smart-nodes 0.3.36 → 0.4.0

package/hysteresis/hysteresis.js

@@ -7,10 +7,22 @@ module.exports = function (RED)
         const node = this;
         RED.nodes.createNode(node, config);
 
+
+        // ###################
+        // # Class constants #
+        // ###################
+
+
+        // #######################
+        // # Global help objects #
+        // #######################
         const smart_context = require("../persistence.js")(RED);
         const helper = require("../smart_helper.js");
 
-        // persistant values
+
+        // #####################
+        // # persistent values #
+        // #####################
         var node_settings = {
             last_value: null,
             last_result: null,
@@ -46,22 +58,52 @@ module.exports = function (RED)
             smart_context.del(node.id);
         }
 
-        // dynamic config
+
+        // ##################
+        // # Dynamic config #
+        // ##################
         let out_higher = helper.evaluateNodeProperty(RED, config.out_higher, config.out_higher_type);
         let out_lower = helper.evaluateNodeProperty(RED, config.out_lower, config.out_lower_type);
         let send_only_change = helper.evaluateNodeProperty(RED, config.send_only_change, "bool");
         let outputs = helper.evaluateNodeProperty(RED, config.outputs, "num");
 
-        // runtime values
 
+        // ##################
+        // # Runtime values #
+        // ##################
+
+
+        // ###############
+        // # Node events #
+        // ###############
         node.on("input", function (msg)
         {
-            let value = parseFloat(msg.payload);
+            handleTopic(msg);
+
+            setStatus();
+
+            if (config.save_state)
+                smart_context.set(node.id, node_settings);
+        });
+
+        node.on("close", function ()
+        {
+        });
+
+
+        // #####################
+        // # Private functions #
+        // #####################
+
+        // This is the main function which handles all topics that was received.
+        let handleTopic = msg =>
+        {
             let real_topic = helper.getTopicName(msg.topic);
+            let value = parseFloat(msg.payload);
 
             if (isNaN(value))
             {
-                // node.error("Invalid payload: " + msg.payload);
+                console.warn("Invalid payload: " + msg.payload);
                 return;
             }
 
@@ -69,67 +111,51 @@ module.exports = function (RED)
             {
                 case "setpoint":
                     node_settings.setpoint = value;
-                    node.status({ fill: node_settings.last_result ? "green" : "red", shape: "ring", text: helper.getCurrentTimeForStatus() + ": New setpoint: " + value + "" });
-
-                    if (config.save_state)
-                        smart_context.set(node.id, node_settings);
                     break;
 
                 case "hysteresis":
                     node_settings.hysteresis = value;
-                    node.status({ fill: node_settings.last_result ? "green" : "red", shape: "ring", text: helper.getCurrentTimeForStatus() + ": New hysteresis: " + value + "" });
-
-                    if (config.save_state)
-                        smart_context.set(node.id, node_settings);
                     break;
 
                 default:
-                    let result = getResult(value);
-                    let out_msg = null;
-
-                    // No change, nothing to send
-                    if (result !== null)
-                    {
-                        // Get custom output message
-                        if (result)
-                            out_msg = createMessage(out_higher, config.out_higher_type, msg, value);
-                        else
-                            out_msg = createMessage(out_lower, config.out_lower_type, msg, value);
-
-                        // Overwrite automatic values, if not already defined
-                        if (typeof out_msg.payload === "undefined")
-                            out_msg.payload = result ?? node_settings.last_result;
-
-                        // Separate outputs if needed
-                        if (outputs == 2)
-                        {
-                            if (result)
-                                out_msg = [out_msg, null];
-                            else
-                                out_msg = [null, out_msg];
-                        }
-
-                        // Send only if needed
-                        if (send_only_change == false || node_settings.last_result != result)
-                            node.send(out_msg);
-
-                        node_settings.last_result = result;
-                        node_settings.last_message = out_msg;
-                    }
-
-                    node_settings.last_value = value;
-
-                    setStatus(result === null);
-
-                    if (config.save_state)
-                        smart_context.set(node.id, node_settings);
+                    node_settings.last_value = value
                     break;
             }
-        });
 
