@pipechela/ewelink-api 1.0.0

package/src/data/devices-channel-length.json

@@ -0,0 +1,20 @@
+{
+  "SOCKET": 1,
+  "SWITCH_CHANGE": 1,
+  "GSM_UNLIMIT_SOCKET": 1,
+  "SWITCH": 1,
+  "THERMOSTAT": 1,
+  "SOCKET_POWER": 1,
+  "GSM_SOCKET": 1,
+  "POWER_DETECTION_SOCKET": 1,
+  "SOCKET_2": 2,
+  "GSM_SOCKET_2": 2,
+  "SWITCH_2": 2,
+  "SOCKET_3": 3,
+  "GSM_SOCKET_3": 3,
+  "SWITCH_3": 3,
+  "SOCKET_4": 4,
+  "GSM_SOCKET_4": 4,
+  "SWITCH_4": 4,
+  "CUN_YOU_DOOR": 4
+}

package/src/data/devices-type-uuid.json

@@ -0,0 +1,55 @@
+{
+  "1": "SOCKET",
+  "2": "SOCKET_2",
+  "3": "SOCKET_3",
+  "4": "SOCKET_4",
+  "6": "SWITCH",
+  "5": "SOCKET_POWER",
+  "7": "SWITCH_2",
+  "8": "SWITCH_3",
+  "9": "SWITCH_4",
+  "10": "OSPF",
+  "11": "CURTAIN",
+  "12": "EW-RE",
+  "13": "FIREPLACE",
+  "14": "SWITCH_CHANGE",
+  "15": "THERMOSTAT",
+  "16": "COLD_WARM_LED",
+  "17": "THREE_GEAR_FAN",
+  "18": "SENSORS_CENTER",
+  "19": "HUMIDIFIER",
+  "22": "RGB_BALL_LIGHT",
+  "23": "NEST_THERMOSTAT",
+  "24": "GSM_SOCKET",
+  "25": "AROMATHERAPY",
+  "26": "BJ_THERMOSTAT",
+  "27": "GSM_UNLIMIT_SOCKET",
+  "28": "RF_BRIDGE",
+  "29": "GSM_SOCKET_2",
+  "30": "GSM_SOCKET_3",
+  "31": "GSM_SOCKET_4",
+  "32": "POWER_DETECTION_SOCKET",
+  "33": "LIGHT_BELT",
+  "34": "FAN_LIGHT",
+  "35": "EZVIZ_CAMERA",
+  "36": "SINGLE_CHANNEL_DIMMER_SWITCH",
+  "38": "HOME_KIT_BRIDGE",
+  "40": "FUJIN_OPS",
+  "41": "CUN_YOU_DOOR",
+  "42": "SMART_BEDSIDE_AND_NEW_RGB_BALL_LIGHT",
+  "43": "",
+  "44": "",
+  "45": "DOWN_CEILING_LIGHT",
+  "46": "AIR_CLEANER",
+  "49": "MACHINE_BED",
+  "51": "COLD_WARM_DESK_LIGHT",
+  "52": "DOUBLE_COLOR_DEMO_LIGHT",
+  "53": "ELECTRIC_FAN_WITH_LAMP",
+  "55": "SWEEPING_ROBOT",
+  "56": "RGB_BALL_LIGHT_4",
+  "57": "MONOCHROMATIC_BALL_LIGHT",
+  "59": "MEARICAMERA",
+  "1001": "BLADELESS_FAN",
+  "1002": "NEW_HUMIDIFIER",
+  "1003": "WARM_AIR_BLOWER"
+}

package/src/data/errors.js

@@ -0,0 +1,23 @@
+const errors = {
+  400: 'Parameter error',
+  401: 'Wrong account or password',
+  402: 'Email inactivated',
+  403: 'Forbidden',
+  404: 'Device does not exist',
+  406: 'Authentication failed',
+  503: 'Service Temporarily Unavailable or Device is offline'
+};
+
+const customErrors = {
+  ch404: 'Device channel does not exist',
+  unknown: 'An unknown error occurred',
+  noDevices: 'No devices found',
+  noPower: 'No power usage data found',
+  noSensor: "Can't read sensor data from device",
+  noFirmware: "Can't get model or firmware version",
+  invalidAuth: 'Library needs to be initialized using email and password',
+  invalidCredentials: 'Invalid credentials provided',
+  invalidPowerState: 'Invalid power state. Expecting: "on", "off" or "toggle"',
+};
+
+module.exports = Object.assign(errors, customErrors);

