node-red-contrib-ccu 3.4.2 → 4.0.0

package/nodes/ccu-value.html

@@ -22,7 +22,7 @@
             rampType: {value: 'undefined'},
             working: {value: false},
             ccuConfig: {value: 'localhost', type: 'ccu-connection', required: true},
-            topic: {value: '${CCU}/${Interface}/${channel}/${datapoint}'} // eslint-disable-line no-template-curly-in-string
+            topic: {value: '${CCU}/${Interface}/${channel}/${datapoint}'}  
         },
         inputs: 1,
         outputs: 1,
@@ -43,7 +43,6 @@
             return this.name ? 'node_label_italic' : '';
         },
         oneditprepare() {
-            console.log(this);
 
             const $nodeInputIface = $('#node-input-iface');
             const $nodeInputCcuConfig = $('#node-input-ccuConfig');
@@ -56,6 +55,7 @@
             let channelList;
             let ifacesLoaded = false;
             let ifacesPending = false;
+            let ifaceLoadRetries = 5;
 
             function loadIfaces(iface, cb) {
                 if (ifacesPending) {
@@ -63,7 +63,6 @@
                 }
 
                 ifacesPending = true;
-                console.log('loadIfaces()');
                 $nodeInputIface.html('<option value=""></option>');
                 const nodeId = $nodeInputCcuConfig.val();
                 if (nodeId === '_ADD_') {
@@ -83,6 +82,12 @@
                             cb();
                             ifacesPending = false;
                         }
+                    }).fail(() => {
+                        // config node not (yet) available in the runtime - allow retrying
+                        ifacesPending = false;
+                        if (ifaceLoadRetries-- > 0) {
+                            setTimeout(() => loadIfaces(iface, cb), 1000);
+                        }
                     });
                 }
             }
@@ -92,19 +97,16 @@
                     return;
                 }
 
-                console.log('loadConfig()');
                 const nodeId = $nodeInputCcuConfig.val();
                 const url = 'ccu?config=' + nodeId + '&type=channels&iface=' + $nodeInputIface.val();
                 $.getJSON(url, d => {
                     data = d;
-                    console.log(d);
                     autocompleteChannel();
                     autocompleteDatapoint();
                 });
             }
 
             $nodeInputCcuConfig.change(() => {
-                console.log('$nodeInputCcuConfig change');
                 loadIfaces(this.iface, () => {
                     ifacesLoaded = true;
                     $nodeInputIface.removeAttr('disabled');
@@ -113,6 +115,10 @@
                 });
             });
 
