@pipechela/ewelink-api 1.0.0

package/src/mixins/getDevice.js

@@ -0,0 +1,37 @@
+const { nonce, timestamp, _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+module.exports = {
+  /**
+   * Get information for a specific device
+   *
+   * @param deviceId
+   * @returns {Promise<*|null|{msg: string, error: *}>}
+   */
+  async getDevice(deviceId) {
+    if (this.devicesCache) {
+      return this.devicesCache.find(dev => dev.deviceid === deviceId) || null;
+    }
+
+    const { APP_ID } = this;
+
+    const device = await this.makeRequest({
+      uri: `/user/device/${deviceId}`,
+      qs: {
+        deviceid: deviceId,
+        appid: APP_ID,
+        nonce,
+        ts: timestamp,
+        version: 8,
+      },
+    });
+
+    const error = _get(device, 'error', false);
+
+    if (error) {
+      return { error, msg: errors[error] };
+    }
+
+    return device;
+  },
+};

package/src/mixins/getDeviceChannelCount.js

@@ -0,0 +1,26 @@
+const { _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+const { getDeviceChannelCount } = require('../helpers/ewelink');
+
+module.exports = {
+  /**
+   * Get device channel count
+   *
+   * @param deviceId
+   *
+   * @returns {Promise<{switchesAmount: *, status: string}|{msg: string, error: *}>}
+   */
+  async getDeviceChannelCount(deviceId) {
+    const device = await this.getDevice(deviceId);
+    const error = _get(device, 'error', false);
+    const uiid = _get(device, 'extra.extra.uiid', false);
+    const switchesAmount = getDeviceChannelCount(uiid);
+
+    if (error) {
+      return { error, msg: errors[error] };
+    }
+
+    return { status: 'ok', switchesAmount };
+  },
+};

package/src/mixins/getDeviceCurrentTH.js

@@ -0,0 +1,55 @@
+const { _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+module.exports = {
+  /**
+   * Get device current temperature & humidity
+   * @param deviceId
+   * @param type
+   * @returns {Promise<{temperature: *, humidity: *, status: string}|{msg: string, error: *}>}
+   */
+  async getDeviceCurrentTH(deviceId, type = '') {
+    const device = await this.getDevice(deviceId);
+    const error = _get(device, 'error', false);
+    const temperature = _get(device, 'params.currentTemperature', false);
+    const humidity = _get(device, 'params.currentHumidity', false);
+
+    if (error) {
+      return device;
+    }
+
+    if (!temperature || !humidity) {
+      return { error: 404, msg: errors.noSensor };
+    }
+
+    const data = { status: 'ok', temperature, humidity };
+
+    if (type === 'temp') {
+      delete data.humidity;
+    }
+
+    if (type === 'humd') {
+      delete data.temperature;
+    }
+
+    return data;
+  },
+
+  /**
+   * Get device current temperature
+   * @param deviceId
+   * @returns {Promise<*|{temperature: *, status: string}|{msg: string, error: *}>}
+   */
+  async getDeviceCurrentTemperature(deviceId) {
+    return this.getDeviceCurrentTH(deviceId, 'temp');
+  },
+
+  /**
+   * Get device current humidity
+   * @param deviceId
+   * @returns {Promise<*|{temperature: *, status: string}|{msg: string, error: *}>}
+   */
+  async getDeviceCurrentHumidity(deviceId) {
+    return this.getDeviceCurrentTH(deviceId, 'humd');
+  },
+};

package/src/mixins/getDeviceIP.js

@@ -0,0 +1,15 @@
+module.exports = {
+  /**
+   * Get local IP address from a given MAC
+   *
+   * @param device
+   * @returns {Promise<string>}
+   */
+  getDeviceIP(device) {
+    const mac = device.extra.extra.staMac;
+    const arpItem = this.arpTable.find(
+      item => item.mac.toLowerCase() === mac.toLowerCase()
+    );
+    return arpItem.ip;
+  },
+};

package/src/mixins/getDevicePowerState.js

@@ -0,0 +1,47 @@
+const { _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+const deviceStatusPayload = require('../payloads/deviceStatus');
+
+module.exports = {
+  /**
+   * Get current power state for a specific device
+   *
+   * @param deviceId
+   * @param channel
+   *
+   * @returns {Promise<{state: *, status: string}|{msg: string, error: *}>}
+   */
+  async getDevicePowerState(deviceId, channel = 1) {
+    const status = await this.makeRequest({
+      uri: '/user/device/status',
+      qs: deviceStatusPayload({
+        appid: this.APP_ID,
+        deviceId,
+        params: 'switch|switches',
+      }),
+    });
+
+    const error = _get(status, 'error', false);
+
+    if (error) {
+      const err = error === 400 ? 404 : error;
+      return { error: err, msg: errors[err] };
+    }
+
+    let state = _get(status, 'params.switch', false);
+    const switches = _get(status, 'params.switches', false);
+
+    const switchesAmount = switches ? switches.length : 1;
+
+    if (switchesAmount > 0 && switchesAmount < channel) {
+      return { error: 404, msg: errors.ch404 };
+    }
+
+    if (switches) {
+      state = switches[channel - 1].switch;
+    }
+
+    return { status: 'ok', state, channel };
+  },
+};

package/src/mixins/getDevicePowerUsage.js

@@ -0,0 +1,27 @@
+const { _get } = require('../helpers/utilities');
+const parsePowerUsage = require('../parsers/parsePowerUsage');
+
+module.exports = {
+  /**
+   * Get device power usage for current month
+   *
+   * @param deviceId
+   *
+   * @returns {Promise<{error: string}|{daily: *, monthly: *}>}
+   */
+  async getDevicePowerUsage(deviceId) {
+    const response = await this.getDevicePowerUsageRaw(deviceId);
+
+    const error = _get(response, 'error', false);
+    const hundredDaysKwhData = _get(response, 'data.hundredDaysKwhData', false);
+
+    if (error) {
+      return response;
+    }
+
+    return {
+      status: 'ok',
+      ...parsePowerUsage({ hundredDaysKwhData }),
+    };
+  },
+};

package/src/mixins/getDevicePowerUsageRaw.js

@@ -0,0 +1,30 @@
+const { _get } = require('../helpers/utilities');
+
+const DevicePowerUsageRaw = require('../classes/DevicePowerUsageRaw');
+
+module.exports = {
+  /**
+   * Get device raw power usage
+   *
+   * @param deviceId
+   *
+   * @returns {Promise<{error: string}|{response: {hundredDaysKwhData: *}, status: string}>}
+   */
+  async getDevicePowerUsageRaw(deviceId) {
+    const device = await this.getDevice(deviceId);
+    const deviceApiKey = _get(device, 'apikey', false);
+
+    const actionParams = {
+      apiUrl: this.getApiWebSocket(),
+      at: this.at,
+      apiKey: this.apiKey,
+      deviceId,
+    };
+
+    if (this.apiKey !== deviceApiKey) {
+      actionParams.apiKey = deviceApiKey;
+    }
+
+    return DevicePowerUsageRaw.get(actionParams);
+  },
+};

package/src/mixins/getDevices.js

@@ -0,0 +1,37 @@
+const { _get, timestamp } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+module.exports = {
+  /**
+   * Get all devices information
+   *
+   * @returns {Promise<{msg: string, error: number}|*>}
+   */
+  async getDevices() {
+    const { APP_ID } = this;
+
+    const response = await this.makeRequest({
+      uri: '/user/device',
+      qs: {
+        lang: 'en',
+        appid: APP_ID,
+        ts: timestamp,
+        version: 8,
+        getTags: 1,
+      },
+    });
+
+    const error = _get(response, 'error', false);
+    const devicelist = _get(response, 'devicelist', false);
+
+    if (error) {
+      return { error, msg: errors[error] };
+    }
+
+    if (!devicelist) {
+      return { error: 404, msg: errors.noDevices };
+    }
+
+    return devicelist;
+  },
+};

package/src/mixins/getFirmwareVersion.js

@@ -0,0 +1,23 @@
+const { _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+module.exports = {
+  /**
+   * Get device firmware version
+   *
+   * @param deviceId
+   *
+   * @returns {Promise<{fwVersion: *, status: string}|{msg: string, error: *}>}
+   */
+  async getFirmwareVersion(deviceId) {
+    const device = await this.getDevice(deviceId);
+    const error = _get(device, 'error', false);
+    const fwVersion = _get(device, 'params.fwVersion', false);
+
+    if (error || !fwVersion) {
+      return { error, msg: errors[error] };
+    }
+
+    return { status: 'ok', fwVersion };
+  },
+};

package/src/mixins/getRegion.js

@@ -0,0 +1,23 @@
+const { _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+module.exports = {
+  async getRegion() {
+    if (!this.email || !this.password) {
+      return { error: 406, msg: errors.invalidAuth };
+    }
+
+    const credentials = await this.getCredentials();
+
+    const error = _get(credentials, 'error', false);
+
+    if (error) {
+      return credentials;
+    }
+
+    return {
+      email: credentials.user.email,
+      region: credentials.region,
+    };
+  },
+};

package/src/mixins/index.js

@@ -0,0 +1,43 @@
+const { checkDevicesUpdates } = require('./checkDevicesUpdates');
+const { checkDeviceUpdate } = require('./checkDeviceUpdate');
+const deviceControl = require('./deviceControl');
+const { getCredentials } = require('./getCredentials');
+const { getDevice } = require('./getDevice');
+const { getDeviceChannelCount } = require('./getDeviceChannelCount');
+const getDeviceCurrentTH = require('./getDeviceCurrentTH');
+const { getDeviceIP } = require('./getDeviceIP');
+const { getDevicePowerState } = require('./getDevicePowerState');
+const { getDevicePowerUsage } = require('./getDevicePowerUsage');
+const { getDevicePowerUsageRaw } = require('./getDevicePowerUsageRaw');
+const { getDevices } = require('./getDevices');
+const { getFirmwareVersion } = require('./getFirmwareVersion');
+const { getRegion } = require('./getRegion');
+const { makeRequest } = require('./makeRequest');
+const { openWebSocket } = require('./openWebSocket');
+const { saveDevicesCache } = require('./saveDevicesCache');
+const { setDevicePowerState } = require('./setDevicePowerState');
+const { toggleDevice } = require('./toggleDevice');
+
+const mixins = {
+  checkDevicesUpdates,
+  checkDeviceUpdate,
+  ...deviceControl,
+  getCredentials,
+  getDevice,
+  getDeviceChannelCount,
+  ...getDeviceCurrentTH,
+  getDeviceIP,
+  getDevicePowerState,
+  getDevicePowerUsage,
+  getDevicePowerUsageRaw,
+  getDevices,
+  getFirmwareVersion,
+  getRegion,
+  makeRequest,
+  openWebSocket,
+  saveDevicesCache,
+  setDevicePowerState,
+  toggleDevice,
+};
+
+module.exports = mixins;

package/src/mixins/makeRequest.js

@@ -0,0 +1,54 @@
+const fetch = require('node-fetch');
+const { _get, _empty, toQueryString } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+module.exports = {
+  /**
+   * Helper to make api requests
+   *
+   * @param method
+   * @param url
+   * @param uri
+   * @param body
+   * @param qs
+   * @returns {Promise<{msg: *, error: *}|*>}
+   */
+  async makeRequest({ method = 'get', url, uri, body = {}, qs = {} }) {
+    const { at } = this;
+
+    if (!at) {
+      await this.getCredentials();
+    }
+
+    let apiUrl = this.getApiUrl();
+
+    if (url) {
+      apiUrl = url;
+    }
+
+    const payload = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.at}`,
+        'Content-Type': 'application/json',
+      },
+    };
+
+    if (!_empty(body)) {
+      payload.body = JSON.stringify(body);
+    }
+
+    const queryString = !_empty(qs) ? toQueryString(qs) : '';
+    const requestUrl = `${apiUrl}${uri}${queryString}`;
+
+    const request = await fetch(requestUrl, payload);
+
+    if (!request.ok) {
+      return { error: request.status, msg: errors[request.status] };
+    }
+
+    const response = await request.json();
+
+    return response
+  },
+};

package/src/mixins/openWebSocket.js

@@ -0,0 +1,44 @@
+const W3CWebSocket = require('websocket').w3cwebsocket;
+const WebSocketAsPromised = require('websocket-as-promised');
+
+const wssLoginPayload = require('../payloads/wssLoginPayload');
+
+module.exports = {
+  /**
+   * Open a socket connection to eWeLink
+   * and execute callback function with server message as argument
+   *
+   * @param callback
+   * @param heartbeat
+   * @returns {Promise<WebSocketAsPromised>}
+   */
+  async openWebSocket(callback, ...{ heartbeat = 120000 }) {
+    const payloadLogin = wssLoginPayload({
+      at: this.at,
+      apiKey: this.apiKey,
+      appid: this.APP_ID,
+    });
+
+    const wsp = new WebSocketAsPromised(this.getApiWebSocket(), {
+      createWebSocket: wss => new W3CWebSocket(wss),
+    });
+
+    wsp.onMessage.addListener(message => {
+      try {
+        const data = JSON.parse(message);
+        callback(data);
+      } catch (error) {
+        callback(message);
+      }
+    });
+
+    await wsp.open();
+    await wsp.send(payloadLogin);
+
+    setInterval(async () => {
+      await wsp.send('ping');
+    }, heartbeat);
+
+    return wsp;
+  },
+};

package/src/mixins/saveDevicesCache.js

@@ -0,0 +1,29 @@
+const fs = require('fs');
+
+const { _get } = require('../helpers/utilities');
+
+module.exports = {
+  /**
+   * Save devices cache file (useful for using zeroconf)
+   * @returns {Promise<string|{msg: string, error: number}|*|Device[]|{msg: string, error: number}>}
+   */
+  async saveDevicesCache(fileName = './devices-cache.json') {
+    const devices = await this.getDevices();
+
+    const error = _get(devices, 'error', false);
+
+    if (error || !devices) {
+      return devices;
+    }
+
+    const jsonContent = JSON.stringify(devices, null, 2);
+
+    try {
+      fs.writeFileSync(fileName, jsonContent, 'utf8');
+      return { status: 'ok', file: fileName };
+    } catch (e) {
+      console.log('An error occured while writing JSON Object to File.');
+      return { error: e.toString() };
+    }
+  },
+};

package/src/mixins/setDevicePowerState.js

@@ -0,0 +1,90 @@
+const { _get, timestamp, nonce } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+const { getDeviceChannelCount } = require('../helpers/ewelink');
+
+const ChangeStateZeroconf = require('../classes/ChangeStateZeroconf');
+
+module.exports = {
+  /**
+   * Change power state for a specific device
+   *
+   * @param deviceId
+   * @param state
+   * @param channel
+   *
+   * @returns {Promise<{state: *, status: string}|{msg: string, error: *}>}
+   */
+  async setDevicePowerState(deviceId, state, channel = 1) {
+    const device = await this.getDevice(deviceId);
+    const error = _get(device, 'error', false);
+    const uiid = _get(device, 'extra.extra.uiid', false);
+
+    let status = _get(device, 'params.switch', false);
+    const switches = _get(device, 'params.switches', false);
+
+    const switchesAmount = getDeviceChannelCount(uiid);
+
+    if (switchesAmount > 0 && switchesAmount < channel) {
+      return { error: 404, msg: errors.ch404 };
+    }
+
+    if (error || (!status && !switches)) {
+      return { error, msg: errors[error] };
+    }
+
+    let stateToSwitch = state;
+    const params = {};
+
+    if (switches) {
+      status = switches[channel - 1].switch;
+    }
+
+    if (state === 'toggle') {
+      stateToSwitch = status === 'on' ? 'off' : 'on';
+    }
+
+    if (switches) {
+      params.switches = switches;
+      params.switches[channel - 1].switch = stateToSwitch;
+    } else {
+      params.switch = stateToSwitch;
+    }
+
+    if (this.devicesCache) {
+      const url = this.getZeroconfUrl(device)
+      if (url) {
+        return ChangeStateZeroconf.set({
+          url,
+          device,
+          params,
+          switches,
+          state: stateToSwitch,
+        });
+      }
+    }
+
+    const { APP_ID } = this;
+
+    const response = await this.makeRequest({
+      method: 'post',
+      uri: '/user/device/status',
+      body: {
+        deviceid: deviceId,
+        params,
+        appid: APP_ID,
+        nonce,
+        ts: timestamp,
+        version: 8,
+      },
+    });
+
+    const responseError = _get(response, 'error', false);
+
+    if (responseError) {
+      return { error: responseError, msg: errors[responseError] };
+    }
+
+    return { status: 'ok', state, channel };
+  },
+};

package/src/mixins/toggleDevice.js

@@ -0,0 +1,13 @@
+module.exports = {
+  /**
+   * Toggle power state for a specific device
+   *
+   * @param deviceId
+   * @param channel
+   *
+   * @returns {Promise<{state: *, status: string}|{msg: string, error: *}>}
+   */
+  async toggleDevice(deviceId, channel = 1) {
+    return this.setDevicePowerState(deviceId, 'toggle', channel);
+  },
+};

package/src/parsers/parseFirmwareUpdates.js

@@ -0,0 +1,16 @@
+const { _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+const parseFirmwareUpdates = devicesList =>
+  devicesList.map(device => {
+    const model = _get(device, 'extra.extra.model', false);
+    const fwVersion = _get(device, 'params.fwVersion', false);
+
+    if (!model || !fwVersion) {
+      return { error: 500, msg: errors.noFirmware };
+    }
+
+    return { model, version: fwVersion, deviceid: device.deviceid };
+  });
+
+module.exports = parseFirmwareUpdates;

package/src/parsers/parsePowerUsage.js

@@ -0,0 +1,38 @@
+/**
+ * Return daily power usage
+ *
+ * @param hundredDaysKwhData
+ *
+ * @returns {{daily: *, monthly: *}}
+ */
+const parsePowerUsage = ({ hundredDaysKwhData }) => {
+  const today = new Date();
+  const days = today.getDate();
+
+  let monthlyUsage = 0;
+  const dailyUsage = [];
+
+  for (let day = 0; day < days; day += 1) {
+    const s = hundredDaysKwhData.substr(6 * day, 2);
+    const c = hundredDaysKwhData.substr(6 * day + 2, 2);
+    const f = hundredDaysKwhData.substr(6 * day + 4, 2);
+    const h = parseInt(s, 16);
+    const y = parseInt(c, 16);
+    const I = parseInt(f, 16);
+    const E = parseFloat(`${h}.${y}${I}`);
+
+    dailyUsage.push({
+      day: days - day,
+      usage: E,
+    });
+
+    monthlyUsage += E;
+  }
+
+  return {
+    monthly: monthlyUsage,
+    daily: dailyUsage,
+  };
+};
+
+module.exports = parsePowerUsage;

package/src/payloads/credentialsPayload.js

@@ -0,0 +1,13 @@
+const { timestamp, nonce } = require('../helpers/utilities');
+
+const credentialsPayload = ({ appid, email, phoneNumber, password }) => ({
+  appid,
+  email,
+  phoneNumber,
+  password,
+  ts: timestamp,
+  version: 8,
+  nonce,
+});
+
+module.exports = credentialsPayload;

package/src/payloads/deviceStatus.js

@@ -0,0 +1,12 @@
+const { timestamp, nonce } = require('../helpers/utilities');
+
+const deviceStatus = ({ appid, deviceId, params }) => ({
+  deviceid: deviceId,
+  appid,
+  nonce,
+  ts: timestamp,
+  version: 8,
+  params,
+});
+
+module.exports = deviceStatus;