Release v2.0.0 (#44)

* Added arpTableSolver (#18)

* Added arpTableSolver

* fix package import

* linting class

* changed arp library

* refactor arp class

* using arpping fork

* refactor arpTableSolver class

* Added Zero Conf functionality (LAN mode) (#46)

* added crypto-js

* zeroconf helper functions

* zeroconf update payload

* new method to save devices cache file

* class renamed

* refactor Zeroconf class

* return cached device if exists

* moved method to get local ip address

* fix mac addresses without leading zeroes

* refactor Zeroconf class

* using new zeroconf functionality

* zeroconf working with single and multichannel devices

* save device mixin enhancement

* working on zeroconf test cases

* catch errors on filesystem methods

* zeroconf: added extra test cases

* better error handling

* zeroconf: 100% code coverage

* removed deprecated login method

* updates on credentials file

* version bump

* Docs for v2.0 (#52)

* added v1 docs

* added zeroconf docs

* updated readme

* docs updated

* removed zeroconf article warning

* updated vscode config

Co-authored-by: Luis Llamas <luisllamas@hotmail.com>

Author: skydiver

.gitignore

@@ -90,4 +90,9 @@ typings/
 
 # End of https://www.gitignore.io/api/node
 
-.idea/
+.idea/
+
+demo.js
+arp-table.json
+devices-cache.json
+test/_setup/credentials.js

.vscode/settings.json

@@ -2,5 +2,8 @@
   "eslint.validate": [
     "javascript"
   ],
-  "eslint.autoFixOnSave": true
+  "eslint.autoFixOnSave": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true
+  }
 }

README.md

@@ -7,13 +7,14 @@
 * 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
+```sh
  npm install ewelink-api
 ```
 
 
 ## Usage
-Check docs at https://ewelink-api.now.sh
+Check library documentation and examples at https://github.com/skydiver/ewelink-api/docs

classes/PowerState/ChangeStateZeroconf.js

@@ -0,0 +1,40 @@
+const rp = require('request-promise');
+
+const WebSocket = require('../WebSocket');
+const payloads = require('../../lib/payloads');
+const { _get } = require('../../lib/helpers');
+
+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 localUrl = `${url}/${endpoint}`;
+
+    const body = payloads.zeroConfUpdatePayload(
+      selfApikey,
+      deviceId,
+      deviceKey,
+      params
+    );
+
+    const response = await rp({
+      method: 'POST',
+      uri: localUrl,
+      body,
+      json: true,
+    });
+
+    const error = _get(response, 'error', false);
+
+    if (error === 403) {
+      return { error, msg: response.reason };
+    }
+
+    return { status: 'ok', state };
+  }
+}
+
+module.exports = ChangeStateZeroconf;

classes/PowerState/index.js

@@ -1,5 +1,7 @@
 const ChangeState = require('./ChangeState');
+const ChangeStateZeroconf = require('./ChangeStateZeroconf');
 
 module.exports = {
   ChangeState,
+  ChangeStateZeroconf,
 };

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;

docs/README.md

@@ -0,0 +1,27 @@
+# Documentation
+
+* [Introduction](introduction.md)
+* [Quickstart](quickstart.md)
+* [Class Instantiation](class-instantiation.md)
+* [Demos](demos/README.md)
+  * [node script](demos/node.md)
+  * [serverless](demos/serverless.md)
+* [Available Methods](available-methods/README.md)
+  * [getCredentials](available-methods/getcredentials.md)
+  * [openWebSocket](available-methods/openwebsocket.md)
+  * [getDevice](available-methods/getdevice.md)
+  * [getDevices](available-methods/getdevices.md)
+  * [getDevicePowerState](available-methods/getdevicepowerstate.md)
+  * [setDevicePowerState](available-methods/setdevicepowerstate.md)
+  * [toggleDevice](available-methods/toggledevice.md)
+  * [getDevicePowerUsage](available-methods/getdevicepowerusage.md)
+  * [getDeviceCurrentTH](available-methods/getdevicecurrentth.md)
+  * [getDeviceCurrentTemperature](available-methods/getdevicecurrenttemperature.md)
+  * [getDeviceCurrentHumidity](available-methods/getdevicecurrenthumidity.md)
+  * [getDeviceChannelCount](available-methods/getdevicechannelcount.md)
+  * [getRegion](available-methods/getregion.md)
+  * [getFirmwareVersion](available-methods/getfirmwareversion.md)
+  * [saveDevicesCache](available-methods/savedevicescache.md)
+  * [login](available-methods/login.md) <sup>_*deprecated_</sup>
+* [Zeroconf (LAN mode)](zeroconf.md)
+* [Testing](testing.md)

docs/available-methods/README.md

@@ -0,0 +1,24 @@
+# Available Methods
+
+Here is the list of available methods.
+
+* [getCredentials](getcredentials.md)
+* [openWebSocket](openwebsocket.md)
+* [getDevice](getdevice.md)
+* [getDevices](getdevices.md)
+* [getDevicePowerState](getdevicepowerstate.md)
+* [setDevicePowerState](setdevicepowerstate.md)
+* [toggleDevice](toggledevice.md)
+* [getDevicePowerUsage](getdevicepowerusage.md)
+* [getDeviceCurrentTH](getdevicecurrentth.md)
+* [getDeviceCurrentTemperature](getdevicecurrenttemperature.md)
+* [getDeviceCurrentHumidity](getdevicecurrenthumidity.md)
+* [getDeviceChannelCount](getdevicechannelcount.md)
+* [getRegion](getregion.md)
+* [getFirmwareVersion](getfirmwareversion.md)
+* [saveDevicesCache](savedevicescache.md)
+* [login](login.md) <sup>_*deprecated_</sup>
+
+Remember to instantiate class before usage.
+
+Also, take a look at the provided demos for [node script](../demos/node.md) and [serverless](../demos/serverless.md).

docs/available-methods/getcredentials.md

@@ -0,0 +1,20 @@
+# getCredentials
+
+Get your access token, api key and region.
+
+This method is useful on serverless context, where you need to obtain auth credentials to make individual requests.
+
+
+### Usage
+```
+  const auth = await connection.getCredentials();
+
+  console.log('access token: ', auth.at);
+  console.log('api key: ', auth.user.apikey);
+  console.log('region: ', auth.region);
+
+```
+
+<sup>* _Remember to instantiate class before use_</sup>
+
+> Access token and api key will be invalidate after you login again using email and password.

docs/available-methods/getdevice.md

@@ -0,0 +1,13 @@
+# getDevice
+
+Return information for specified device.
+
+
+### Usage
+```
+  /* get specific device information */
+  const device = await connection.getDevice('<your device id>');
+  console.log(device);
+```
+
+<sup>* _Remember to instantiate class before use_</sup>