package/src/helpers/device-control.js

@@ -0,0 +1,58 @@
+const STATE_ON = 'on';
+const STATE_OFF = 'off';
+const STATE_TOGGLE = 'toggle';
+
+const VALID_POWER_STATES = [STATE_ON, STATE_OFF, STATE_TOGGLE];
+
+/**
+ * Return new device state based on current conditions
+ */
+const getNewPowerState = (currentState, newState) => {
+  if (newState !== STATE_TOGGLE) {
+    return newState;
+  }
+  return currentState === STATE_ON ? STATE_OFF : STATE_ON;
+};
+
+/**
+ * Get current device parameters and
+ */
+const getPowerStateParams = (params, newState, channel) => {
+  if (params.switches) {
+    const switches = [...params.switches];
+    const channelToSwitch = channel - 1;
+    switches[channelToSwitch].switch = newState;
+    return { switches };
+  }
+  return { switch: newState };
+};
+
+/**
+ * Return status of all channels on a multi-channel device
+ */
+const getAllChannelsState = params => {
+  const { switches } = params;
+  return switches.map(ch => ({
+    channel: ch.outlet + 1,
+    state: ch.switch,
+  }));
+};
+
+/**
+ * Return status of specific channel on multi-channel device
+ */
+const getSpecificChannelState = (params, channel) => {
+  const { switches } = params;
+  return switches[channel - 1].switch;
+};
+
+module.exports = {
+  STATE_ON,
+  STATE_OFF,
+  STATE_TOGGLE,
+  VALID_POWER_STATES,
+  getNewPowerState,
+  getPowerStateParams,
+  getAllChannelsState,
+  getSpecificChannelState,
+};

package/src/helpers/ewelink.js

@@ -0,0 +1,68 @@
+const crypto = require('crypto');
+const CryptoJS = require('crypto-js');
+const random = require('random');
+
+const DEVICE_TYPE_UUID = require('../data/devices-type-uuid.json');
+const DEVICE_CHANNEL_LENGTH = require('../data/devices-channel-length.json');
+
+const makeAuthorizationSign = (APP_SECRET, body) =>
+  crypto
+    .createHmac('sha256', APP_SECRET)
+    .update(JSON.stringify(body))
+    .digest('base64');
+
+const getDeviceTypeByUiid = uiid => DEVICE_TYPE_UUID[uiid] || '';
+
+const getDeviceChannelCountByType = deviceType =>
+  DEVICE_CHANNEL_LENGTH[deviceType] || 0;
+
+const getDeviceChannelCount = deviceUUID => {
+  const deviceType = getDeviceTypeByUiid(deviceUUID);
+  return getDeviceChannelCountByType(deviceType);
+};
+
+const create16Uiid = () => {
+  let result = '';
+  for (let i = 0; i < 16; i += 1) {
+    result += random.int(0, 9);
+  }
+  return result;
+};
+
+const encryptionBase64 = t =>
+  CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(t));
+
+const decryptionBase64 = t =>
+  CryptoJS.enc.Base64.parse(t).toString(CryptoJS.enc.Utf8);
+
+const encryptationData = (data, key) => {
+  const encryptedMessage = {};
+  const uid = create16Uiid();
+  const iv = encryptionBase64(uid);
+  const code = CryptoJS.AES.encrypt(data, CryptoJS.MD5(key), {
+    iv: CryptoJS.enc.Utf8.parse(uid),
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.Pkcs7,
+  });
+  encryptedMessage.uid = uid;
+  encryptedMessage.iv = iv;
+  encryptedMessage.data = code.ciphertext.toString(CryptoJS.enc.Base64);
+  return encryptedMessage;
+};
+
+const decryptionData = (data, key, iv) => {
+  const iv64 = decryptionBase64(iv);
+  const code = CryptoJS.AES.decrypt(data, CryptoJS.MD5(key), {
+    iv: CryptoJS.enc.Utf8.parse(iv64),
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.Pkcs7,
+  });
+  return code.toString(CryptoJS.enc.Utf8);
+};
+
+module.exports = {
+  makeAuthorizationSign,
+  getDeviceChannelCount,
+  encryptationData,
+  decryptionData,
+};