-        node.on("close", function ()
-        {
-        });
+            // Always calculate new result
+            let result = getResult(node_settings.last_value);
+            let out_msg = null;
+
+            // No change, nothing to send
+            if (result === null)
+                return;
+
+            // Get custom output message
+            if (result)
+                out_msg = createMessage(out_higher, config.out_higher_type, msg, node_settings.last_value);
+            else
+                out_msg = createMessage(out_lower, config.out_lower_type, msg, node_settings.last_value);
+
+            // Overwrite automatic values, if not already defined
+            if (typeof out_msg.payload === "undefined")
+                out_msg.payload = result ?? node_settings.last_result;
+
+            // Separate outputs if needed
+            if (outputs == 2)
+            {
+                if (result)
+                    out_msg = [out_msg, null];
+                else
+                    out_msg = [null, out_msg];
+            }
+
+            // Send only if needed
+            if (send_only_change == false || node_settings.last_result != result)
+                node.send(out_msg);
+
+            node_settings.last_result = result;
+            node_settings.last_message = out_msg;
+        }
 
         let getResult = value =>
         {
@@ -145,19 +171,17 @@ module.exports = function (RED)
             return node_settings.last_result;
         }
 
-        let setStatus = noChange =>
+        let setStatus = () =>
         {
-            if (noChange)
-                node.status({ fill: node_settings.last_result ? "green" : "red", shape: "ring", text: helper.getCurrentTimeForStatus() + ": No change by value " + node_settings.last_value + "" });
-            else if (node_settings.last_result === true)
-                node.status({ fill: "green", shape: "dot", text: helper.getCurrentTimeForStatus() + ": Turned higher by value " + node_settings.last_value + "" });
-            else if (node_settings.last_result === false)
-                node.status({ fill: "red", shape: "dot", text: helper.getCurrentTimeForStatus() + ": Turned lower by value " + node_settings.last_value + "" });
+            if (node_settings.last_result == null)
+                node.status({ fill: "yellow", shape: "ring", text: helper.getCurrentTimeForStatus() + ": ❓ S: " + node_settings.setpoint + " - H: " + node_settings.hysteresis + " - V: null" });
+            else
+                node.status({ fill: node_settings.last_result ? "green" : "red", shape: "dot", text: helper.getCurrentTimeForStatus() + ": " + (node_settings.last_result ? "⬆️" : "⬇️") + " S: " + node_settings.setpoint + " - H: " + node_settings.hysteresis + " - V: " + node_settings.last_value.toFixed(2) });
         }
 
         let createMessage = (out_msg, out_type, msg, value) =>
         {
-            return Object.assign({}, out_type == "original" ? msg : out_msg, {
+            return helper.cloneObject(out_type == "ORIGINAL" ? msg : out_msg, {
                 smart_info: {
                     last_result: node_settings.last_result,
                     hysteresis: node_settings.hysteresis,
@@ -165,7 +189,7 @@ module.exports = function (RED)
                     last_value: node_settings.last_value,
                     value: value
                 }
-            })
+            });
         };
 
         if (config.save_state && config.resend_on_start && node_settings.last_result !== null && node_settings.last_message !== null)
@@ -175,16 +199,18 @@ module.exports = function (RED)
                 if (outputs == 2)
                 {
                     if (node_settings.last_result)
-                        node.send([node_settings.last_message, null]);
+                        node.send([helper.cloneObject(node_settings.last_message), null]);
                     else
-                        node.send([null, node_settings.last_message]);
+                        node.send([null, helper.cloneObject(node_settings.last_message)]);
                 }
                 else
                 {
-                    node.send(node_settings.last_message);
+                    node.send(helper.cloneObject(node_settings.last_message));
                 }
             }, 10000);
         }
+
+        setStatus();
     }
 
     RED.nodes.registerType("smart_hysteresis", HysteresisNode);

package/hysteresis/locales/de-DE/hysteresis.html