+            // Node-RED 4.x does not reliably fire the change event on dialog
+            // open - trigger the initial load explicitly (see ROADMAP.md 8.1)
+            $nodeInputCcuConfig.trigger('change');
+
             $('#node-input-onEnabled').change(() => {
                 if ($('#node-input-onEnabled').is(':checked')) {
                     $('#node-input-on').removeAttr('disabled');
@@ -211,7 +217,6 @@
             }
 
             $nodeInputIface.change(() => {
-                console.log('$nodeInputIface change');
                 $('.BURST').hide();
                 loadConfig();
             });

package/nodes/ccu-value.js

@@ -25,10 +25,10 @@ module.exports = function (RED) {
                     stable: config.working,
                     iface: config.iface,
                     channel: String(config.channel).split(' ')[0],
-                    datapoint: config.datapoint
+                    datapoint: config.datapoint,
                 };
 
-                this.idSubscription = this.ccu.subscribe(filter, message => {
+                this.idSubscription = this.ccu.subscribe(filter, (message) => {
                     this.status({fill: 'green', shape: 'ring', text: String(message.payload)});
                     message.topic = this.ccu.topicReplace(config.topic, message);
                     this.send(message);
@@ -38,7 +38,13 @@ module.exports = function (RED) {
             this.on('input', (message, send, done) => {
                 const [tIface, tChannel, tDatapoint] = (message.topic || '').split('.');
                 const iface = config.iface || message.interface || message.iface || tIface;
-                const channel = (config.channel || this.ccu.findChannel(message.channelName, true) || message.channel || tChannel || '').split(' ')[0];
+                const channel = (
+                    config.channel ||
+                    this.ccu.findChannel(message.channelName, true) ||
+                    message.channel ||
+                    tChannel ||
+                    ''
+                ).split(' ')[0];
                 const datapoint = config.datapoint || message.datapoint || tDatapoint;
 
                 if (!iface) {
@@ -56,6 +62,12 @@ module.exports = function (RED) {
                     return;
                 }
 
+                if (message.payload === undefined) {
+                    // don't write to the CCU when the incoming msg carries no payload (PR #173)
+                    done();
+                    return;
+                }
+
                 let ramp;
                 switch (config.rampType) {
                     case 'msg':
@@ -95,11 +107,19 @@ module.exports = function (RED) {
                 on = Number.parseFloat(on);
 
                 if (!ramp && !on) {
-                    this.ccu[this.queue ? 'setValueQueued' : 'setValue'](iface, channel, datapoint, message.payload, config.burst).then(() => {
-                        done();
-                    }).catch(error => {
-                        done(error);
-                    });
+                    this.ccu[this.queue ? 'setValueQueued' : 'setValue'](
+                        iface,
+                        channel,
+                        datapoint,
+                        message.payload,
+                        config.burst,
+                    )
+                        .then(() => {
+                            done();
+                        })
+                        .catch((error) => {
+                            done(error);
+                        });
                 } else {
                     const parameters = {};
                     if (on) {
@@ -112,11 +132,14 @@ module.exports = function (RED) {
 
                     parameters[datapoint] = this.ccu.paramCast(iface, channel, 'VALUES', datapoint, message.payload);
                     // Todo queue
-                    this.ccu.methodCall(iface, 'putParamset', [channel, 'VALUES', parameters]).then(() => {
-                        done();
-                    }).catch(error => {
-                        done(error);
-                    });
+                    this.ccu
+                        .methodCall(iface, 'putParamset', [channel, 'VALUES', parameters])
+                        .then(() => {
+                            done();
+                        })
+                        .catch((error) => {
+                            done(error);
+                        });
                 }
             });
 

package/nodes/lib/base62.js

@@ -0,0 +1,22 @@
+/* Replaces the buffer-base62 dependency (which pulled in big-number,
+   buffer-reverse and underscore). BigInt implementation, byte-for-byte
+   identical output: big-endian buffer value, alphabet 0-9A-Za-z. */
+
+const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+function toBase62(buffer) {
+    let n = 0n;
+    for (const byte of buffer) {
+        n = n * 256n + BigInt(byte);
+    }
+
+    let out = '';
+    do {
+        out = alphabet[Number(n % 62n)] + out;
+        n /= 62n;
+    } while (n > 0n);
+
+    return out;
+}
+
+module.exports = {toBase62};

package/nodes/lib/discover.js

@@ -0,0 +1,127 @@
+/* Vendored from https://github.com/hobbyquaker/hm-discover (MIT, same
+   author), rewritten without the abandoned `binary` and `async`
+   dependencies. Sends the eQ-3 UDP broadcast discovery datagram and
+   probes the known interface ports on every responding CCU. */
+
+const net = require('net');
+const dgram = require('dgram');
+
+const SERVICE_PORTS = {
+    ReGaHSS: 1999,
+    'BidCos-Wired': 2000,
+    'BidCos-RF': 2001,
+    'HmIP-RF': 2010,
+    VirtualDevices: 9292,
+    CUxD: 8701,
+    'CCU-Jack': 2121,
+};
+
+function checkService(host, port) {
+    return new Promise((resolve) => {
+        const c = net.connect({port, host, timeout: 1200}, () => {
+            resolve(true);
+            c.end();
+        });
+        c.on('timeout', () => {
+            resolve(false);
+            c.destroy();
+        });
+        c.on('error', () => {
+            resolve(false);
+        });
+    });
+}
+
+/* Response layout: 5-byte header 02 8f 91 c0 01, then NUL-terminated
+   type, NUL-terminated serial, 3 bytes, NUL-terminated version. */
+function parseResponse(message) {
+    if (message.length < 5 || message.slice(0, 5).toString('hex') !== '028f91c001') {
+        return null;
+    }
+
+    let offset = 5;
+    const readString = () => {
+        const end = message.indexOf(0, offset);
+        if (end === -1) {
+            return null;
+        }
+
+        const string = message.slice(offset, end).toString();
+        offset = end + 1;
+        return string;
+    };
+
+    const type = readString();
+    const serial = readString();
+    offset += 3;
+    const version = readString();
+
+    if (type === null || serial === null || version === null) {
+        return null;
+    }
+
+    return {type, serial, version};
+}
+
+function hmDiscover(options, callback) {
+    if (typeof options === 'function') {
+        callback = options;
+        options = {};
+    } else if (typeof options !== 'object' || options === null) {
+        options = {};
+    }
+
+    const timeout = options.timeout || 1200;
+    const remoteport = 43439;
+    // Kept verbatim from hm-discover — Buffer.from() coerces the string
+    // elements to 0x00, and that is the datagram CCUs answer to.
+    const message = Buffer.from([0x02, 0x8f, 0x91, 0xc0, 0x01, 'e', 'Q', '3', 0x2d, 0x2a, 0x00, 0x2a, 0x00, 0x49]);
+    const found = [];
+    const foundAddresses = [];
+    const client = dgram.createSocket('udp4');
+
+    client.on('error', () => {
+        /* ignore — discovery is best-effort; an unhandled 'error' event
+           would crash the whole process */
+    });
+
+    client.on('message', (msg, remote) => {
+        const parsed = parseResponse(msg);
+        if (!parsed || foundAddresses.includes(remote.address)) {
+            return;
+        }
+
+        foundAddresses.push(remote.address);
+        const device = {
+            type: parsed.type,
+            serial: parsed.serial,
+            version: parsed.version,
+            address: remote.address,
+        };
+
+        Promise.all(
+            Object.keys(SERVICE_PORTS).map((name) =>
+                checkService(remote.address, SERVICE_PORTS[name]).then((ok) => [name, ok]),
+            ),
+        ).then((entries) => {
+            const interfaces = {};
+            entries.forEach(([name, ok]) => {
+                interfaces[name] = ok;
+            });
+            device.interfaces = interfaces;
+            found.push(device);
+        });
+    });
+
+    client.bind(() => {
+        client.setBroadcast(true);
+        client.send(message, 0, message.length, remoteport, '255.255.255.255');
+    });
+
+    setTimeout(() => {
+        client.close();
+        callback(found);
+    }, timeout);
+}
+
+module.exports = hmDiscover;

package/nodes/lib/nextport.js

@@ -0,0 +1,30 @@
+/* Vendored from https://github.com/hobbyquaker/nextport (MIT, same author).
+   Finds the next free TCP port at or above the given port. */
+
+const net = require('net');
+
+function nextport(port, address, cb) {
+    if (typeof address === 'function') {
+        cb = address;
+        address = '0.0.0.0';
+    }
+
+    const server = net.createServer();
+    server.on('listening', () => {
+        server.close();
+    });
+    server.on('close', () => {
+        cb(port);
+    });
+    server.on('error', () => {
+        port += 1;
+        if (port <= 65535) {
+            nextport(port, address, cb);
+        } else {
+            cb(null);
+        }
+    });
+    server.listen(port, address);
+}
+
+module.exports = nextport;

package/nodes/lib/similarity.js

@@ -0,0 +1,51 @@
+/* Replaces the deprecated string-similarity package. Same algorithm as its
+   compareTwoStrings: Sørensen–Dice coefficient on bigram multisets, with
+   whitespace stripped first. */
+
+function compareTwoStrings(first, second) {
+    first = first.replace(/\s+/g, '');
+    second = second.replace(/\s+/g, '');
+
+    if (first === second) {
+        return 1;
+    }
+
+    if (first.length < 2 || second.length < 2) {
+        return 0;
+    }
+
+    const firstBigrams = new Map();
+    for (let i = 0; i < first.length - 1; i++) {
+        const bigram = first.substring(i, i + 2);
+        firstBigrams.set(bigram, (firstBigrams.get(bigram) || 0) + 1);
+    }
+
+    let intersectionSize = 0;
+    for (let i = 0; i < second.length - 1; i++) {
+        const bigram = second.substring(i, i + 2);
+        const count = firstBigrams.get(bigram) || 0;
+        if (count > 0) {
+            firstBigrams.set(bigram, count - 1);
+            intersectionSize++;
+        }
+    }
+
+    return (2 * intersectionSize) / (first.length + second.length - 2);
+}
+
+function bestMatch(mainString, targetStrings) {
+    let best = targetStrings[0];
+    let bestRating = -1;
+
+    for (const target of targetStrings) {
+        const rating = compareTwoStrings(mainString, target);
+        if (rating > bestRating) {
+            bestRating = rating;
+            best = target;
+        }
+    }
+
+    return best;
+}
+
+module.exports = {compareTwoStrings, bestMatch};

package/nodes/lib/status.js

@@ -3,7 +3,7 @@ module.exports = (that, data) => {
     if (!that.iface) {
         if (data.ifaceStatus) {
             let status = 0;
-            Object.keys(data.ifaceStatus).forEach(s => {
+            Object.keys(data.ifaceStatus).forEach((s) => {
                 if (data.ifaceStatus[s]) {
                     status += 1;
                 }