@evops/lightwaverf 0.0.7 → 0.0.8

package/dist/LightwaveAccount.d.ts

@@ -0,0 +1,13 @@
+import Debug, { Debugger } from "debug";
+import { LightwaveDevice } from "./LightwaveDevice";
+import { LightwaveRFClient } from "./LightwaveRFClient";
+export declare class LightwaveAccount {
+    debug: Debug.Debugger;
+    client: LightwaveRFClient;
+    email: string;
+    pin: string;
+    mainDebug: Debug.Debugger;
+    constructor(debug: Debugger, client: LightwaveRFClient, email: string, pin: string);
+    getConfiguration(callback: any): void;
+    parseRooms(lightwaveResponse: any, callback: (devices: LightwaveDevice[], error: Error | null) => void): void;
+}

package/dist/LightwaveAccount.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveAccount = void 0;
+const request_promise_1 = __importDefault(require("request-promise"));
+const LightwaveDevice_1 = require("./LightwaveDevice");
+class LightwaveAccount {
+    constructor(debug, client, email, pin) {
+        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) {
+        this.debug('Getting rooms from LightWave');
+        var self = this;
+        var host = 'https://control-api.lightwaverf.com';
+        var json = request_promise_1.default.defaults({
+            json: true
+        });
+        var auth, 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, callback) {
+        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 = new Map();
+            deviceTypeMapping.set(1, LightwaveDevice_1.LightwaveDeviceType.OnOff);
+            deviceTypeMapping.set(2, LightwaveDevice_1.LightwaveDeviceType.Dimmer);
+            deviceTypeMapping.set(3, LightwaveDevice_1.LightwaveDeviceType.OnOff);
+            for (var j = 0; j < r.devices.length; j++) {
+                var d = r.devices[j];
+                const device = new LightwaveDevice_1.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);
+    }
+    ;
+}
+exports.LightwaveAccount = LightwaveAccount;

package/dist/LightwaveDevice.d.ts

@@ -0,0 +1,26 @@
+import Debug from 'debug';
+import { LightwaveRFClient } from './LightwaveRFClient';
+export interface LightwaveRFDeviceInterface {
+    roomId: number;
+    deviceId: number;
+    roomName: string;
+    deviceName: string;
+    deviceType: string;
+}
+export declare enum LightwaveDeviceType {
+    Dimmer = "D",
+    OnOff = "O"
+}
+export declare 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);
+    turnOn(): Promise<void>;
+    turnOff(): Promise<void>;
+    dim(percentage: number): Promise<void>;
+}

package/dist/LightwaveDevice.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveDevice = exports.LightwaveDeviceType = void 0;
+var LightwaveDeviceType;
+(function (LightwaveDeviceType) {
+    LightwaveDeviceType["Dimmer"] = "D";
+    LightwaveDeviceType["OnOff"] = "O";
+})(LightwaveDeviceType = exports.LightwaveDeviceType || (exports.LightwaveDeviceType = {}));
+class LightwaveDevice {
+    constructor(client, debug, roomId, deviceId, roomName, deviceName, deviceType) {
+        this.client = client;
+        this.debug = debug.extend(deviceName);
+        this.roomId = roomId;
+        this.deviceId = deviceId;
+        this.roomName = roomName;
+        this.deviceName = deviceName;
+        this.deviceType = deviceType;
+    }
+    turnOn() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.debug("Device turning on");
+                this.client.send(`R${this.roomId}D${this.deviceId}F1`, (message, error) => {
+                    resolve();
+                });
+            });
+        });
+    }
+    turnOff() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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();
+                });
+            });
+        });
+    }
+    dim(percentage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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();
+                });
+            });
+        });
+    }
+}
+exports.LightwaveDevice = LightwaveDevice;

package/dist/LightwaveJsonMessageProcessor.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Debugger } from "debug";
+import "./LightwaveTransaction";
+import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
+export declare class LightwaveJsonMessageProcessor implements LightwaveMessageProcessor {
+    debug: Debugger;
+    constructor(debug: Debugger);
+    process(message: Buffer): any;
+    canProcess(message: Buffer): boolean;
+}

package/dist/LightwaveJsonMessageProcessor.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveJsonMessageProcessor = void 0;
+require("./LightwaveTransaction");
+class LightwaveJsonMessageProcessor {
+    constructor(debug) {
+        this.debug = debug.extend('jsonMessageProcessor');
+    }
+    process(message) {
+        var _a;
+        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 = (_a = json.error) !== null && _a !== void 0 ? _a : null;
+        return response;
+    }
+    canProcess(message) {
+        this.debug("Checking if can process message");
+        return message.toString('utf-8').startsWith('*!');
+    }
+}
+exports.LightwaveJsonMessageProcessor = LightwaveJsonMessageProcessor;

package/dist/LightwaveMessage.d.ts

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

package/dist/LightwaveMessage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/LightwaveMessageProcessor.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import "./LightwaveTransaction";
+declare interface LightwaveMessageProcessor {
+    process(message: Buffer): any;
+    canProcess(message: Buffer): boolean;
+}
+export default LightwaveMessageProcessor;

package/dist/LightwaveMessageProcessor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./LightwaveTransaction");