@@ -0,0 +1,36 @@
+<script type="text/html" data-help-name="smart_hysteresis">
+    <p>
+        Diese Node sendet die einkommende Nachricht an den Ausgang <code>Über</code>, wenn der einkommende Wert größer gleich dem Sollwert plus Hysterese ist und
+        die einkommende Nachricht an den Ausgang <code>Unter</code>, wenn der einkommende Wert kleiner gleich dem Sollwert minus Hysterese ist.<br/>
+        Die Nachricht wird dabei nur einmalig bei über- bzw. unterschreiten des Grenzwertes weitergeleitet.<br/>
+        Die Node behält den aktuellen Zustand auch nach dem Deploy bei.
+    </p>
+    <p>
+        <b>Hinweis:</b> Smart Nodes verwenden Topics im Format <code>name#nummer</code>, damit können verschiedene Smart Nodes mit dem gleichen Topic angesteuert werden.<br/>
+        Diese Node verwendet nur den Teil <code>name</code>. <code>#</code> und <code>nummer</code> sind dabei optional.
+    </p>
+    <p>
+        Folgende topics werden akzeptiert:
+        <table>
+            <thead>
+                <tr>
+                    <th>Topic</th>
+                    <th>Beschreibung</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><code>setpoint</code></td>
+                    <td>Überschreibt den Sollwert mit <code>msg.payload</code>.</td>
+                </tr>
+                <tr>
+                    <td><code>hysteresis</code></td>
+                    <td>Überschreibt die Hysterese mit <code>msg.payload</code>.</td>
+                </tr>
+            </tbody>
+        </table>
+    </p>
+    <p>
+        Die einkommende Nachricht wird mit den angegebenen Ausgangsnachrichten ergänzt, sofern nicht Originalnachricht ausgewählt wurde.
+    </p>
+</script>

package/hysteresis/locales/de-DE/hysteresis.json

@@ -0,0 +1,27 @@
+{
+    "hysteresis": {
+        "ui": {
+            "name": "Name",
+            "setpoint": "Sollwert",
+            "hysteresis": "Hysterese",
+            "output_messages": "Ausgangsnachrichten",
+            "over": "Über",
+            "under": "Unter",
+            "send": "Senden",
+            "outputs": "Ausgänge",
+
+            "note": "Hinweis:",
+            "note_text": "<code>msg.payload</code> wird automatisch auf das Hystere-Ergebnis gesetzt,<br/>sofern es nicht bereits hier in der Konfiguration gesetzt wurde.<br/><code>true</code> wenn höher, <code>false</code> wenn niedriger",
+            "system_start": "Systemstart",
+            "save_state": "Zustand speichern",
+            "send_after_start": "Letze Nachricht 10 Sekunden nach dem Start senden",
+
+            "send_nothing": "Nichts senden",
+            "original_message": "Originalnachricht",
+            "send_only_change": "Nur bei Änderung",
+            "always": "Immer",
+            "common_output": "Gemeinsamer Ausgang",
+            "separate_output": "Separate Ausgänge"
+        }
+    }
+}

package/hysteresis/locales/en-US/hysteresis.html

@@ -0,0 +1,36 @@
+<script type="text/html" data-help-name="smart_hysteresis">
+    <p>
+        This node sends the incoming message to the output <code>Over</code> if the incoming value is greater than or equal to the setpoint plus hysteresis and
+        the incoming message to the output <code>Under</code> if the incoming value is less than or equal to the setpoint minus hysteresis.<br />
+        The message is only forwarded once when the limit is exceeded or not reached.<br />
+        The node retains the current state even after deployment.
+    </p>
+    <p>
+        <b>Note:</b> Smart nodes use topics in the format <code>name#number</code>, so that different smart nodes can be controlled with the same topic.<br />
+        This node only uses the part <code>name</code>. <code>#</code> and <code>number</code> are optional.
+    </p>
+    <p>
+        The following topics are accepted:
+        <table>
+            <thead>
+                <tr>
+                    <th>Topic</th>
+                    <th>Description</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><code>setpoint</code></td>
+                    <td>Overwrites the setpoint with <code>msg.payload</code>.</td>
+                </tr>
+                <tr>
+                    <td><code>hysteresis</code></td>
+                    <td>Overwrites the hysteresis with <code>msg.payload</code>.</td>
+                </tr>
+            </tbody>
+        </table>
+    </p>
+    <p>
+        The incoming message is supplemented with the specified outgoing messages, unless the original message was selected.
+    </p>
+</script>

package/hysteresis/locales/en-US/hysteresis.json

@@ -0,0 +1,27 @@
+{
+    "hysteresis": {
+        "ui": {
+            "name": "Name",
+            "setpoint": "Setpoint",
+            "hysteresis": "Hysteresis",
+            "output_messages": "Output messages",
+            "over": "Over",
+            "under": "Under",
+            "send": "Send",
+            "outputs": "Outputs",
+
+            "note": "Note:",
+            "note_text": "<code>msg.payload</code> is automatically set to the hysteresis result,<br/>if it has not already been set here in the configuration.<br/><code>true</code> if higher, <code>false</code> if lower",
+            "system_start": "System start",
+            "save_state": "Save state",
+            "send_after_start": "Send last message 10 seconds after start",
+
+            "send_nothing": "Send nothing",
+            "original_message": "Original message",
+            "send_only_change": "Only when changed",
+            "always": "Always",
+            "common_output": "Common output",
+            "separate_output": "Separate outputs"
+        }
+    }
+}