package/src/helpers/utilities.js

@@ -0,0 +1,29 @@
+const nonce = Math.random()
+  .toString(36)
+  .slice(5);
+
+const timestamp = Math.floor(new Date() / 1000);
+
+const _get = (obj, path, defaultValue = null) =>
+  String.prototype.split
+    .call(path, /[,[\].]+?/)
+    .filter(Boolean)
+    .reduce(
+      (a, c) => (Object.hasOwnProperty.call(a, c) ? a[c] : defaultValue),
+      obj
+    );
+
+const _empty = obj => Object.entries(obj).length === 0;
+
+const toQueryString = object =>
+  `?${Object.keys(object)
+    .map(key => `${key}=${object[key].toString()}`)
+    .join('&')}`;
+
+module.exports = {
+  nonce,
+  timestamp,
+  _get,
+  _empty,
+  toQueryString,
+};

package/src/mixins/checkDeviceUpdate.js

@@ -0,0 +1,48 @@
+const { _get } = require('../helpers/utilities');
+const parseFirmwareUpdates = require('../parsers/parseFirmwareUpdates');
+
+module.exports = {
+  /**
+   * Check device firmware update
+   *
+   * @param deviceId
+   *
+   * @returns {Promise<{msg: string, version: *}|{msg: string, error: number}|{msg: string, error: *}|Device|{msg: string}>}
+   */
+  async checkDeviceUpdate(deviceId) {
+    const device = await this.getDevice(deviceId);
+
+    const error = _get(device, 'error', false);
+
+    if (error) {
+      return device;
+    }
+
+    const deviceInfoList = parseFirmwareUpdates([device]);
+
+    const deviceInfoListError = _get(deviceInfoList, 'error', false);
+
+    if (deviceInfoListError) {
+      return deviceInfoList;
+    }
+
+    const update = await this.makeRequest({
+      method: 'post',
+      url: this.getOtaUrl(),
+      uri: '/app',
+      body: { deviceInfoList },
+    });
+
+    const isUpdate = _get(update, 'upgradeInfoList.0.version', false);
+
+    if (!isUpdate) {
+      return { status: 'ok', msg: 'No update available' };
+    }
+
+    return {
+      status: 'ok',
+      msg: 'Update available',
+      version: isUpdate,
+    };
+  },
+};

package/src/mixins/checkDevicesUpdates.js

@@ -0,0 +1,54 @@
+const { _get } = require('../helpers/utilities');
+const parseFirmwareUpdates = require('../parsers/parseFirmwareUpdates');
+
+module.exports = {
+  async checkDevicesUpdates() {
+    const devices = await this.getDevices();
+
+    const error = _get(devices, 'error', false);
+
+    if (error) {
+      return devices;
+    }
+
+    const deviceInfoList = parseFirmwareUpdates(devices);
+
+    const deviceInfoListError = _get(deviceInfoList, 'error', false);
+
+    if (deviceInfoListError) {
+      return deviceInfoList;
+    }
+
+    const updates = await this.makeRequest({
+      method: 'post',
+      url: this.getOtaUrl(),
+      uri: '/app',
+      body: { deviceInfoList },
+    });
+
+    const upgradeInfoList = _get(updates, 'upgradeInfoList', false);
+
+    if (!upgradeInfoList) {
+      return { error: "Can't find firmware update information" };
+    }
+
+    return upgradeInfoList.map(device => {
+      const upd = _get(device, 'version', false);
+
+      if (!upd) {
+        return {
+          status: 'ok',
+          deviceId: device.deviceid,
+          msg: 'No update available',
+        };
+      }
+
+      return {
+        status: 'ok',
+        deviceId: device.deviceid,
+        msg: 'Update available',
+        version: upd,
+      };
+    });
+  },
+};

package/src/mixins/deviceControl.js

