@evops/lightwaverf 0.0.6 → 0.0.7

package/dist/index.js

@@ -0,0 +1,505 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const events_1 = __importStar(require("events"));
+const dgram_1 = __importDefault(require("dgram"));
+const request_promise_1 = __importDefault(require("request-promise"));
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('lightwaverf');
+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();
+        const self = this;
+        this.timeout = config.timeout || 1000;
+        this.devices = []; //[{roomId:0,roomName:'',
+        //deviceId:0,deviceName:'',
+        //deviceType:''}];
+        this.setMaxListeners(255);
+        //Counter
+        this.messageCounter = 0;
+        //Config
+        this.config = config;
+        // Use broadcast to discover the IP
+        this.config.ip = this.config.ip || '255.255.255.255';
+        //Send Socket
+        this.sendSocket = dgram_1.default.createSocket("udp4");
+        //Receive socket
+        this.receiveSocket = dgram_1.default.createSocket("udp4");
+        //Receive message
+        this.receiveSocket.on("message", function (message, rinfo) {
+            // 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) => {
+                const response = 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);
+                }
+                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.trans = response.trans !== null ? parseInt(response.trans) : null;
+                response.error = response.pkt === "error" ? response.fn : 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("Link response fn", linkResponse.fn);
+            if (linkResponse.fn === "on") {
+                self.emit("deviceTurnedOn", linkResponse.room, linkResponse.dev);
+            }
+            if (linkResponse.fn === "off") {
+                self.emit("deviceTurnedOff", linkResponse.room, linkResponse.dev);
+            }
+            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;
+            }
+            responseListenerData.listener(linkResponse.error ? linkResponse.error : null, 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', () => {
+            self.stop();
+        });
+    }
+    stop() {
+        debug("Stopping server sockets");
+        this.sendSocket.close();
+        this.receiveSocket.close();
+    }
+    initialiseConfiguration(callback) {
+        //Check config
+        if (!this.config.host) {
+            this.config.host = "web.trustsmartcloud.com";
+        }
+        if (!this.config.email || !this.config.pin) {
+            callback(null, "No email or pin specified. The server configuration (rooms, devices, etc.) cannot be obtained");
+            this.stop();
+        }
+        else {
+            this.getConfiguration(this.config.email, this.config.pin, this.config.host, 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);
+    }
+    /**
+     * Request energy
+     *
+     * @param Function callback The callback function
+     *
+     * @return void
+     */
+    requestEnergy(callback) {
+        this.sendUdp("@?\0", function (error, content) {
+            if (error) {
+                //Send error back
+                callback(error);
+            }
+            else {
+                //Determine if this is the energy monitor
+                //ID,?W=current,max,today,yesterday (all kwh)
+                var values = content.substring(3).split(",");
+                callback(undefined, {
+                    current: parseInt(values[0], 10),
+                    max: parseInt(values[1], 10),
+                    today: parseInt(values[2], 10),
+                    yesterday: parseInt(values[3], 10)
+                });
+            }
+        });
+    }
+    /**
+     * 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) {
+        var state = "1";
+        this.exec("!R" + roomId + "D" + deviceId + "F" + state + "|\0", callback);
+    }
+    /**
+     * Open a device
+     *
+     * @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
+     */
+    openDevice(roomId, deviceId, callback) {
+        var state = ">";
+        this.exec("!R" + roomId + "D" + deviceId + "F" + state + "|\0", callback);
+    }
+    /**
+     * Close a device
+     *
+     * @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
+     */
+    closeDevice(roomId, deviceId, callback) {
+        var state = "<";
+        this.exec("!R" + roomId + "D" + deviceId + "F" + state + "|\0", callback);
+    }
+    /**
+     * Stop a device
+     *
+     * @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
+     */
+    stopDevice(roomId, deviceId, callback) {
+        var state = "^";
+        this.exec("!R" + roomId + "D" + deviceId + "F" + state + "|\0", callback);
+    }
+    /**
+     * Turn all devices in a room off
+     *
+     * @param integer  roomId   The room ID
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    turnRoomOff(roomId, callback) {
+        this.exec("!R" + roomId + "Fa\0", callback);
+    }
+    /**
+     * 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();
+        }
+        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}`;
+        debug(`[${this.config.ip}][trans: ${transactionNumber}] Sending message: ${message}`);
+        //Create buffer from message
+        const messageBuffer = Buffer.from(message, 'utf-8');
+        this.sendSocket.setBroadcast(true);
+        debug("Callback for message: " + message, callback);
+        //Add listener
+        if (callback) {
+            debug("Registering call back with transaction number: " + transactionNumber);
+            this.responseListeners.set(transactionNumber, {
+                time: new Date().getTime(),
+                listener: callback
+            });
+            debug(this.responseListeners);
+            // Expire request, trigger retry
+            setTimeout(() => {
+                const listener = this.responseListeners.get(transactionNumber);
+                if (listener) {
+                    debug("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() {
+        debug("Checking queue");
+        if (this.queue.length === 0)
+            return;
+        if (!this.ready)
+            return;
+        var self = this;
+        this.ready = false;
+        debug("Processing queue...");
+        debug("Items in the queue", this.queue.length);
+        this.send.apply(this, this.queue.shift());
+        setTimeout(function () {
+            self.ready = true;
+            self.process();
+        }, this.timeout);
+    }
+    ;
+    /**
+     * Parser to get de devices from https POST
+     */
+    getDevices(roomsString, devicesString, typesString, callback) {
+        var nrRooms = 8;
+        var nrDevicesPerRoom = 10;
+        var tempRS = roomsString;
+        var tempDS = devicesString;
+        var tempTS = typesString;
+        var deviceCounter = 0;
+        for (var i = 0; i < nrRooms; i++) {
+            var rId = i + 1;
+            tempRS = tempRS.substring(tempRS.indexOf('\"') + 1);
+            var rName = tempRS.substring(0, tempRS.indexOf('\"'));
+            tempRS = tempRS.substring(tempRS.indexOf('\"') + 1);
+            //console.log("room=" + rName);
+            for (var j = 0; j < nrDevicesPerRoom; j++) {
+                var dId = j + 1;
+                tempDS = tempDS.substring(tempDS.indexOf('\"') + 1);
+                var dName = tempDS.substring(0, tempDS.indexOf('\"'));
+                tempDS = tempDS.substring(tempDS.indexOf('\"') + 1);
+                //console.log("devices=" + dName);
+                tempTS = tempTS.substring(tempTS.indexOf('\"') + 1);
+                var dType = tempTS.substring(0, tempTS.indexOf('\"'));
+                tempTS = tempTS.substring(tempTS.indexOf('\"') + 1);
+                //console.log("devices=" + deviceName + " type=" + dType);
+                // 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
+                if (dType == "O" || dType == "D") {
+                    this.devices.push({
+                        roomId: rId, roomName: rName,
+                        deviceId: dId, deviceName: dName,
+                        deviceType: dType
+                    });
+                    //console.log("devices=" + deviceName + " type=" + deviceType);
+                    deviceCounter += 1;
+                }
+            }
+        }
+        if (callback)
+            callback(this.devices, this);
+        //console.log(this.devices);
+    }
+    parseRooms(lightwaveResponse, callback) {
+        debug('Parsing lightwaveResponse: ', lightwaveResponse.content.estates[0].locations[0].zones[0].rooms[0].devices);
+        var home = lightwaveResponse.content.estates[0].locations[0].zones[0];
+        for (var i = 0; i < home.rooms.length; i++) {
+            var r = home.rooms[i];
+            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 = {
+                1: 'L',
+                2: 'D',
+                3: 'P'
+            };
+            for (var j = 0; j < r.devices.length; j++) {
+                var d = r.devices[j];
+                const device = {
+                    roomId: r.room_number,
+                    roomName: r.name,
+                    deviceId: d.device_number,
+                    deviceName: d.name,
+                    deviceType: d.device_type_id
+                };
+                this.devices.push(device);
+            }
+        }
+        debug('Devices:', this.devices);
+        callback(this.devices, null);
+    }
+    ;
+    /**
+     * Connect to the server and obtain the configuration
+     */
+    getConfiguration(email, pin, manager_host, callback) {
+        // An object of options to indicate where to post to
+        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=' + pin + '&username=' + 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);
+        });
+    }
+}
+util_1.default.inherits(LightwaveRF, events_1.default.EventEmitter);
+exports.default = LightwaveRF;