package/light/light.html

@@ -0,0 +1,250 @@
+<script type="text/javascript">
+    (function ()
+    {
+        let treeList;
+        let candidateNodesCount = 0;
+        let flows = [];
+        let flowMap = {};
+
+        function onEditPrepare(node, targetTypes)
+        {
+            if (!node.links)
+                node.links = [];
+
+            const activeSubflow = RED.nodes.subflow(node.z);
+
+            treeList = $("<div>")
+                .css({ width: "100%", height: "100%" })
+                .appendTo(".node-input-link-row")
+                .treeList({ autoSelect: false })
+                .on("treelistitemmouseover", function (e, item)
+                {
+                    if (item.node)
+                    {
+                        item.node.highlighted = true;
+                        item.node.dirty = true;
+                        RED.view.redraw();
+                    }
+                })
+                .on("treelistitemmouseout", function (e, item)
+                {
+                    if (item.node)
+                    {
+                        item.node.highlighted = false;
+                        item.node.dirty = true;
+                        RED.view.redraw();
+                    }
+                });
+
+            flows = [];
+            flowMap = {};
+
+            if (activeSubflow)
+            {
+                flowMap[activeSubflow.id] = {
+                    id: activeSubflow.id,
+                    class: "red-ui-palette-header",
+                    label: "Subflow : " + (activeSubflow.name || activeSubflow.id),
+                    expanded: true,
+                    children: []
+                };
+                flows.push(flowMap[activeSubflow.id]);
+            }
+            else
+            {
+                RED.nodes.eachWorkspace(function (ws)
+                {
+                    if (!ws.disabled)
+                    {
+                        flowMap[ws.id] = {
+                            id: ws.id,
+                            class: "red-ui-palette-header",
+                            label: (ws.label || ws.id) + (node.z === ws.id ? " *" : ""),
+                            expanded: true,
+                            children: []
+                        };
+                        flows.push(flowMap[ws.id]);
+                    }
+                });
+            }
+
+            setTimeout(function ()
+            {
+                treeList.treeList("show", node.z);
+            }, 100);
+        }
+
+        function initTreeList(node, targetTypes)
+        {
+            candidateNodesCount = 0;
+            for (const key in flowMap)
+            {
+                flowMap[key].children = [];
+            }
+
+            let candidateNodes = [];
+
+            targetTypes.forEach(function (targetType)
+            {
+                candidateNodes = candidateNodes.concat(RED.nodes.filterNodes({ type: targetType }));
+            });
+
+            candidateNodes.forEach(function (n)
+            {
+                if (flowMap[n.z])
+                {
+                    const isChecked = (node.links.indexOf(n.id) !== -1) || (n.links || []).indexOf(node.id) !== -1;
+                    if (isChecked)
+                    {
+                        flowMap[n.z].children.push({
+                            id: n.id,
+                            node: n,
+                            label: n.name || n.id,
+                            selected: false,
+                            checkbox: false,
+                            radio: false
+                        });
+                        candidateNodesCount++;
+                    }
+                }
+            });
+
+            for (const key in flowMap)
+            {
+                flowMap[key].children.sort((a, b) => a.label.localeCompare(b.label));
+            }
+
+            const flowsFiltered = flows.filter(function (f) { return f.children.length > 0 });
+            treeList.treeList("empty");
+            treeList.treeList("data", flowsFiltered);
+        }
+
+        function resizeNodeList()
+        {
+            var rows = $("#dialog-form>div:not(.node-input-link-row)");
+            var height = $("#dialog-form").height();
+            for (var i = 0; i < rows.length; i++)
+            {
+                height -= $(rows[i]).outerHeight(true);
+            }
+            var editorRow = $("#dialog-form>div.node-input-link-row");
+            height -= (parseInt(editorRow.css("marginTop")) + parseInt(editorRow.css("marginBottom")));
+            $(".node-input-link-row").css("height", height + "px");
+        }
+
+        RED.nodes.registerType("smart_light-control", {
+            category: "Smart Nodes",
+            paletteLabel: "Light control",
+            color: "#C882FF",
+            defaults: {
+                name: { value: "" },
+                exec_text_names: { value: "" },
+                max_time_on: { value: "0" },
+                max_time_on_unit: { value: "s" },
+                alarm_action: { value: 'NOTHING' }, // NOTHING | ON | OFF
+                alarm_off_action: { value: 'NOTHING' }, // NOTHING | ON | OFF | LAST | LAST_SENDED
+                links: { value: [], type: "smart_central-control[]" }
+            },
+            inputs: 1,
+            outputs: 1,
+            icon: "font-awesome/fa-lightbulb-o",
+            label: function ()
+            {
+                return this.name || "Light control";
+            },
+            oneditprepare: function ()
+            {
+                let node = this;
+
+                onEditPrepare(this, ["smart_central-control"]);
+                initTreeList(node, ["smart_central-control"]);
+
+                $("#node-input-max_time_on")
+                    .spinner({
+                        min: 0,
+                        change: function (event, ui)
+                        {
+                            var value = parseInt(this.value);
+                            value = isNaN(value) ? 0 : value;
+                            value = Math.max(value, parseInt($(this).attr("aria-valuemin")));
+                            // value = Math.min(value, parseInt($(this).attr("aria-valuemax")));
+                            if (value !== this.value) $(this).spinner("value", value);
+                        },
+                    }).css("max-width", "4rem");
+
+                $("#node-input-max_time_on_unit")
+                    .css("max-width", "10rem")
+                    .typedInput({
+                        types: [{
+                            value: "max_time_on_unit",
+                            default: "s",
+                            options: [
+                                { value: "ms", label: node._("light.ui.milliseconds") },
+                                { value: "s", label: node._("light.ui.seconds") },
+                                { value: "min", label: node._("light.ui.minutes") },
+                                { value: "h", label: node._("light.ui.hours") },
+                            ],
+                        }],
+                    });
+
+                $("#node-input-alarm_action").typedInput({
+                    types: [{
+                        value: "alarm_action",
+                        default: "NOTHING",
+                        options: [
+                            { value: "NOTHING", label: node._("light.ui.no_action") },
+                            { value: "ON", label: node._("light.ui.turn_on") },
+                            { value: "OFF", label: node._("light.ui.turn_off") }
+                        ],
+                    }],
+                });
+
+                $("#node-input-alarm_off_action").typedInput({
+                    types: [{
+                        value: "alarm_off_action",
+                        default: "NOTHING",
+                        options: [
+                            { value: "NOTHING", label: node._("light.ui.no_action") },
+                            { value: "ON", label: node._("light.ui.turn_on") },
+                            { value: "OFF", label: node._("light.ui.turn_off") },
+                            { value: "LAST", label: node._("light.ui.last_state") },
+                            { value: "LAST_SENDED", label: node._("light.ui.last_sended_state") }
+                        ],
+                    }],
+                });
+            },
+            onadd: function ()
+            {
+                this.links = [];
+            },
+            oneditresize: resizeNodeList
+        });
+    })();
+</script>
+
+<script type="text/html" data-template-name="smart_light-control">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="light.ui.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]light.ui.name" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-exec_text_names"><i class="fa fa-comments-o"></i> <span data-i18n="light.ui.text"></span></label>
+        <input id="node-input-exec_text_names" type="text" />
+        <div style="max-width: 450px;" data-i18n="light.ui.controlled_by_words"></div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-max_time_on"><i class="fa fa-clock-o"></i> <span data-i18n="light.ui.time_on"></span></label>
+        <input id="node-input-max_time_on" value="0" />
+        <input id="node-input-max_time_on_unit" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-alarm_action"><i class="fa fa-exclamation-triangle"></i> <span data-i18n="light.ui.alarm_on"></span></label>
+        <input id="node-input-alarm_action"/>
+    </div>
+    <div class="form-row">
+        <label for="node-input-alarm_off_action"><i class="fa fa-exclamation-triangle"></i> <span data-i18n="light.ui.alarm_off"></span></label>
+        <input id="node-input-alarm_off_action"/>
+    </div>
+    <span><i class="fa fa-link"></i> <span data-i18n="light.ui.controlled_by_central"></span></span>
+    <div class="form-row node-input-link-row node-input-link-rows"></div>
+</script>