@@ -0,0 +1,272 @@
+const W3CWebSocket = require('websocket').w3cwebsocket;
+const WebSocketAsPromised = require('websocket-as-promised');
+const delay = require('delay');
+
+const { nonce, timestamp } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+const {
+  VALID_POWER_STATES,
+  getNewPowerState,
+  getPowerStateParams,
+  getAllChannelsState,
+  getSpecificChannelState,
+} = require('../helpers/device-control');
+
+module.exports = {
+  async initDeviceControl(params = {}) {
+    // check if socket is already initialized
+    if (this.wsp) {
+      return;
+    }
+
+    const { APP_ID, at, apiKey } = this;
+
+    // set delay between socket messages
+    const { delayTime = 1000 } = params;
+    this.wsDelayTime = delayTime;
+
+    // request credentials if needed
+    if (at === null || apiKey === null) {
+      await this.getCredentials();
+    }
+
+    // request distribution service
+    const dispatch = await this.makeRequest({
+      method: 'post',
+      url: `https://${this.region}-api.coolkit.cc:8080`,
+      uri: '/dispatch/app',
+      body: {
+        accept: 'ws',
+        appid: APP_ID,
+        nonce,
+        ts: timestamp,
+        version: 8,
+      },
+    });
+
+    // WebSocket parameters
+    const WSS_URL = `wss://${dispatch.domain}:${dispatch.port}/api/ws`;
+    const WSS_CONFIG = { createWebSocket: wss => new W3CWebSocket(wss) };
+
+    // open WebSocket connection
+    this.wsp = new WebSocketAsPromised(WSS_URL, WSS_CONFIG);
+
+    // catch autentication errors
+    let socketError;
+    this.wsp.onMessage.addListener(async message => {
+      const data = JSON.parse(message);
+      if (data.error) {
+        socketError = data;
+        await this.webSocketClose();
+      }
+    });
+
+    // open socket connection
+    await this.wsp.open();
+
+    // WebSocket handshake
+    await this.webSocketHandshake();
+
+    // if auth error exists, throw an error
+    if (socketError) {
+      throw new Error(errors[socketError.error]);
+    }
+  },
+
+  /**
+   * WebSocket authentication process
+   */
+  async webSocketHandshake() {
+    const apikey = this.deviceApiKey || this.apiKey;
+
+    const payload = JSON.stringify({
+      action: 'userOnline',
+      version: 8,
+      ts: timestamp,
+      at: this.at,
+      userAgent: 'app',
+      apikey,
+      appid: this.APP_ID,
+      nonce,
+      sequence: Math.floor(timestamp * 1000),
+    });
+
+    await this.wsp.send(payload);
+    await delay(this.wsDelayTime);
+  },
+
+  /**
+   * Close WebSocket connection and class cleanup
+   */
+  async webSocketClose() {
+    await this.wsp.close();
+    delete this.wsDelayTime;
+    delete this.wsp;
+    delete this.deviceApiKey;
+  },
+
+  /**
+   * Update device status (timers, share status, on/off etc)
+   */
+  async updateDeviceStatus(deviceId, params) {
+    await this.initDeviceControl();
+
+    const apikey = this.deviceApiKey || this.apiKey;
+
+    const payload = JSON.stringify({
+      action: 'update',
+      deviceid: deviceId,
+      apikey,
+      userAgent: 'app',
+      sequence: Math.floor(timestamp * 1000),
+      ts: timestamp,
+      params,
+    });
+
+    return this.wsp.send(payload);
+  },
+
+  /**
+   * Check device status (timers, share status, on/off etc)
+   */
+  async getWSDeviceStatus(deviceId, params) {
+    await this.initDeviceControl();
+
+    let response = null;
+
+    this.wsp.onMessage.addListener(message => {
+      const data = JSON.parse(message);
+      if (data.deviceid === deviceId) {
+        response = data;
+      }
+    });
+
+    const apikey = this.deviceApiKey || this.apiKey;
+
+    const payload = JSON.stringify({
+      action: 'query',
+      deviceid: deviceId,
+      apikey,
+      userAgent: 'app',
+      sequence: Math.floor(timestamp * 1000),
+      ts: timestamp,
+      params,
+    });
+
+    this.wsp.send(payload);
+    await delay(this.wsDelayTime);
+
+    // throw error on invalid device
+    if (response.error) {
+      throw new Error(errors[response.error]);
+    }
+
+    return response;
+  },
+
+  /**
+   * Get device power state
+   */
+  async getWSDevicePowerState(deviceId, options = {}) {
+    // get extra parameters
+    const { channel = 1, allChannels = false, shared = false } = options;
+
+    // if device is shared by other account, fetch device api key
+    if (shared) {
+      const device = await this.getDevice(deviceId);
+      this.deviceApiKey = device.apikey;
+    }
+
+    // get device current state
+    const status = await this.getWSDeviceStatus(deviceId, [
+      'switch',
+      'switches',
+    ]);
+
+    // close websocket connection
+    await this.webSocketClose();
+
+    // check for multi-channel device
+    const multiChannelDevice = !!status.params.switches;
+
+    // returns all channels
+    if (multiChannelDevice && allChannels) {
+      return {
+        status: 'ok',
+        state: getAllChannelsState(status.params),
+      };
+    }
+
+    // multi-channel device & requested channel
+    if (multiChannelDevice) {
+      return {
+        status: 'ok',
+        state: getSpecificChannelState(status.params, channel),
+        channel,
+      };
+    }
+
+    // single channel device
+    return {
+      status: 'ok',
+      state: status.params.switch,
+      channel,
+    };
+  },
+
+  /**
+   * Set device power state
+   */
+  async setWSDevicePowerState(deviceId, state, options = {}) {
+    // check for valid power state
+    if (!VALID_POWER_STATES.includes(state)) {
+      throw new Error(errors.invalidPowerState);
+    }
+
+    // get extra parameters
+    const { channel = 1, shared = false } = options;
+
+    // if device is shared by other account, fetch device api key
+    if (shared) {
+      const device = await this.getDevice(deviceId);
+      this.deviceApiKey = device.apikey;
+    }
+
+    // get device current state
+    const status = await this.getWSDeviceStatus(deviceId, [
+      'switch',
+      'switches',
+    ]);
+
+    // check for multi-channel device
+    const multiChannelDevice = !!status.params.switches;
+
+    // get current device state
+    const currentState = multiChannelDevice
+      ? status.params.switches[channel - 1].switch
+      : status.params.switch;
+
+    // resolve new power state
+    const stateToSwitch = getNewPowerState(currentState, state);
+
+    // build request payload
+    const params = getPowerStateParams(status.params, stateToSwitch, channel);
+
+    // change device status
+    try {
+      await this.updateDeviceStatus(deviceId, params);
+      await delay(this.wsDelayTime);
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      await this.webSocketClose();
+    }
+
+    return {
+      status: 'ok',
+      state: stateToSwitch,
+      channel: multiChannelDevice ? channel : 1,
+    };
+  },
+};

