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

package/src/irdevice/waterheater.ts

@@ -1,6 +1,8 @@
-import { AxiosResponse } from 'axios';
+import https from 'https';
+import crypto from 'crypto';
+import { IncomingMessage } from 'http';
 import { SwitchBotPlatform } from '../platform';
-import { irDevicesConfig, DeviceURL, irdevice, payload } from '../settings';
+import { irDevicesConfig, irdevice, HostDomain, DevicePath } from '../settings';
 import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 
 /**
@@ -91,37 +93,65 @@ export class WaterHeater {
    */
   async pushWaterHeaterOnChanges(): Promise<void> {
     if (this.Active !== 1) {
-      const payload = {
-        commandType: 'command',
-        parameter: 'default',
-        command: 'turnOn',
-      } as payload;
-      await this.pushChanges(payload);
+      const body = JSON.stringify({
+        'command': 'turnOn',
+        'parameter': 'default',
+        'commandType': 'command',
+      });
+      await this.pushChanges(body);
     }
   }
 
   async pushWaterHeaterOffChanges(): Promise<void> {
     if (this.Active !== 0) {
-      const payload = {
-        commandType: 'command',
-        parameter: 'default',
-        command: 'turnOff',
-      } as payload;
-      await this.pushChanges(payload);
+      const body = JSON.stringify({
+        'command': 'turnOff',
+        'parameter': 'default',
+        'commandType': 'command',
+      });
+      await this.pushChanges(body);
     }
   }
 