package/dist/LightwaveRFClient.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import events from 'events';
+import { Debugger } from 'debug';
+import { LightwaveTransaction } from './LightwaveTransaction';
+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 declare class LightwaveRFClient extends events.EventEmitter implements LightwaveRFClientInterface {
+    private senderSocket;
+    private receiverSocket;
+    private senderSocketReady;
+    private receiverSocketReady;
+    private commandQueue;
+    private messageProcessors;
+    private debug;
+    private ip;
+    private transactionListeners;
+    delay: number;
+    constructor(debug: Debugger, ip?: string, port?: number);
+    stop(): void;
+    private socketReady;
+    private checkRegistration;
+    send(message: (string | Buffer), callback: (transaction: LightwaveTransaction | null, error: Error) => void): void;
+    private processQueue;
+    private exec;
+    private processRawMessage;
+    processLightwaveMessage(lightwaveMessage: any): void;
+}
+export {};

package/dist/LightwaveRFClient.js

@@ -0,0 +1,202 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveRFClient = void 0;
+const dgram_1 = __importDefault(require("dgram"));
+const events_1 = __importDefault(require("events"));
+const LightwaveTextMessageProcessor_1 = __importDefault(require("./LightwaveTextMessageProcessor"));
+const LightwaveJsonMessageProcessor_1 = require("./LightwaveJsonMessageProcessor");
+const Queue_1 = require("./Queue");
+class LightwaveRFClient extends events_1.default.EventEmitter {
+    constructor(debug, ip = "255.255.255.255", port = 9761) {
+        super();
+        this.senderSocketReady = false;
+        this.receiverSocketReady = false;
+        this.commandQueue = new Queue_1.Queue();
+        this.messageProcessors = [];
+        this.transactionListeners = new Map();
+        this.delay = 125;
+        this.ip = ip;
+        this.debug = debug.extend('client');
+        this.senderSocket = dgram_1.default.createSocket('udp4');
+        this.receiverSocket = dgram_1.default.createSocket('udp4');
+        this.messageProcessors.push(new LightwaveJsonMessageProcessor_1.LightwaveJsonMessageProcessor(this.debug));
+        this.messageProcessors.push(new LightwaveTextMessageProcessor_1.default(this.debug));
+        this.receiverSocket.on('message', (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();
+        });
+    }
+    stop() {
+        try {
+            this.receiverSocket.close();
+        }
+        catch (_a) { }
+    }
+    socketReady() {
+        if (!this.senderSocketReady)
+            return;
+        if (!this.receiverSocketReady)
+            return;
+        this.checkRegistration();
+        this.processQueue();
+    }
+    checkRegistration() {
+        this.debug("Checking registration");
+        this.send("@H", (transaction, error) => {
+            if (error) {
+                this.debug('Error: %o', error);
+            }
+            this.debug(transaction);
+            this.emit('ready');
+        });
+    }
+    send(message, callback) {
+        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({
+            id: transaction,
+            message: messageWithTransaction,
+            debug: transactionDebug,
+            callback
+        });
+        this.processQueue();
+    }
+    processQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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, 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 === null || command === void 0 ? void 0 : command.id}`);
+            transactionDebug("Starting new transaction");
+            this.exec(command.message, (message, error) => { });
+        });
+    }
+    exec(message, callback) {
+        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, bytes) => {
+            if (error) {
+                this.debug("Message send errror: %o", error);
+            }
+            this.debug("Message sent: %s, length: %d", message, bytes);
+        });
+    }
+    processRawMessage(message, 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) {
+        var _a;
+        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 ((_a = lightwaveMessage.error) === null || _a === void 0 ? void 0 : _a.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, 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);
+        }
+    }
+}
+exports.LightwaveRFClient = LightwaveRFClient;

package/dist/LightwaveTextMessageProcessor.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Debugger } from "debug";
+import "./LightwaveTransaction";
+import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
+export default class LightwaveTextMessageProcessor implements LightwaveMessageProcessor {
+    debug: Debugger;
+    constructor(debug: Debugger);
+    process(message: Buffer): any;
+    canProcess(message: Buffer): boolean;
+}

package/dist/LightwaveTextMessageProcessor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./LightwaveTransaction");
+class LightwaveTextMessageProcessor {
+    constructor(debug) {
+        this.debug = debug.extend('textMessageProcessor');
+    }
+    process(message) {
+        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 = {};
+        response.id = parseInt(trans[0]);
+        response.message = content;
+        response.error = content.match("^ERR") ? content : null;
+        return response;
+    }
+    canProcess(message) {
+        this.debug("Checking if can process message");
+        return message.toString('utf-8').endsWith("\n");
+    }
+}
+exports.default = LightwaveTextMessageProcessor;

package/dist/LightwaveTransaction.d.ts

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

package/dist/LightwaveTransaction.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Queue.d.ts

@@ -0,0 +1,7 @@
+export declare class Queue<T> {
+    items: T[];
+    busy: boolean;
+    get length(): number;
+    add(item: T): void;
+    receive(): T | undefined;
+}

package/dist/Queue.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue {
+    constructor() {
+        this.items = [];
+        this.busy = false;
+    }
+    get length() {
+        return this.items.length;
+    }
+    add(item) {
+        this.items.push(item);
+    }
+    receive() {
+        return this.items.shift();
+    }
+}
+exports.Queue = Queue;