@evops/lightwaverf 0.0.7 → 0.0.8

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;

package/src/LightwaveRFClient.ts

@@ -0,0 +1,236 @@
+import dgram from 'dgram';
+import events from 'events';
+import Debug, { Debugger } from 'debug';
+import LightwaveMessageProcessor from './LightwaveMessageProcessor';
+import LightwaveTextMessageProcessor from './LightwaveTextMessageProcessor';
+import { LightwaveJsonMessageProcessor } from './LightwaveJsonMessageProcessor';
+import { LightwaveTransaction } from './LightwaveTransaction';
+import { Queue } from './Queue';
+
+declare interface LightwaveRFClientInterface {
+  on(event: 'ready', listener: (client: LightwaveRFClient) => void): this;
+  on(event: 'deviceTurnedOn', listener: (room: number, device: number) => void): this;
+  on(event: 'deviceTurnedOff', listener: (room: number, device: number) => void): this;
+  on(event: 'deviceDimmed', listener: (room: number, device: number, dimPercentage: number) => void): this;
+}
+
+export class LightwaveRFClient extends events.EventEmitter implements LightwaveRFClientInterface {
+  private senderSocket: dgram.Socket;
+  private receiverSocket: dgram.Socket;
+
+  private senderSocketReady: boolean = false;
+  private receiverSocketReady: boolean = false;
+
+  private commandQueue: Queue<LightwaveTransaction> = new Queue<LightwaveTransaction>();
+
+  private messageProcessors: LightwaveMessageProcessor[] = [];
+
+  private debug: Debug.Debugger;
+  private ip: string;
+  private transactionListeners: Map<number, any> = new Map();
+  delay: number = 125;
+
+  constructor(debug: Debugger, ip: string = "255.255.255.255", port: number = 9761) {
+    super();
+
+    this.ip = ip;
+    this.debug = debug.extend('client');
+    this.senderSocket = dgram.createSocket('udp4');
+    this.receiverSocket = dgram.createSocket('udp4');
+
+    this.messageProcessors.push(new LightwaveJsonMessageProcessor(this.debug));
+    this.messageProcessors.push(new LightwaveTextMessageProcessor(this.debug));
+
+    this.receiverSocket.on('message', (buffer: Buffer) => {
+      this.debug("RAW: %o", buffer.toString('utf-8'));
+    });
+    this.receiverSocket.on('message', this.processRawMessage.bind(this));
+
+    this.receiverSocket.once('listening', () => {
+      this.debug("Receiver socket bound", this.receiverSocket.address());
+      this.receiverSocketReady = true
+    });
+    this.receiverSocket.once('listening', this.socketReady.bind(this));
+
+    this.senderSocket.once('listening', () => {
+      this.debug("Sender socket bound", this.senderSocket.address());
+      this.senderSocketReady = true
+    });
+    this.senderSocket.once('listening', this.socketReady.bind(this));
+
+    this.senderSocket.unref();
+
+    this.senderSocket.bind();
+
+    this.debug("Binding receiver socket on address %s and port %d", ip, port);
+    this.receiverSocket.bind(port);
+
+    this.receiverSocket.on('error', () => {
+      throw new Error("Error binding receiver socket");
+    })
+
+    process.on('SIGINT', () => {
+      this.debug("\nClosing sockets");
+      this.stop();
+      process.exit();
+    })
+  }
+
+  public stop() {
+    try {
+      this.receiverSocket.close();
+    } catch { }
+  }
+
+  private socketReady() {
+    if (!this.senderSocketReady) return;
+    if (!this.receiverSocketReady) return;
+
+    this.checkRegistration();
+    this.processQueue();
+  }
+
+  private checkRegistration() {
+    this.debug("Checking registration");
+    this.send("@H", (transaction: LightwaveTransaction | null, error: Error) => {
+      if (error) {
+        this.debug('Error: %o', error);
+      }
+
+      this.debug(transaction);
+      this.emit('ready');
+    });
+  }
+
+  public send(message: (string | Buffer), callback: (transaction: LightwaveTransaction | null, error: Error) => void) {
+    const transaction = Math.round(Math.random() * Math.pow(10, 8));
+    const messageWithTransaction = `${transaction},!${message}`;
+    const transactionDebug = this.debug.extend("transaction:" + transaction);
+
+    this.transactionListeners.set(transaction, {
+      message: message,
+      debug: transactionDebug,
+      delay: this.delay,
+      callback: callback
+    })
+
+    this.debug("Queueing message: %s", messageWithTransaction);
+
+    this.commandQueue.add(<LightwaveTransaction>{
+      id: transaction,
+      message: messageWithTransaction,
+      debug: transactionDebug,
+      callback
+    });
+
+    this.processQueue();
+  }
+
+  private async processQueue() {
+    if (this.commandQueue.busy) {
+      setTimeout(this.processQueue.bind(this), this.delay);
+      return
+    };
+
+    const command = this.commandQueue.receive();
+    if (!command) return;
+
+    this.commandQueue.busy = true;
+    const transactionListener = this.transactionListeners.get(command.id);
+    const originalCallback = transactionListener.callback;
+
+    transactionListener.callback = (transaction: LightwaveTransaction, error: Error) => {
+      this.commandQueue.busy = false;
+      setTimeout(this.processQueue.bind(this), this.delay);
+      originalCallback(transaction, error);
+    }
+
+    setTimeout(() => {
+      const listener = this.transactionListeners.get(command.id);
+      if (!listener) return;
+
+      originalCallback(null, new Error("Execution expired"));
+      this.transactionListeners.delete(command.id);
+      this.processQueue();
+    }, 5000)
+
+
+    const transactionDebug = this.debug.extend(`transaction:${command?.id}`);
+    transactionDebug("Starting new transaction");
+    this.exec(command!.message, (message: LightwaveTransaction | null, error: Error) => { });
+  }
+
+  private exec(message: (Buffer | string | undefined), callback: (message: LightwaveTransaction | null, error: Error) => void) {
+    if (message === undefined) return;
+
+    this.debug("Sending message: %s to %s on port %d", message, this.ip, 9760);
+    this.senderSocket.setBroadcast(this.ip === "255.255.255.255");
+    this.senderSocket.send(message, 9760, this.ip, (error: Error | null, bytes: number) => {
+      if (error) {
+        this.debug("Message send errror: %o", error);
+      }
+      this.debug("Message sent: %s, length: %d", message, bytes);
+    })
+  }
+
+  private processRawMessage(message: Buffer, remoteInfo: dgram.RemoteInfo) {
+    this.debug("Message has come through from %o", remoteInfo);
+    this.debug("Message received: %o", message.toString('ascii'));
+
+    for (const messageProcessor of this.messageProcessors) {
+      if (messageProcessor.canProcess(message)) {
+        this.debug("Message can be processed by %s", messageProcessor.constructor.name);
+        const lightwaveMessage = messageProcessor.process(message);
+        this.processLightwaveMessage(lightwaveMessage);
+        return;
+      }
+    }
+
+    throw "Message cannot be processed";
+  }
+
+  processLightwaveMessage(lightwaveMessage: any) {
+    this.debug("Processing lightwave message: %o", lightwaveMessage);
+    this.debug("Current listeners: %o", this.transactionListeners);
+
+    this.debug("Link response fn", lightwaveMessage.fn)
+    if (lightwaveMessage.fn === "on") {
+      this.emit("deviceTurnedOn", lightwaveMessage.room, lightwaveMessage.dev);
+    }
+
+    if (lightwaveMessage.fn === "off") {
+      this.emit("deviceTurnedOff", lightwaveMessage.room, lightwaveMessage.dev);
+    }
+
+    if (lightwaveMessage.fn === "dim") {
+      this.emit("deviceDimmed", lightwaveMessage.room, lightwaveMessage.dev, Math.round(lightwaveMessage.param / 32 * 100));
+    }
+
+    const listener = this.transactionListeners.get(lightwaveMessage.id);
+    if (!listener) return;
+
+
+    if (lightwaveMessage.error?.match(/^ERR,6,/)) {
+      listener.delay = listener.delay * 2;
+      const msg = `${lightwaveMessage.id},!${listener.message}`
+      this.debug("message errorred, retrying: %o, %o with delay: %o", msg, listener, listener.delay);
+      setTimeout(() => {
+        this.exec(msg, (message: LightwaveTransaction | null, error: Error) => {
+          this.debug("message: %o, error: %o", message, error)
+        });
+      }, Math.round(listener.delay));
+      return;
+    }
+
+    if (listener) {
+      listener.debug("Found transaction listener");
+      listener.callback(lightwaveMessage, null);
+      listener.debug("Transaction completed, removing listener");
+      this.transactionListeners.delete(lightwaveMessage.id);
+      this.commandQueue.busy = false;
+    } else {
+      this.debug("Listener not found for message: %o", lightwaveMessage)
+    }
+
+  }
+}

