@pipechela/ewelink-api 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Martin M.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# @pipechela/ewelink-api
+> eWeLink API for JavaScript (Fork with fixes)
+
+This repository is a fork of [skydiver/ewelink-api](https://github.com/skydiver/ewelink-api) with the following changes:
+- fixed mac address parsing
+
+## Key features
+* can run on browsers, node scripts or serverless environment
+* set on/off devices
+* get power consumption on devices like Sonoff POW
+* listen for devices events
+* using zeroconf (LAN mode), no internet connection required
+
+
+## Installation
+```sh
+npm install @pipechela/ewelink-api
+```
+
+
+## Usage
+Check library documentation and examples in the `docs` folder or at the [original repository](https://github.com/skydiver/ewelink-api/tree/master/docs).

package/index.d.ts

@@ -0,0 +1,223 @@
+// Type definitions for ewelink-api
+// Definitions by: Alexander Méhes https://github.com/BMXsanko
+
+declare module '@pipechela/ewelink-api' {
+  export default eWelink;
+
+  class eWelink {
+    constructor({ }: { email: string; password: string; } | { at: string; } | { at: string; apiKey: string; });
+    /**
+    * Login into eWeLink API and get auth credentials.
+    */
+    login(): Promise<LoginInfo>
+    /**
+    * Opens a socket connection to eWeLink and listen for real-time events.
+    */
+    openWebSocket(callback: (data: {}) => void): Promise<any>
+    /**
+     * Returns a list of devices associated to logged account.
+     */
+    getDevices(): Promise<Device[]>
+    /**
+     * Return information for specified device.
+     */
+    getDevice(deviceId: string): Promise<Device>
+    /**
+     * Query for specified device power status.
+     */
+    getDevicePowerState(deviceId: string, channel?: number): Promise<DeviceState>
+    /**
+     * Change specified device power state.
+     */
+    setDevicePowerState(deviceId: string, state?: string, channel?: number): Promise<DeviceState>
+    /**
+     * Switch specified device current power state.
+     */
+    toggleDevice(deviceId: string, channel?: number): Promise<DeviceState>
+    /**
+     * Returns current month power usage on device who supports electricity records, like Sonoff POW.
+     */
+    getDevicePowerUsage(deviceId: string): Promise<PowerUsage>
+    /**
+     * Return current temperature and humidity for specified device.
+     */
+    getDeviceCurrentTH(deviceId: string): Promise<TemperatureHumidity>
+    /**
+     * Return current temperature for specified device.
+     */
+    getDeviceCurrentTemperature(deviceId: string): Promise<TemperatureHumidity>
+    /**
+     * Return current temperature for specified device.
+     */
+    getDeviceCurrentHumidity(deviceId: string): Promise<TemperatureHumidity>
+    /**
+     * Return total channels for specified device.
+     */
+    getDeviceChannelCount(deviceId: string): Promise<SwitchCount>
+    /**
+     * Return firmware version for specified device.
+     */
+    getFirmwareVersion(deviceId: string): Promise<FirmwareVersion>
+  }
+
+  export interface Device {
+    _id: string;
+    name: string;
+    type: string;
+    deviceid: string;
+    apikey: string;
+    extra: Extra2;
+    __v: number;
+    onlineTime: string;
+    ip: string;
+    location: string;
+    offlineTime: string;
+    deviceStatus: string;
+    tags: Tags;
+    settings: Settings;
+    devGroups: any[];
+    groups: any[];
+    params: Params;
+    online: boolean;
+    createdAt: string;
+    group: string;
+    sharedTo: any[];
+    devicekey: string;
+    deviceUrl: string;
+    brandName: string;
+    showBrand: boolean;
+    brandLogoUrl: string;
+    productModel: string;
+    devConfig: DevConfig;
+    uiid: number;
+  }
+
+  export interface DevConfig {
+  }
+
+  export interface Params {
+    pulseWidth: number;
+    pulse: string;
+    init: number;
+    sledOnline: string;
+    version: number;
+    timers: any[];
+    controlType: string;
+    partnerApikey: string;
+    bindInfos: BindInfos;
+    rssi: number;
+    staMac: string;
+    startup: string;
+    fwVersion: string;
+    switch: string;
+  }
+
+  export interface BindInfos {
+    gaction: string[];
+  }
+
+  export interface Settings {
+    alarmNotify: number;
+    opsHistory: number;
+    opsNotify: number;
+  }
+
+  export interface Tags {
+    m_4434_sany: string;
+  }
+
+  export interface Extra2 {
+    _id: string;
+    extra: Extra;
+  }
+
+  export interface Extra {
+    description: string;
+    brandId: string;
+    apmac: string;
+    mac: string;
+    ui: string;
+    modelInfo: string;
+    model: string;
+    manufacturer: string;
+    uiid: number;
+    staMac: string;
+    chipid: string;
+  }
+
+  export interface DeviceState {
+    status?: string;
+    state?: string;
+    error?: number;
+    msg?: string;
+  }
+
+  export interface SwitchCount {
+    status?: string;
+    switchesAmount?: number;
+    error?: number;
+    msg?: string;
+  }
+
+  export interface TemperatureHumidity {
+    status?: string;
+    temperature?: number;
+    humidity?: number;
+    error?: number;
+    msg?: string;
+  }
+
+  export interface PowerUsage {
+    status?: string;
+    monthly?: number;
+    daily?: Daily[];
+    error?: number;
+    msg?: string;
+  }
+
+  export interface FirmwareVersion {
+    status?: string;
+    fwVersion?: string;
+    error?: number;
+    msg?: string;
+  }
+
+  export interface LoginInfo {
+    at: string;
+    rt: string;
+    user: User;
+    region: string;
+  }
+
+  export interface User {
+    _id: string;
+    email: string;
+    appId: string;
+    lang: string;
+    online: boolean;
+    onlineTime: string;
+    ip: string;
+    location: string;
+    offlineTime: string;
+    userStatus: string;
+    appInfos: AppInfo[];
+    isAccepEmailAd: boolean;
+    bindInfos: LoginBindInfos;
+    createdAt: string;
+    apikey: string;
+  }
+
+  export interface LoginBindInfos {
+    gaction: string[];
+  }
+
+  export interface AppInfo {
+    appVersion: string;
+    os: string;
+  }
+
+  export interface Daily {
+    day: number;
+    usage: number;
+  }
+}

package/main.js

@@ -0,0 +1,114 @@
+const {
+  APP_ID: DEFAULT_APP_ID,
+  APP_SECRET: DEFAULT_APP_SECRET,
+} = require('./src/data/constants');
+
+const mixins = require('./src/mixins');
+const errors = require('./src/data/errors');
+
+class eWeLink {
+  constructor(parameters = {}) {
+    const {
+      region = 'us',
+      email = null,
+      phoneNumber = null,
+      password = null,
+      at = null,
+      apiKey = null,
+      devicesCache = null,
+      arpTable = null,
+      APP_ID = DEFAULT_APP_ID,
+      APP_SECRET = DEFAULT_APP_SECRET,
+    } = parameters;
+
+    const check = this.checkLoginParameters({
+      region,
+      email,
+      phoneNumber,
+      password,
+      at,
+      apiKey,
+      devicesCache,
+      arpTable,
+    });
+
+    if (check === false) {
+      throw new Error(errors.invalidCredentials);
+    }
+
+    this.region = region;
+    this.phoneNumber = phoneNumber;
+    this.email = email;
+    this.password = password;
+    this.at = at;
+    this.apiKey = apiKey;
+    this.devicesCache = devicesCache;
+    this.arpTable = arpTable;
+
+    this.APP_ID = APP_ID;
+    this.APP_SECRET = APP_SECRET;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  checkLoginParameters(params) {
+    const { email, phoneNumber, password, devicesCache, arpTable, at } = params;
+
+    if (email !== null && phoneNumber !== null) {
+      return false;
+    }
+
+    if (
+      (email !== null && password !== null) ||
+      (phoneNumber !== null && password !== null) ||
+      (devicesCache !== null && arpTable !== null) ||
+      at !== null
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Generate eWeLink API URL
+   *
+   * @returns {string}
+   */
+  getApiUrl() {
+    return `https://${this.region}-api.coolkit.cc:8080/api`;
+  }
+
+  /**
+   * Generate eWeLink OTA API URL
+   * @returns {string}
+   */
+  getOtaUrl() {
+    return `https://${this.region}-ota.coolkit.cc:8080/otaother`;
+  }
+
+  /**
+   * Generate eWeLink WebSocket URL
+   *
+   * @returns {string}
+   */
+  getApiWebSocket() {
+    return `wss://${this.region}-pconnect3.coolkit.cc:8080/api/ws`;
+  }
+
+  /**
+   * Generate Zeroconf URL
+   * @param device
+   * @returns {string}
+   */
+  getZeroconfUrl(device) {
+    const ip = this.getDeviceIP(device);
+    if (!ip) {
+      return null;
+    }
+    return `http://${ip}:8081/zeroconf`;
+  }
+}
+
+Object.assign(eWeLink.prototype, mixins);
+
+module.exports = eWeLink;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@pipechela/ewelink-api",
+  "version": "1.0.0",
+  "description": "eWeLink API for Node.js (Fork by pipechela)",
+  "author": "pipechela",
+  "license": "MIT",
+  "typings": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pipechela/ewelink-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pipechela/ewelink-api/issues"
+  },
+  "keywords": [
+    "ewelink",
+    "sonoff",
+    "api",
+    "node",
+    "nodejs"
+  ],
+  "main": "main.js",
+  "scripts": {
+    "test": "jest --runInBand --verbose",
+    "coverage": "jest --runInBand --verbose --coverage --coverageDirectory=coverage/jest",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "jest": {
+    "setupFilesAfterEnv": [
+      "<rootDir>/test/_setup/setupTests.js"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      ".cache"
+    ],
+    "coverageReporters": [
+      "text",
+      "html"
+    ]
+  },
+  "dependencies": {
+    "arpping": "github:skydiver/arpping",
+    "crypto-js": "^4.0.0",
+    "delay": "^4.4.0",
+    "node-fetch": "^2.6.1",
+    "random": "^2.2.0",
+    "websocket": "^1.0.32",
+    "websocket-as-promised": "^1.0.1"
+  },
+  "devDependencies": {
+    "babel-eslint": "^10.1.0",
+    "eslint": "^7.11.0",
+    "eslint-config-airbnb": "^18.2.0",
+    "eslint-config-prettier": "^6.12.0",
+    "eslint-config-wesbos": "0.0.19",
+    "eslint-plugin-html": "^6.1.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jsx-a11y": "^6.3.1",
+    "eslint-plugin-prettier": "^3.1.4",
+    "eslint-plugin-react": "^7.21.4",
+    "eslint-plugin-react-hooks": "^4.1.2",
+    "jest": "^26.5.3",
+    "nock": "^12.0.3",
+    "prettier": "^1.19.1"
+  }
+}

package/src/classes/ChangeStateZeroconf.js

@@ -0,0 +1,34 @@
+const fetch = require('node-fetch');
+
+const WebSocket = require('./WebSocket');
+const zeroConfUpdatePayload = require('../payloads/zeroConfUpdatePayload');
+const { _get } = require('../helpers/utilities');
+
+class ChangeStateZeroconf extends WebSocket {
+  static async set({ url, device, params, switches, state }) {
+    const selfApikey = device.apikey;
+    const deviceId = device.deviceid;
+    const deviceKey = device.devicekey;
+
+    const endpoint = switches ? 'switches' : 'switch';
+
+    const body = zeroConfUpdatePayload(selfApikey, deviceId, deviceKey, params);
+
+    const request = await fetch(`${url}/${endpoint}`, {
+      method: 'post',
+      body: JSON.stringify(body),
+    });
+
+    const response = await request.json();
+
+    const error = _get(response, 'error', false);
+
+    if (error === 403) {
+      return { error, msg: response.reason };
+    }
+
+    return { status: 'ok', state };
+  }
+}
+
+module.exports = ChangeStateZeroconf;

package/src/classes/DevicePowerUsageRaw.js

@@ -0,0 +1,58 @@
+const WebSocket = require('./WebSocket');
+const wssLoginPayload = require('../payloads/wssLoginPayload');
+const wssUpdatePayload = require('../payloads/wssUpdatePayload');
+const { _get } = require('../helpers/utilities');
+const errors = require('../data/errors');
+
+class DevicePowerUsageRaw extends WebSocket {
+  /**
+   * Get specific device power usage (raw data)
+   *
+   * @param apiUrl
+   * @param at
+   * @param apiKey
+   * @param deviceId
+   * @returns {Promise<{error: string}|{data: {hundredDaysKwhData: *}, status: string}|{msg: any, error: *}|{msg: string, error: number}>}
+   */
+  static async get({ apiUrl, at, apiKey, deviceId }) {
+    const payloadLogin = wssLoginPayload({ at, apiKey, appid: this.APP_ID });
+
+    const payloadUpdate = wssUpdatePayload({
+      apiKey,
+      deviceId,
+      params: { hundredDaysKwh: 'get' },
+    });
+
+    const response = await this.WebSocketRequest(apiUrl, [
+      payloadLogin,
+      payloadUpdate,
+    ]);
+
+    if (response.length === 1) {
+      return { error: errors.noPower };
+    }
+
+    const error = _get(response[1], 'error', false);
+
+    if (error === 403) {
+      return { error, msg: response[1].reason };
+    }
+
+    const hundredDaysKwhData = _get(
+      response[1],
+      'config.hundredDaysKwhData',
+      false
+    );
+
+    if (!hundredDaysKwhData) {
+      return { error: errors.noPower };
+    }
+
+    return {
+      status: 'ok',
+      data: { hundredDaysKwhData },
+    };
+  }
+}
+
+module.exports = DevicePowerUsageRaw;

package/src/classes/WebSocket.js

@@ -0,0 +1,57 @@
+const W3CWebSocket = require('websocket').w3cwebsocket;
+const WebSocketAsPromised = require('websocket-as-promised');
+const delay = require('delay');
+
+const errors = require('../data/errors');
+
+class WebSocket {
+  /**
+   * Open WebSocket connection and send provided payloads
+   *
+   * @param url
+   * @param payloads
+   * @param delayTime
+   *
+   * @returns {Array}
+   */
+  static async WebSocketRequest(url, payloads, ...{ delayTime = 1000 }) {
+    const wsp = new WebSocketAsPromised(url, {
+      createWebSocket: wss => new W3CWebSocket(wss),
+    });
+
+    const responses = [];
+    wsp.onMessage.addListener(message => responses.push(JSON.parse(message)));
+
+    try {
+      await wsp.open();
+
+      for (const payload of payloads) {
+        await wsp.send(payload);
+        await delay(delayTime);
+      }
+
+      await wsp.close();
+    } catch (e) {
+      return this.customThrowError(e);
+    }
+
+    return responses;
+  }
+
+  /**
+   * Parse WebSocket errors and return user friendly messages
+   *
+   * @param e
+   *
+   * @returns {{error: string}|{msg: string, error: number}}
+   */
+  static customThrowError(e) {
+    const loginError = e.message.indexOf('WebSocket is not opened');
+    if (loginError > -1) {
+      return { error: 406, msg: errors['406'] };
+    }
+    return { error: errors.unknown };
+  }
+}
+
+module.exports = WebSocket;

package/src/classes/Zeroconf.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const arpping = require('arpping')({});
+
+class Zeroconf {
+  /**
+   * Build the ARP table
+   * @param ip
+   * @returns {Promise<unknown>}
+   */
+  static getArpTable(ip = null) {
+    return new Promise((resolve, reject) => {
+      arpping.discover(ip, (err, hosts) => {
+        if (err) {
+          return reject(err);
+        }
+        const arpTable = Zeroconf.fixMacAddresses(hosts);
+        return resolve(arpTable);
+      });
+    });
+  }
+
+  /**
+   * Sometime arp command returns mac addresses without leading zeroes.
+   * @param hosts
+   */
+  static fixMacAddresses(hosts) {
+    return hosts.map(host => {
+      const octets = host.mac.split(/[:\-]/);
+
+      const fixedMac = octets.map(octet => {
+        if (octet.length === 1) {
+          return `0${octet}`;
+        }
+        return octet;
+      });
+
+      return {
+        ip: host.ip,
+        mac: fixedMac.join(':'),
+      };
+    });
+  }
+
+  /**
+   * Save ARP table to local file
+   * @param config
+   * @returns {Promise<{error: string}|{file: {request: string; resolved: string} | any | string | string, status: string}>}
+   */
+  static async saveArpTable(config = {}) {
+    const ip = config.ip || null;
+    const fileName = config.file || './arp-table.json';
+    try {
+      const arpTable = await Zeroconf.getArpTable(ip);
+      const jsonContent = JSON.stringify(arpTable, null, 2);
+      fs.writeFileSync(fileName, jsonContent, 'utf8');
+      return { status: 'ok', file: fileName };
+    } catch (e) {
+      return { error: e.toString() };
+    }
+  }
+
+  /**
+   * Read ARP table file
+   * @param fileName
+   * @returns {Promise<{error: string}|any>}
+   */
+  static async loadArpTable(fileName = './arp-table.json') {
+    try {
+      const jsonContent = await fs.readFileSync(fileName);
+      return JSON.parse(jsonContent);
+    } catch (e) {
+      return { error: e.toString() };
+    }
+  }
+
+  /**
+   * Read devices cache file
+   * @param fileName
+   * @returns {Promise<{error: string}>}
+   */
+  static async loadCachedDevices(fileName = './devices-cache.json') {
+    try {
+      const jsonContent = await fs.readFileSync(fileName);
+      return JSON.parse(jsonContent);
+    } catch (e) {
+      return { error: e.toString() };
+    }
+  }
+}
+
+module.exports = Zeroconf;

package/src/data/constants.js

@@ -0,0 +1,7 @@
+const APP_ID = 'YzfeftUVcZ6twZw1OoVKPRFYTrGEg01Q';
+const APP_SECRET = '4G91qSoboqYO4Y0XJ0LPPKIsq8reHdfa';
+
+module.exports = {
+  APP_ID,
+  APP_SECRET,
+};