node-red-nodes/hardware/wemo/WeMoNG.js

/**
 * Copyright 2016 IBM Corp.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 **/
var WeMoNG = require('./lib/wemo.js');

var wemo = new WeMoNG();

//this won't work as there is no way to stop it...
//but is that a problem?
var interval = setInterval(wemo.start.bind(wemo), 60000);
wemo.start();

module.exports = function(RED) {
    'use strict';
    var util = require('util');
    var ip = require('ip');
    var bodyParser = require('body-parser');
    var http = require('http');
    var os = require('os');

    var settings = RED.settings;

    var subscriptions = {};
    var sub2dev = {};

    var resubscribe = function() {

        var subs = Object.keys(subscriptions);
        for (var s in subs) {
            if (subs.hasOwnProperty(s)) {
                var sub = subscriptions[subs[s]];
                var dev = wemo.get(subs[s]);
                var reSubOptions = {
                    host: dev.ip,
                    port: dev.port,
                    path: dev.device.UDN.indexOf('Bridge-1_0') < 0 ? '/upnp/event/basicevent1' : '/upnp/event/bridge1',
                    method: 'SUBSCRIBE',
                    headers: {
                        'SID': sub.sid,
                        'TIMEOUT': 'Second-300'
                    }
                };

                var resub_request = http.request(reSubOptions, function(res) {
                    //shoudl raise an error if needed
                    if (res.statusCode != 200) {
                        console.log('problem with resubscription %s - %s', res.statusCode, res.statusMessage);
                        console.log('opts - %s', util.inspect(reSubOptions));
                        console.log('dev - %s', util.inspect(dev));
                        delete subscriptions[dev];
                        delete sub2dev[sub.sid];
                        subscribe({dev: subs[s]});
                    } else {
                        // console.log("resubscription good %s", res.statusCode);
                        // console.log("dev - %s", util.inspect(dev));
                    }
                });

                resub_request.on('error', function() {
                    //console.log("failed to resubscribe to %s", dev.name );
                    //need to find a way to resubsribe
                    delete subscriptions[dev];
                    delete sub2dev[sub.sid];
                    subscribe({dev: subs[s]});
                });

                resub_request.end();

            }
        }

    };

    setInterval(resubscribe, 200000);

    var subscribe = function(node) {
        var dev = node.dev;
        var device = wemo.get(dev);
        if (device) {
            if (subscriptions[dev]) {
                //exists
                subscriptions[dev].count++;
            } else {
                //new

                var ipAddr;
                //device.ip
                var interfaces = os.networkInterfaces();
                var interfaceNames = Object.keys(interfaces);
                for (var name in interfaceNames) {
                    if (interfaceNames.hasOwnProperty(name)) {
                        var addrs = interfaces[interfaceNames[name]];
                        for (var add in addrs) {
                            if (addrs[add].netmask) {
                                //node 0.12 or better
                                if (!addrs[add].internal && addrs[add].family == 'IPv4') {
                                    if (ip.isEqual(ip.mask(addrs[add].address,addrs[add].netmask),ip.mask(device.ip,addrs[add].netmask))) {
                                        ipAddr = addrs[add].address;
                                        break;
                                    }
                                }
                            } else {
                                //node 0.10 not great but best we can do
                                if (!addrs[add].internal && addrs[add].family == 'IPv4') {
                                    ipAddr = addrs[add].address;
                                    break;
                                }
                            }
                        }
                        if (ipAddr) {
                            break;
                        }
                    }
                }

                var callback_url = 'http://' + ipAddr + ':' + settings.uiPort;
                if (settings.httpAdminRoot) {
                    callback_url += settings.httpAdminRoot;
                }

                if (callback_url.lastIndexOf('/') != (callback_url.length - 1)) {
                    callback_url += '/';
                }

                callback_url += 'wemoNG/notification';

                console.log('Callback URL = %s',callback_url);

                var subscribeOptions = {
                    host: device.ip,
                    port: device.port,
                    path: device.device.UDN.indexOf('Bridge-1_0') < 0 ? '/upnp/event/basicevent1' : '/upnp/event/bridge1',
                    method: 'SUBSCRIBE',
                    headers: {
                        'CALLBACK': '<' + callback_url + '>',
                        'NT': 'upnp:event',
                        'TIMEOUT': 'Second-300'
                    }
                };

                //console.log(util.inspect(subscribeOptions));

                var sub_request = http.request(subscribeOptions, function(res) {
                    //console.log("subscribe: %s - %s", device.name, res.statusCode);
                    if (res.statusCode == 200) {
                        subscriptions[dev] = {'count': 1, 'sid': res.headers.sid};
                        sub2dev[res.headers.sid] = dev;
                    } else {
                        console.log('failed to subsrcibe');
                    }
                });

                sub_request.end();
            }
        }
    };

    function unsubscribe(node) {
        var dev = node.dev;
        if (subscriptions[dev]) {
            if (subscriptions[dev].count == 1) {
                var sid = subscriptions[dev].sid;

                var device = wemo.get(dev);
                //need to unsubsribe properly here
                var unSubOpts = {
                    host: device.ip,
                    port: device.port,
                    path: device.device.UDN.indexOf('Bridge-1_0') < 0 ? '/upnp/event/basicevent1' : '/upnp/event/bridge1',
                    method: 'UNSUBSCRIBE',
                    headers: {
                        'SID': sid
                    }
                };

                //console.log(util.inspect(unSubOpts));

                var unSubreq = http.request(unSubOpts, function(res) {
                    //console.log("unsubscribe: %s \n %s", device.name, res.statusCode);
                    delete subscriptions[dev];
                    delete sub2dev[sid];
                });

                unSubreq.end();

            } else {
                subscriptions[dev].count--;
            }
        } else {
            //shouldn't ever get here
        }
    }

    var wemoNGConfig = function(n) {
        RED.nodes.createNode(this,n);
        this.device = n.device;
    };
    RED.nodes.registerType('wemo-dev', wemoNGConfig);

    var wemoNGNode = function(n) {
        RED.nodes.createNode(this,n);
        var node = this;
        node.device = n.device;
        node.name = n.name;
        node.dev = RED.nodes.getNode(node.device).device;
        node.status({fill: 'red',shape: 'dot',text: 'searching'});

        //console.log("Control - %j" ,this.dev);
        if (!wemo.get(node.dev)) {
            wemo.on('discovered', function(d) {
                if (node.dev === d) {
                    node.status({fill: 'green',shape: 'dot',text: 'found'});
                }
            });
        } else {
            node.status({fill: 'green',shape: 'dot',text: 'found'});
        }

        node.on('input', function(msg) {
            var dev = wemo.get(node.dev);

            if (!dev) {
                //need to show that dev not currently found
                console.log('no device found');
                return;
            }

            var on = 0;
            if (typeof msg.payload === 'string') {
                if (msg.payload == 'on' || msg.payload == '1' || msg.payload == 'true') {
                    on = 1;
                } else if (msg.payload === 'toggle') {
                    on = 2;
                }
            } else if (typeof msg.payload === 'number') {
                if (msg.payload >= 0 && msg.payload < 3) {
                    on = msg.payload;
                }
            } else if (typeof msg.payload === 'object') {
                //object need to get complicated here
                if (msg.payload.state && typeof msg.payload.state === 'number') {
                    if (dev.type === 'socket') {
                        if (msg.payload >= 0 && msg.payload < 2) {
                            on = msg.payload.state;
                        }
                    } else if (dev.type === 'light' || dev.type === 'group') {
                        if (msg.payload >= 0 && msg.payload < 3) {
                            on = msg.payload.state;
                        }
                    }
                }
            } else if (typeof msg.payload === 'boolean') {
                if (msg.payload) {
                    on = 1;
                }
            }

            if (dev.type === 'socket') {
                //console.log("socket");
                wemo.toggleSocket(dev, on);
            } else if (dev.type === 'light`') {
                //console.log("light");
                wemo.setStatus(dev,'10006', on);
            } else {
                console.log('group');
                wemo.setStatus(dev, '10006', on);
            }
        });
    };
    RED.nodes.registerType('wemo out', wemoNGNode);

    var wemoNGEvent = function(n) {
        RED.nodes.createNode(this,n);
        var node = this;
        node.ipaddr = n.ipaddr;
        node.device = n.device;
        node.name = n.name;
        node.topic = n.topic;
        node.dev = RED.nodes.getNode(node.device).device;

        node.status({fill: 'red',shape: 'dot',text: 'searching'});

        var onEvent = function(notification) {
            var d = sub2dev[notification.sid];
            if (d == node.dev) {
                var dd = wemo.get(node.dev);
                notification.type = dd.type;
                notification.name = dd.name;
                if (!notification.id) {
                    notification.id = node.dev;
                }

                var msg = {
                    topic: node.topic ? node.topic : 'wemo',
                    payload: notification
                };

                switch (notification.type){
                    case 'light':
                    case 'group':
                        if (dd.id === notification.id) {
                            node.send(msg);
                        }
                        break;
                    case 'socket':
                        node.send(msg);
                        break;
                    default:
                }

            }
        };

        wemo.on('event', onEvent);

        if (node.dev) {
            //subscribe to events
            if (wemo.get(node.dev)) {
                node.status({fill: 'green',shape: 'dot',text: 'found'});
                subscribe(node);
            } else {
                wemo.on('discovered', function(d) {
                    if (node.dev === d) {
                        node.status({fill: 'green',shape: 'dot',text: 'found'});
                        subscribe(node);
                    }
                });
            }
        } else if (node.ipaddr) {
            //legacy
            var devices = Object.keys(wemo.devices);
            for (var d in devices) {
                if (devices.hasOwnProperty(d)) {
                    var device = devices[d];
                    if (device.ip === node.ipaddr) {
                        node.dev = device.id;
                        node.status({fill: 'green',shape: 'circle',text: 'reconfigure'});
                        subscribe(node);
                        break;
                    }
                }
            }
        }

        node.on('close', function(done) {
            //should un subscribe from events
            wemo.removeListener('event', onEvent);
            unsubscribe(node);
            done();
        });
    };
    RED.nodes.registerType('wemo in', wemoNGEvent);

    RED.httpAdmin.get('/wemoNG/devices', function(req, res) {
        res.json(wemo.devices);
    });

    RED.httpAdmin.use('/wemoNG/notification',bodyParser.raw({type: 'text/xml'}));

    RED.httpAdmin.notify('/wemoNG/notification', function(req, res) {
        var notification = {
            'sid': req.headers.sid
        };
        //console.log("Incoming Event %s", req.body.toString());
        wemo.parseEvent(req.body.toString()).then(function(evt) {
            evt.sid = notification.sid;
            wemo.emit('event',evt);
        });
        res.send('');
    });
};