@evops/lightwaverf 0.0.4 → 0.0.8

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import Debug from 'debug';
+import { LightwaveRFClient } from './LightwaveRFClient';
+import { LightwaveDevice } from './LightwaveDevice';
+declare class LightwaveRFConfiguration {
+    timeout?: number;
+    ip?: string;
+    file?: any;
+    host?: any;
+    email?: any;
+    pin?: any;
+}
+declare interface ILightwaveRF {
+    on(event: 'deviceTurnedOn', listener: (roomId: number, deviceId: number) => void): this;
+    on(event: 'deviceTurnedOff', listener: (roomId: number, deviceId: number) => void): this;
+    on(event: 'deviceDimmed', listener: (roomId: number, deviceId: number, percentage: number) => void): this;
+}
+/** * LightwaveRF API
+ *
+ * @param object config The config
+ *
+ * An instance of the LightwaveRF API
+ */
+export default class LightwaveRF extends EventEmitter implements ILightwaveRF {
+    timeout: number;
+    queue: any;
+    ready: boolean;
+    awaitRegistrration: boolean;
+    currentTransactionNumber: number;
+    devices: Array<LightwaveDevice>;
+    messageCounter: number;
+    config: LightwaveRFConfiguration;
+    responseListeners: Map<number, any>;
+    lwClient: LightwaveRFClient;
+    debug: Debug.Debugger;
+    constructor(config: LightwaveRFConfiguration, callback: (config: any, error: any) => void);
+    stop(): void;
+    initialiseConfiguration(callback: (config: any, error: string) => void): void;
+    /**
+     * Register this device with the Wi-Fi Link
+     *
+     * @param Function callback The callback function
+     *
+     * @return void
+     */
+    register(callback: any): void;
+    /**
+     * Turn a device off
+     *
+     * @param integer  roomId   The room ID
+     * @param integer  deviceId The device ID
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    turnDeviceOff(roomId: number, deviceId: number, callback?: any): void;
+    /**
+     * Turn a device on
+     *
+     * @param integer  roomId   The room ID
+     * @param integer  deviceId The device ID
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    turnDeviceOn(roomId: number, deviceId: number, callback?: any): void;
+    /**
+     * Set the dim percentage of a device
+     *
+     * @param integer  roomId        The room ID
+     * @param integer  deviceId      The device ID
+     * @param integer  dimPercentage The percentage to set the device dim
+     * @param Function callback      The callback for if there are any errors
+     *
+     * @return void
+     */
+    setDeviceDim(roomId: string, deviceId: string, dimPercentage: number, callback: any): void;
+    /**
+     * Get message code
+     *
+     * @return string
+     */
+    private getTransactionNumber;
+    private exec;
+    private send;
+    /**
+     * Send a message over udp
+     *
+     * @param string   message  The message to send
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    private sendUdp;
+    private process;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const debug_1 = __importDefault(require("debug"));
+const LightwaveRFClient_1 = require("./LightwaveRFClient");
+const LightwaveAccount_1 = require("./LightwaveAccount");
+class LightwaveRFConfiguration {
+    constructor() {
+        this.timeout = 1000;
+    }
+}
+/** * LightwaveRF API
+ *
+ * @param object config The config
+ *
+ * An instance of the LightwaveRF API
+ */
+class LightwaveRF extends events_1.EventEmitter {
+    constructor(config, callback) {
+        super();
+        this.timeout = 1000;
+        this.queue = [];
+        this.ready = true;
+        this.awaitRegistrration = false;
+        this.currentTransactionNumber = 4674773;
+        this.devices = [];
+        this.messageCounter = 0;
+        this.config = {};
+        this.responseListeners = new Map();
+        this.debug = (0, debug_1.default)('lightwaverf');
+        this.debug('Initialising LightwaveRF Client');
+        this.lwClient = new LightwaveRFClient_1.LightwaveRFClient(this.debug, config.ip);
+        this.lwClient.on('ready', () => {
+            this.debug('LightwaveRF ready');
+            this.initialiseConfiguration(callback);
+        });
+        this.timeout = config.timeout || 1000;
+        this.devices = []; //[{roomId:0,roomName:'',
+        //deviceId:0,deviceName:'',
+        //deviceType:''}];
+        //Config
+        this.config = config;
+        const self = this;
+        this.lwClient.on('deviceTurnedOn', function () {
+            self.emit('deviceTurnedOn', ...arguments);
+        });
+        this.lwClient.on('deviceTurnedOff', function () {
+            self.emit('deviceTurnedOff', ...arguments);
+        });
+        this.lwClient.on('deviceDimmed', function () {
+            self.emit('deviceDimmed', ...arguments);
+        });
+        //Receive message
+        // this.receiveSocket.on("message", function (message: Buffer, rinfo: dgram.RemoteInfo) {
+        //     // If we were using broadcast IP, we have now
+        //     // discovered Link device IP and can switch off
+        //     // broadcast
+        //     if (self.config.ip == '255.255.255.255') {
+        //         console.log("We have now discovered Link IP address: %s", rinfo.address);
+        //         self.config.ip = rinfo.address
+        //         self.sendSocket.setBroadcast(false)
+        //     }
+        //     //Check this came from the lightwave unit
+        //     if (rinfo.address !== self.config.ip) {
+        //         //Came from wrong ip]
+        //         console.warn("Response came from a different IP than our configured", rinfo.address, self.config.ip)
+        //         return false;
+        //     }
+        //     const parseResponse = (buffer: Buffer) => {
+        //         const response: any = new Object();
+        //         const message = buffer.toString('utf-8');
+        //         if (message.match(/^\*!/)) {
+        //             const jsonResponse = JSON.parse(message.replace(/^\*!/, ''))
+        //             self.currentTransactionNumber = jsonResponse.trans + 1;
+        //             Object.assign(response, jsonResponse)
+        //             response.error = response.pkt === "error" ? response.fn : null;
+        //         } else {
+        //             //Split off the code for the message
+        //             var parts = message.split(",");
+        //             var trans = parts.splice(0, 1);
+        //             var content = parts.join(",").replace(/(\r\n|\n|\r)/gm, "");
+        //             response.trans = parseInt(trans[0]);
+        //             response.message = content;
+        //             response.error = content.match("^ERR") ? content : null;
+        //         }
+        //         response.trans = response.trans !== null ? parseInt(response.trans) : null;
+        //         return response;
+        //     }
+        //     let linkResponse = parseResponse(message)
+        //     debug(">>>>>>>> Received response msg: %s, response: %s, rinfo: %s", message, linkResponse, rinfo);
+        //     if (linkResponse.error === "nonRegistered" && !self.awaitRegistrration) {
+        //         console.warn("Your device is not registered, please accept registration on the Link devices")
+        //         self.register(() => { });
+        //     }
+        //     if (linkResponse.msg === "success" && linkResponse.pairType) {
+        //         self.awaitRegistrration = false;
+        //     }
+        //     debug(self.responseListeners);
+        //     var responseListenerData = self.responseListeners.get(linkResponse.trans);
+        //     if (!responseListenerData) {
+        //         debug("We haven't got anyone to respond to, ignoring the message")
+        //         return;
+        //     }
+        //     debug(`[Transaction: ${linkResponse.trans}] Processing time: ${new Date().getTime() - responseListenerData.time}`)
+        //     responseListenerData.listener(
+        //         linkResponse.error,
+        //         linkResponse.fn,
+        //     );
+        //     self.responseListeners.delete(linkResponse.trans);
+        // });
+        // this.receiveSocket.on("listening", function () {
+        //     var address = self.receiveSocket.address();
+        //     debug("Receiver socket listening " + address.address + ":" + address.port);
+        //     self.send('@H', (code, err) => {
+        //         if (err) {
+        //             console.log('code', code, 'error', err)
+        //             return
+        //         }
+        //         self.initialiseConfiguration(callback);
+        //     })
+        // });
+        // this.sendSocket.bind();
+        // this.sendSocket.on('listening', () => {
+        //     debug("Send socket is ready")
+        //     debug("Setting up receiver socket")
+        //     //Bind to the receive port
+        //     self.receiveSocket.bind(9761);
+        // })
+        process.on('SIGINT', () => {
+            this.stop();
+            this.lwClient.stop();
+        });
+    }
+    stop() {
+        this.debug("Stopping server sockets");
+    }
+    initialiseConfiguration(callback) {
+        //Check config
+        const lwAccount = new LightwaveAccount_1.LightwaveAccount(this.debug, this.lwClient, this.config.email, this.config.pin);
+        lwAccount.getConfiguration(callback);
+    }
+    /**
+     * Register this device with the Wi-Fi Link
+     *
+     * @param Function callback The callback function
+     *
+     * @return void
+     */
+    register(callback) {
+        this.awaitRegistrration = true;
+        this.sendUdp("!F*p", callback);
+    }
+    /**
+     * Turn a device off
+     *
+     * @param integer  roomId   The room ID
+     * @param integer  deviceId The device ID
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    turnDeviceOff(roomId, deviceId, callback) {
+        var state = "0";
+        this.exec("!R" + roomId + "D" + deviceId + "F" + state + "|\0", callback);
+    }
+    /**
+     * Turn a device on
+     *
+     * @param integer  roomId   The room ID
+     * @param integer  deviceId The device ID
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    turnDeviceOn(roomId, deviceId, callback) {
+        // this.devices.find(d => d.roomId == roomId && d.deviceId == deviceId)?.turnOn();
+    }
+    /**
+     * Set the dim percentage of a device
+     *
+     * @param integer  roomId        The room ID
+     * @param integer  deviceId      The device ID
+     * @param integer  dimPercentage The percentage to set the device dim
+     * @param Function callback      The callback for if there are any errors
+     *
+     * @return void
+     */
+    setDeviceDim(roomId, deviceId, dimPercentage, callback) {
+        // var dimAmount = dimPercentage * 0.32; //Dim is on a scale from 0 to 32
+        // if (dimAmount === 0) {
+        //     this.turnDeviceOff(roomId, deviceId, callback);
+        // } else {
+        //     this.exec("!R" + roomId + "D" + deviceId + "FdP" + dimAmount + "|\0", callback);
+        // }
+    }
+    /**
+     * Get message code
+     *
+     * @return string
+     */
+    getTransactionNumber() {
+        return this.currentTransactionNumber;
+    }
+    exec(...args) {
+        // Check if the queue has a reasonable size
+        if (this.queue.length > 100) {
+            this.queue.pop();
+        }
+        this.debug("Ading to queue: " + args.join(" "));
+        this.queue.push(args);
+        this.process();
+    }
+    ;
+    send(cmd, callback) {
+        this.sendUdp(cmd, callback);
+        //if (callback) callback();
+    }
+    ;
+    /**
+     * Send a message over udp
+     *
+     * @param string   message  The message to send
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    sendUdp(message, callback) {
+        //Add to message
+        const transactionNumber = this.getTransactionNumber();
+        //Prepend code to message
+        message = `${transactionNumber},${message}`;
+        this.debug(`[${this.config.ip}][trans: ${transactionNumber}] Sending message: ${message}`);
+        //Create buffer from message
+        const messageBuffer = Buffer.from(message, 'utf-8');
+        this.debug("Callback for message: " + message, callback);
+        //Add listener
+        if (callback) {
+            this.debug("Registering call back with transaction number: " + transactionNumber);
+            this.responseListeners.set(transactionNumber, {
+                time: new Date().getTime(),
+                listener: callback
+            });
+            this.debug(this.responseListeners);
+            // Expire request, trigger retry
+            setTimeout(() => {
+                const listener = this.responseListeners.get(transactionNumber);
+                if (listener) {
+                    this.debug(`[Transaction $(transactionNumber)] The listener is still there, triggering error`);
+                    this.responseListeners.delete(transactionNumber);
+                    callback("ERR:EXPIRED", undefined);
+                }
+            }, 1000);
+        }
+        //Broadcast the message
+        // this.sendSocket.send(messageBuffer, 0, messageBuffer.length, 9760, this.config.ip);
+    }
+    process() {
+        this.debug("Checking queue");
+        if (this.queue.length === 0)
+            return;
+        if (!this.ready)
+            return;
+        var self = this;
+        this.ready = false;
+        this.debug("Processing queue...");
+        this.debug("Items in the queue", this.queue.length);
+        this.send.apply(this, this.queue.shift());
+        setTimeout(function () {
+            self.ready = true;
+            self.process();
+        }, this.timeout);
+    }
+    ;
+}
+exports.default = LightwaveRF;

package/package.json

@@ -1,29 +1,33 @@
 {
   "name": "@evops/lightwaverf",
   "description": "Lightwave RF client library",
-  "version": "0.0.4",
-  "main": "index.js",
+  "version": "0.0.8",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": "bin/lightwaverf.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublish": "tsc"
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/ollieparsley/node-lightwaverf.git"
+    "url": "git://github.com/eu-evos/node-lightwaverf.git"
   },
   "keywords": [
     "lightwaverf"
   ],
-  "author": "Ollie Parsley",
-  "license": "BSD-2-Clause",
+  "author": "Stanislaw Wozniak",
+  "license": "MIT",
   "bugs": {
-    "url": "https://github.com/ollieparsley/node-lightwaverf/issues"
+    "url": "https://github.com/eu-evos/node-lightwaverf/issues"
   },
   "dependencies": {
-    "debug": "~2.2.0",
+    "@types/debug": "^4.1.7",
+    "@types/js-yaml": "^4.0.5",
+    "@types/request-promise": "^4.1.48",
+    "debug": "4.3.3",
     "js-yaml": ">=3.5.3",
     "request": "^2.74.0",
-    "request-promise": "^4.1.1",
-    "wait.for": ">=0.6.6"
+    "request-promise": "^4.1.1"
   }
-}
+}

package/src/LightwaveAccount.ts

@@ -0,0 +1,107 @@
+import Debug, { Debugger } from "debug";
+import { RequestAPI, RequiredUriUrl } from "request";
+import rp from "request-promise";
+import { LightwaveDevice, LightwaveDeviceType } from "./LightwaveDevice";
+import { LightwaveRFClient } from "./LightwaveRFClient";
+
+export class LightwaveAccount {
+  debug: Debug.Debugger;
+  client: LightwaveRFClient;
+  email: string;
+  pin: string;
+  mainDebug: Debug.Debugger;
+
+  constructor(debug: Debugger, client: LightwaveRFClient, email: string, pin: string) {
+    if (!email || !pin) {
+      throw "No email or pin specified. The server configuration (rooms, devices, etc.) cannot be obtained";
+    }
+    this.mainDebug = debug;
+    this.debug = debug.extend('account');
+    this.client = client;
+    this.email = email;
+    this.pin = pin;
+  }
+
+  getConfiguration(callback: any) {
+    this.debug('Getting rooms from LightWave');
+    var self = this;
+    var host = 'https://control-api.lightwaverf.com';
+    var json = rp.defaults({
+      json: true
+    });
+
+    var auth: RequestAPI<rp.RequestPromise<any>, rp.RequestPromiseOptions, RequiredUriUrl>, token;
+    json.get(host + '/v1/user?password=' + this.pin + '&username=' + this.email)
+      .then(function (res) {
+        return json.get(host + '/v1/auth?application_key=' + res.application_key)
+      })
+      .then(function (res) {
+        token = res.token;
+        auth = json.defaults({
+          headers: {
+            'X-LWRF-token': token,
+            'X-LWRF-platform': 'ios',
+            'X-LWRF-skin': 'lightwaverf'
+          }
+        });
+
+        return auth.get(host + '/v1/device_type?nested=1');
+      })
+      .then(function (res) {
+        return auth.get(host + '/v1/user_profile?nested=1')
+      })
+      .then(function (res) {
+        self.parseRooms(res, callback);
+      });
+  }
+
+
+  parseRooms(lightwaveResponse: any, callback: (devices: LightwaveDevice[], error: Error | null) => void) {
+    this.debug('Parsing lightwaveResponse: ',
+      lightwaveResponse.content.estates[0].locations[0].zones[0].rooms[0].devices);
+
+    const home = lightwaveResponse.content.estates[0].locations[0].zones[0];
+    const devices = [];
+
+    for (var i = 0; i < home.rooms.length; i++) {
+      var r = home.rooms[i];
+
+      this.debug("Room " + r.name + " with " + r.devices.length + " devices");
+
+      // Get device types
+      //   O: On/Off Switch
+      //   D: Dimmer
+      //   R: Radiator(s)
+      //   P: Open/Close
+      //   I: Inactive (i.e. not configured)
+      //   m: Mood (inactive)
+      //   M: Mood (active)
+      //   o: All Off
+      var deviceTypeMapping: Map<number, LightwaveDeviceType> = new Map<number, LightwaveDeviceType>();
+      deviceTypeMapping.set(1, LightwaveDeviceType.OnOff);
+      deviceTypeMapping.set(2, LightwaveDeviceType.Dimmer);
+      deviceTypeMapping.set(3, LightwaveDeviceType.OnOff);
+
+      for (var j = 0; j < r.devices.length; j++) {
+        var d = r.devices[j];
+
+        const device = new LightwaveDevice(
+          this.client,
+          this.mainDebug,
+          r.room_number,
+          d.device_number,
+          r.name,
+          d.name,
+          deviceTypeMapping.get(d.device_type_id)!
+        );
+
+        devices.push(device);
+      }
+    }
+
+    this.debug('Devices: %O', devices)
+
+    callback(devices, null);
+  };
+
+}

package/src/LightwaveDevice.ts

@@ -0,0 +1,66 @@
+import Debug from 'debug';
+import { LightwaveRFClient } from './LightwaveRFClient';
+
+export interface LightwaveRFDeviceInterface {
+  roomId: number
+  deviceId: number
+  roomName: string
+  deviceName: string
+  deviceType: string
+}
+
+export enum LightwaveDeviceType {
+  Dimmer = "D",
+  OnOff = "O",
+}
+
+export class LightwaveDevice implements LightwaveRFDeviceInterface {
+  roomId: number;
+  deviceId: number;
+  roomName: string;
+  deviceName: string;
+  deviceType: LightwaveDeviceType;
+  client: LightwaveRFClient;
+  debug: Debug.Debugger;
+
+  constructor(client: LightwaveRFClient, debug: debug.Debugger, roomId: number, deviceId: number, roomName: string, deviceName: string, deviceType: LightwaveDeviceType) {
+    this.client = client;
+    this.debug = debug.extend(deviceName);
+    this.roomId = roomId;
+    this.deviceId = deviceId;
+    this.roomName = roomName;
+    this.deviceName = deviceName;
+    this.deviceType = deviceType;
+  }
+
+  async turnOn(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.debug("Device turning on");
+      this.client.send(`R${this.roomId}D${this.deviceId}F1`, (message, error) => {
+        resolve();
+      });
+    });
+  }
+
+  async turnOff(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.debug("Device turning off");
+      this.client.send(`R${this.roomId}D${this.deviceId}F0`, (message, error) => {
+        if (error) return reject(error);
+        resolve();
+      });
+    });
+  }
+
+  async dim(percentage: number): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.debug("Device dimming to %d", percentage);
+
+      const lwDim = Math.round(percentage * 0.32);
+      this.client.send(`R${this.roomId}D${this.deviceId}FdP${lwDim}`, (message, error) => {
+        if (error) return reject(error);
+        resolve();
+      });
+    });
+  }
+}

package/src/LightwaveJsonMessageProcessor.ts

@@ -0,0 +1,29 @@
+import { Debugger } from "debug";
+import "./LightwaveTransaction";
+import { LightwaveTransaction } from "./LightwaveTransaction";
+import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
+
+export class LightwaveJsonMessageProcessor implements LightwaveMessageProcessor {
+  debug: Debugger;
+  constructor(debug: Debugger) {
+    this.debug = debug.extend('jsonMessageProcessor');
+  }
+
+  process(message: Buffer): any {
+    this.debug('Processing message')
+    const textMessage = message.toString('utf-8').replace('*!', '');
+    const json = JSON.parse(textMessage);
+
+    const response = json;
+    response.id = json.trans;
+    response.error = json.error ?? null;
+
+    return response;
+  }
+
+  canProcess(message: Buffer): boolean {
+    this.debug("Checking if can process message");
+    return message.toString('utf-8').startsWith('*!');
+  }
+
+}

package/src/LightwaveMessageProcessor.ts

@@ -0,0 +1,8 @@
+import "./LightwaveTransaction";
+
+declare interface LightwaveMessageProcessor {
+  process(message: Buffer): any;
+  canProcess(message: Buffer): boolean;
+}
+
+export default LightwaveMessageProcessor;