-  async pushChanges(payload: payload): Promise<void> {
+  async pushChanges(body): Promise<void> {
     try {
-      this.infoLog(
-        `Water Heater: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
-          ` parameter: ${payload.parameter}, commandType: ${payload.commandType}`,
-      );
-
-      // Make the API request
-      const push = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-      this.debugLog(`Water Heater: ${this.accessory.displayName} pushChanges: ${push.data}`);
-      this.statusCode(push);
+      // Make Push On request to the API
+      const t = Date.now();
+      const nonce = 'requestID';
+      const data = this.platform.config.credentials?.token + t + nonce;
+      const signTerm = crypto.createHmac('sha256', this.platform.config.credentials?.secret)
+        .update(Buffer.from(data, 'utf-8'))
+        .digest();
+      const sign = signTerm.toString('base64');
+      this.debugLog(`Water Heater: ${this.accessory.displayName} sign: ${sign}`);
+      this.infoLog(`Water Heater: ${this.accessory.displayName} Sending request to SwitchBot API. body: ${body},`);
+      const options = {
+        hostname: HostDomain,
+        port: 443,
+        path: `${DevicePath}/${this.device.deviceId}/commands`,
+        method: 'POST',
+        headers: {
+          'Authorization': this.platform.config.credentials?.token,
+          'sign': sign,
+          'nonce': nonce,
+          't': t,
+          'Content-Type': 'application/json',
+          'Content-Length': body.length,
+        },
+      };
+      const req = https.request(options, res => {
+        this.debugLog(`Water Heater: ${this.accessory.displayName} statusCode: ${res.statusCode}`);
+        this.statusCode({ res });
+        res.on('data', d => {
+          this.debugLog(`Water Heater: ${this.accessory.displayName} d: ${d}`);
+        });
+      });
+      req.on('error', (e: any) => {
+        this.errorLog(`Water Heater: ${this.accessory.displayName} error message: ${e.message}`);
+      });
+      req.write(body);
+      req.end();
+      this.debugLog(`Water Heater: ${this.accessory.displayName} pushchanges: ${JSON.stringify(req)}`);
       this.updateHomeKitCharacteristics();
     } catch (e: any) {
       this.errorLog(`Water Heater: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
@@ -134,8 +164,8 @@ export class WaterHeater {
     }
   }
 
-  async statusCode(push: AxiosResponse<{ statusCode: number }>): Promise<void>{
-    switch (push.data.statusCode) {
+  async statusCode({ res }: { res: IncomingMessage }): Promise<void> {
+    switch (res.statusCode) {
       case 151:
         this.errorLog(`Water Heater: ${this.accessory.displayName} Command not supported by this device type.`);
         break;
@@ -154,7 +184,7 @@ export class WaterHeater {
       case 190:
         this.errorLog(
           `Water Heater: ${this.accessory.displayName} Device internal error due to device states not synchronized` +
-            ` with server, Or command: ${JSON.stringify(push.data)} format is invalid`,
+            ` with server, Or command: ${JSON.stringify(res)} format is invalid`,
         );
         break;
       case 100:

package/src/platform.ts

@@ -18,12 +18,13 @@ import { AirPurifier } from './irdevice/airpurifier';
 import { WaterHeater } from './irdevice/waterheater';
 import { VacuumCleaner } from './irdevice/vacuumcleaner';
 import { AirConditioner } from './irdevice/airconditioner';
-import sha256 from 'crypto-js/sha256';
+import https from 'https';
+import crypto from 'crypto';
+import { Buffer } from 'buffer';
 import fakegato from 'fakegato-history';
 import { readFileSync, writeFileSync } from 'fs';
-import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
 import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, Service, Characteristic } from 'homebridge';
-import { PLATFORM_NAME, PLUGIN_NAME, DeviceURL, irdevice, device, SwitchBotPlatformConfig, deviceResponses, devicesConfig } from './settings';
+import { PLATFORM_NAME, PLUGIN_NAME, irdevice, device, SwitchBotPlatformConfig, devicesConfig, DevicePath, HostDomain } from './settings';
 
 /**
  * HomebridgePlatform
@@ -37,12 +38,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   // this is used to track restored cached accessories
   public readonly accessories: PlatformAccessory[] = [];
 
-  public axios: AxiosInstance = axios.create({
-    responseType: 'json',
-  });
-
   version = require('../package.json').version || '1.12.8'; // eslint-disable-line @typescript-eslint/no-var-requires
-  deviceStatus!: deviceResponses;
+  deviceStatus!: any;
   registeringDevice!: boolean;
   debugMode!: boolean;
   platformLogging?: string;
@@ -51,6 +48,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
 
   constructor(public readonly log: Logger, public readonly config: SwitchBotPlatformConfig, public readonly api: API) {
     this.logs();
+
     this.debugLog('Finished initializing platform:', this.config.name);
     // only load if configured
     if (!this.config) {
@@ -74,16 +72,6 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       return;
     }
 
-    // setup axios interceptor to add headers / api key to each request
-    this.axios.interceptors.request.use((request: AxiosRequestConfig) => {
-      request.headers!.Authorization = this.config.credentials?.token;
-      request.headers!.sign = String(sha256(this.config.credentials!.token + Date.now(), this.config.credentials!.secret)).toUpperCase();
-      request.headers!.t = String(Date.now());
-      request.headers!.nonce = '';
-      request.headers!['Content-Type'] = 'application/json; charset=utf8';
-      return request;
-    });
-
     // import fakegato-history module
     this.fakegatoAPI = fakegato(api);
 
@@ -288,90 +276,128 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   async discoverDevices() {
     try {
       if (this.config.credentials?.token) {
-        const devicesAPI: any = (await this.axios.get(DeviceURL)).data;
-        this.deviceListInfo(devicesAPI);
-        this.debugLog(JSON.stringify(devicesAPI));
+        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');
+        this.debugLog(sign);
+        const options = {
+          hostname: HostDomain,
+          port: 443,
+          path: DevicePath,
+          method: 'GET',
+          headers: {
+            'Authorization': this.config.credentials?.token,
+            'sign': sign,
+            'nonce': nonce,
+            't': t,
+            'Content-Type': 'application/json',
+          },
+        };
+        const req = https.request(options, (res) => {
+          this.debugLog(`statusCode: ${res.statusCode}`);
+          this.debugLog(`headers: ${JSON.stringify(res.headers)}`);
+          let rawData = '';
+          res.on('data', (d) => {
+            rawData += d;
+            this.debugLog(`d: ${d}`);
+          });
+          res.on('end', () => {
+            try {
+              const devicesAPI = JSON.parse(rawData);
+              this.debugLog(`devicesAPI: ${JSON.stringify(devicesAPI.body)}`);
+
+              // SwitchBot Devices
+              if (devicesAPI.body.deviceList.length !== 0) {
+                this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+              } else {
+                this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+              }
+              const deviceLists = devicesAPI.body.deviceList;
+              if (!this.config.options?.devices) {
+                this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+                const devices = deviceLists.map((v: any) => 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) {
+                this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+                const deviceConfigs = this.config.options?.devices;
+
+                const mergeBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
+                  a1.map((itm: { deviceId: string }) => ({
+                    ...a2.find(
+                      (item: { deviceId: string }) =>
+                        item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
+                    ),
+                    ...itm,
+                  }));
+
+                const devices = mergeBydeviceId(deviceLists, deviceConfigs);
+                this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+                for (const device of devices) {
+                  if (device.deviceType) {
+                    if (device.configDeviceName) {
+                      device.deviceName = device.configDeviceName;
+                    }
+                    this.createDevice(device);
+                  }
+                }
+              } else {
+                this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
+              }
 
-        // SwitchBot Devices
-        if (devicesAPI.body.deviceList.length !== 0) {
-          this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-        } else {
-          this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-        }
-        const deviceLists = devicesAPI.body.deviceList;
-        if (!this.config.options?.devices) {
-          this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
-          const devices = deviceLists.map((v: any) => v);
-          for (const device of devices) {
-            if (device.deviceType) {
-              if (device.configDeviceName) {
-                device.deviceName = device.configDeviceName;
+              // IR Devices
+              if (devicesAPI.body.infraredRemoteList.length !== 0) {
+                this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+              } else {
+                this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
               }
-              this.createDevice(device);
-            }
-          }
-        } else if (this.config.credentials.token && this.config.options.devices) {
-          this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
-          const deviceConfigs = this.config.options?.devices;
-
-          const mergeBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
-            a1.map((itm: { deviceId: string }) => ({
-              ...a2.find(
-                (item: { deviceId: string }) =>
-                  item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
-              ),
-              ...itm,
-            }));
-
-          const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-          this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
-          for (const device of devices) {
-            if (device.deviceType) {
-              if (device.configDeviceName) {
-                device.deviceName = device.configDeviceName;
+              const irDeviceLists = devicesAPI.body.infraredRemoteList;
+              if (!this.config.options?.irdevices) {
+                this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                const devices = irDeviceLists.map((v: any) => v);
+                for (const device of devices) {
+                  if (device.remoteType) {
+                    this.createIRDevice(device);
+                  }
+                }
+              } else {
+                this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+                const irDeviceConfig = this.config.options?.irdevices;
+
+                const mergeIRBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
+                  a1.map((itm: { deviceId: string }) => ({
+                    ...a2.find(
+                      (item: { deviceId: string }) =>
+                        item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
+                    ),
+                    ...itm,
+                  }));
+
+                const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
+                this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+                for (const device of devices) {
+                  if (device.remoteType) {
+                    this.createIRDevice(device);
+                  }
+                }
               }
-              this.createDevice(device);
-            }
-          }
-        } else {
-          this.errorLog('Neither SwitchBot Token or Device Config are not set.');
-        }
-        // IR Devices
-        if (devicesAPI.body.infraredRemoteList.length !== 0) {
-          this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-        } else {
-          this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-        }
-        const irDeviceLists = devicesAPI.body.infraredRemoteList;
-        if (!this.config.options?.irdevices) {
-          this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-          const devices = irDeviceLists.map((v: any) => v);
-          for (const device of devices) {
-            if (device.remoteType) {
-              this.createIRDevice(device);
+            } catch (e:any) {
+              this.errorLog(e.message);
             }
-          }
-        } else {
-          this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-          const irDeviceConfig = this.config.options?.irdevices;
-
-          const mergeIRBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
-            a1.map((itm: { deviceId: string }) => ({
-              ...a2.find(
-                (item: { deviceId: string }) =>
-                  item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
-              ),
-              ...itm,
-            }));
-
-          const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-          this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
-          for (const device of devices) {
-            if (device.remoteType) {
-              this.createIRDevice(device);
-            }
-          }
-        }
+          });
+        });
+        req.on('error', (error) => {
+          this.errorLog(error);
+        });
+        req.end();
       } else if (!this.config.credentials?.token && this.config.options?.devices) {
         this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
         const deviceConfigs = this.config.options?.devices;
@@ -1744,7 +1770,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     this.warnLog(`Removing existing accessory from cache: ${existingAccessory.displayName}`);
   }
 
-  public deviceListInfo(devices: deviceResponses) {
+  public deviceListInfo(devices) {
     if (this.platformLogging?.includes('debug')) {
       this.warnLog(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
     }
@@ -1753,7 +1779,38 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   public async deviceInfo(device: (irdevice & devicesConfig) | (device & devicesConfig)) {
     if (this.platformLogging?.includes('debug')) {
       this.warnLog(JSON.stringify(device));
-      this.deviceStatus = (await this.axios.get(`${DeviceURL}/${device.deviceId}/status`)).data;
+
+      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');
+      this.debugLog(sign);
+      const options = {
+        hostname: HostDomain,
+        port: 443,
+        path: `${DevicePath}/${device.deviceId}/status`,
+        method: 'GET',
+        headers: {
+          Authorization: this.config.credentials?.token,
+          sign: sign,
+          nonce: nonce,
+          t: t,
+          'Content-Type': 'application/json',
+        },
+      };
+      const req = https.request(options, (res) => {
+        this.debugLog(`statusCode: ${res.statusCode}`);
+        res.on('data', (d) => {
+          process.stdout.write(d);
+        });
+      });
+      req.on('error', (error) => {
+        this.errorLog(error);
+      });
+      req.end();
+
+      this.deviceStatus = req;
       if (this.deviceStatus.message === 'success') {
         this.warnLog(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus)}`);
       } else {

package/src/settings.ts

@@ -13,12 +13,12 @@ export const PLUGIN_NAME = '@switchbot/homebridge-switchbot';
 /**
  * This is the main url used to access SwitchBot API
  */
-export const AuthURL = 'https://api.switch-bot.com';
+export const HostDomain = 'api.switch-bot.com';
 
 /**
  * This is the main url used to access SwitchBot API
  */
-export const DeviceURL = 'https://api.switch-bot.com/v1.1/devices';
+export const DevicePath = '/v1.1/devices';
 
 //Config
 export interface SwitchBotPlatformConfig extends PlatformConfig {
@@ -177,23 +177,6 @@ export type other = {
   commandOff?: string;
 };
 
-export type payload = {
-  commandType: string;
-  parameter: string;
-  command: string;
-};
-
-export interface AxiosRequestConfig {
-  params?: Record<string, unknown>;
-  headers?: any;
-}
-
-export type deviceResponses = {
-  statusCode: number | string;
-  message: string;
-  body: deviceList | infraredRemoteList;
-};
-
 //a list of physical devices.
 export type deviceList = {
   device: Array<device>;
@@ -236,12 +219,6 @@ export type irdevice = {
   hubDeviceId: string; //remote device's parent Hub ID
 };
 
-export type deviceStatusResponse = {
-  statusCode: number;
-  message: string;
-  body: deviceStatus;
-};
-
 export type deviceStatus = {
   //device ID.
   deviceId: string;