package/src/mixins/getCredentials.js

@@ -0,0 +1,54 @@
+const fetch = require('node-fetch');
+
+const { _get } = require('../helpers/utilities');
+const credentialsPayload = require('../payloads/credentialsPayload');
+const { makeAuthorizationSign } = require('../helpers/ewelink');
+const errors = require('../data/errors');
+
+module.exports = {
+  /**
+   * Returns user credentials information
+   *
+   * @returns {Promise<{msg: string, error: *}>}
+   */
+  async getCredentials() {
+    const { APP_ID, APP_SECRET } = this;
+
+    const body = credentialsPayload({
+      appid: APP_ID,
+      email: this.email,
+      phoneNumber: this.phoneNumber,
+      password: this.password,
+    });
+
+    const request = await fetch(`${this.getApiUrl()}/user/login`, {
+      method: 'post',
+      headers: {
+        Authorization: `Sign ${makeAuthorizationSign(APP_SECRET, body)}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    let response = await request.json();
+
+    const error = _get(response, 'error', false);
+    const region = _get(response, 'region', false);
+
+    if (error && [400, 401, 404].indexOf(parseInt(error)) !== -1) {
+      return { error: 406, msg: errors['406'] };
+    }
+
+    if (error && parseInt(error) === 301 && region) {
+      if (this.region !== region) {
+        this.region = region;
+        response = await this.getCredentials();
+        return response;
+      }
+      return { error, msg: 'Region does not exist' };
+    }
+
+    this.apiKey = _get(response, 'user.apikey', '');
+    this.at = _get(response, 'at', '');
+    return response;
+  },
+};