package/src/LightwaveTextMessageProcessor.ts

@@ -0,0 +1,30 @@
+import { Debugger } from "debug";
+import "./LightwaveTransaction";
+import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
+
+export default class LightwaveTextMessageProcessor implements LightwaveMessageProcessor {
+  debug: Debugger;
+  constructor(debug: Debugger) {
+    this.debug = debug.extend('textMessageProcessor');
+  }
+
+  process(message: Buffer): any {
+    this.debug('Processing message')
+    const textMessage = message.toString('utf-8');
+    var parts = textMessage.split(",");
+    var trans = parts.splice(0, 1);
+    var content = parts.join(",").replace(/(\r\n|\n|\r)/gm, "");
+
+    const response: any = {};
+    response.id = parseInt(trans[0]);
+    response.message = content;
+    response.error = content.match("^ERR") ? content : null;
+    return response;
+  }
+
+  canProcess(message: Buffer): boolean {
+    this.debug("Checking if can process message");
+    return message.toString('utf-8').endsWith("\n");
+  }
+
+}

package/src/LightwaveTransaction.ts

@@ -0,0 +1,9 @@
+import debug from 'debug';
+
+export declare interface LightwaveTransaction {
+  id: number;
+  message: string;
+  error: any;
+  debug: debug.Debugger,
+  callback: (message: LightwaveTransaction, error: Error) => void
+}

package/src/Queue.ts

@@ -0,0 +1,17 @@
+export class Queue<T> {
+  items: T[] = [];
+  busy = false;
+
+  get length(): number {
+    return this.items.length;
+  }
+
+  add(item: T) {
+    this.items.push(item);
+  }
+
+  receive(): T | undefined {
+    return this.items.shift();
+  }
+
+}