node-red-contrib-event-calc 0.1.2 → 2.0.1

package/nodes/event-calc.html

@@ -13,10 +13,12 @@
             inputMappings: { value: [] },
             expression: { value: "" },
             triggerOn: { value: "any" },
-            outputTopic: { value: "calc/result" }
+            outputTopic: { value: "calc/result" },
+            externalTrigger: { value: false }
         },
         inputs: 1,
-        outputs: 1,
+        outputs: 2,
+        outputLabels: ["result", "error"],
         icon: "font-awesome/fa-calculator",
         label: function() {
             return this.name || this.expression || "event calc";
@@ -34,7 +36,7 @@
                     $.getJSON("event-cache/" + cacheId + "/topics", function(topics) {
                         cachedTopics = topics || [];
                         // Update existing autocomplete instances
-                        $(".input-pattern").each(function() {
+                        $(".input-topic").each(function() {
                             $(this).autocomplete("option", "source", cachedTopics);
                         });
                     });
@@ -92,17 +94,17 @@
 
                     $('<span/>', { style: "flex: 0 0 auto;" }).text(" = ").appendTo(row);
 
-                    const patternInput = $('<input/>', {
+                    const topicInput = $('<input/>', {
                         type: "text",
                         placeholder: "topic (type to search cached topics)",
-                        class: "input-pattern"
+                        class: "input-topic"
                     })
                     .css({ flex: "1 1 auto" })
-                    .val(data.pattern || "")
+                    .val(data.topic || data.pattern || "")
                     .appendTo(row);
 
-                    // Add autocomplete to pattern input
-                    patternInput.autocomplete({
+                    // Add autocomplete to topic input
+                    topicInput.autocomplete({
                         source: cachedTopics,
                         minLength: 0,
                         delay: 0
@@ -135,9 +137,9 @@
 
             $("#node-input-inputMappings-list").editableList('items').each(function() {
                 const name = $(this).find(".input-name").val().trim();
-                const pattern = $(this).find(".input-pattern").val().trim();
-                if (name && pattern) {
-                    node.inputMappings.push({ name: name, pattern: pattern });
+                const topic = $(this).find(".input-topic").val().trim();
+                if (name && topic) {
+                    node.inputMappings.push({ name: name, topic: topic });
                 }
             });
         }
@@ -157,7 +159,7 @@
         <label style="width:100%;"><i class="fa fa-sign-in"></i> Input Variables</label>
         <ol id="node-input-inputMappings-list"></ol>
         <div class="form-tips">
-            Map variable names to topic patterns. Wildcards: <code>?</code> = one char, <code>*</code> = one or more chars
+            Map variable names to topics.
         </div>
     </div>
     <div class="form-row">
@@ -212,6 +214,11 @@
         <label for="node-input-outputTopic"><i class="fa fa-bookmark"></i> Output Topic</label>
         <input type="text" id="node-input-outputTopic" placeholder="calc/result">
     </div>
+    <div class="form-row">
+        <label>&nbsp;</label>
+        <input type="checkbox" id="node-input-externalTrigger" style="width:auto; margin-right:5px;">
+        <label for="node-input-externalTrigger" style="width:auto;"> External Trigger - calculate on any input message</label>
+    </div>
 </script>
 
 <script type="text/html" data-help-name="event-calc">
@@ -220,7 +227,7 @@
     <h3>Properties</h3>
     <dl class="message-properties">
         <dt>Input Variables</dt>
-        <dd>Map variable names to topic patterns. Each variable receives the latest value from matching topics.</dd>
+        <dd>Map variable names to topics.</dd>
         <dt>Expression</dt>
         <dd>JavaScript expression using the variable names, e.g. <code>a + b</code>, <code>Math.max(a, b)</code>, <code>(a - b) / a * 100</code></dd>
         <dt>Trigger</dt>
@@ -231,7 +238,9 @@
             </ul>
         </dd>
         <dt>Output Topic</dt>
-        <dd>Topic to set on output messages</dd>
+        <dd>Topic for output messages.</dd>
+        <dt>External Trigger</dt>
+        <dd>When enabled, any incoming message will trigger a calculation using the current cached values. Useful for time-based or event-driven calculations.</dd>
     </dl>
 
     <h3>Inputs</h3>
@@ -243,19 +252,40 @@
     </dl>
 
     <h3>Outputs</h3>
+    <p>The node has two outputs:</p>
+    <ol>
+        <li><b>Result</b> - Successful calculation results</li>
+        <li><b>Error</b> - Errors (NaN results, evaluation failures)</li>
+    </ol>
+
+    <h4>Output 1 (Result)</h4>
     <dl class="message-properties">
         <dt>payload <span class="property-type">any</span></dt>
         <dd>The result of the expression</dd>
         <dt>topic <span class="property-type">string</span></dt>
-        <dd>The configured output topic</dd>
+        <dd>The output topic</dd>
+        <dt>topics <span class="property-type">object</span></dt>
+        <dd>Mapping of variable names to topics</dd>
+        <dt>timestamps <span class="property-type">object</span></dt>
+        <dd>Mapping of variable names to their cached timestamps</dd>
         <dt>inputs <span class="property-type">object</span></dt>
-        <dd>Details of all input values used in the calculation</dd>
+        <dd>Full details of all input values</dd>
         <dt>expression <span class="property-type">string</span></dt>
         <dd>The expression that was evaluated</dd>
         <dt>trigger <span class="property-type">string</span></dt>
         <dd>The topic that triggered this calculation</dd>
     </dl>
 
+    <h4>Output 2 (Error)</h4>
+    <dl class="message-properties">
+        <dt>payload.error <span class="property-type">string</span></dt>
+        <dd>Error message (e.g., "Expression resulted in NaN")</dd>
+        <dt>payload.missingInputs <span class="property-type">array</span></dt>
+        <dd>List of input variables that were undefined</dd>
+        <dt>payload.expression <span class="property-type">string</span></dt>
+        <dd>The expression that failed</dd>
+    </dl>
+
     <h3>Built-in Functions</h3>
     <p>The following functions are available in expressions:</p>
 
@@ -304,10 +334,4 @@
         <li><code>ifelse(a > b, 'high', 'low')</code> - Conditional</li>
         <li><code>pctChange(a, b)</code> - Percent change from b to a</li>
     </ul>
-
-    <h3>Wildcard Examples</h3>
-    <ul>
-        <li><code>sensor?</code> - matches sensor1, sensorA (exactly one char)</li>
-        <li><code>sensors/*</code> - matches sensors/temp, sensors/room1/temp</li>
-    </ul>
 </script>

package/nodes/event-calc.js

@@ -2,7 +2,7 @@
  * event-calc - Calculation node for multi-topic expressions
  *
  * Features:
- * - Maps multiple variables to topic patterns
+ * - Maps variables to exact topics
  * - Evaluates JavaScript expressions when inputs update
  * - Trigger modes: 'any' (any input updates) or 'all' (all inputs have values)
  * - Safe expression evaluation using Function constructor
@@ -10,6 +10,7 @@
  * - Built-in helper functions for common operations
  */
 module.exports = function(RED) {
+
     // Helper functions available in expressions
     const helpers = {
         // Math shortcuts
@@ -65,9 +66,9 @@ module.exports = function(RED) {
         node.expression = config.expression || '';
         node.triggerOn = config.triggerOn || 'any';
         node.outputTopic = config.outputTopic || 'calc/result';
+        node.externalTrigger = config.externalTrigger || false;
 
         const subscriptionIds = [];
-        const latestValues = new Map(); // name -> { topic, value, ts }
 
         if (!node.cacheConfig) {
             node.status({ fill: "red", shape: "ring", text: "no cache configured" });
@@ -84,32 +85,43 @@ module.exports = function(RED) {
             return;
         }
 
+        // Track subscribed topics to ignore updates from our own output
+        const subscribedTopics = new Set();
+        for (const input of node.inputMappings) {
+            const topicName = input.topic || input.pattern;
+            if (topicName) {
+                subscribedTopics.add(topicName);
+            }
+        }
+
         /**
          * Attempt to calculate and output result
          */
-        function tryCalculate(triggerTopic) {
-            // Check if we should trigger
+        function tryCalculate(triggerTopic, latestValues) {
+            // Ignore updates triggered by our own output
+            if (triggerTopic === node.outputTopic) {
+                return;
+            }
+
             if (node.triggerOn === 'all') {
-                // All inputs must have values
                 for (const input of node.inputMappings) {
                     if (!latestValues.has(input.name)) {
-                        return; // Not all values available yet
+                        return;
                     }
                 }
             }
 
-            // At least one value must exist to calculate
             if (latestValues.size === 0) {
                 return;
             }
 
-            // Build context object for expression evaluation
             const context = {};
             const inputDetails = {};
+            const missingInputs = [];
 
             for (const input of node.inputMappings) {
                 const data = latestValues.get(input.name);
-                if (data) {
+                if (data && data.value !== undefined && data.value !== null) {
                     context[input.name] = data.value;
                     inputDetails[input.name] = {
                         topic: data.topic,
@@ -118,63 +130,98 @@ module.exports = function(RED) {
                     };
                 } else {
                     context[input.name] = undefined;
+                    missingInputs.push(input.name);
                 }
             }
 
-            // Evaluate expression safely
+            // Build topics mapping: variable name -> topic
+            const topics = { _output: node.outputTopic };
+            const timestamps = {};
+            for (const [name, details] of Object.entries(inputDetails)) {
+                topics[name] = details.topic;
+                timestamps[name] = details.ts;
+            }
+
             try {
-                // Create a function with named parameters from context + helpers
                 const allParams = { ...helpers, ...context };
                 const paramNames = Object.keys(allParams);
                 const paramValues = Object.values(allParams);
 
-                // Build function body with helpers and variables available
                 const fn = new Function(...paramNames, `return ${node.expression};`);
                 const result = fn(...paramValues);
 
+                // Check for NaN or invalid result
+                if (typeof result === 'number' && isNaN(result)) {
+                    const errorMsg = {
+                        topic: node.outputTopic,
+                        payload: {
+                            error: 'Expression resulted in NaN',
+                            missingInputs: missingInputs,
+                            expression: node.expression
+                        },
+                        inputs: inputDetails,
+                        trigger: triggerTopic,
+                        timestamp: Date.now()
+                    };
+                    node.send([null, errorMsg]);
+                    node.status({ fill: "yellow", shape: "ring", text: "NaN" });
+                    return;
+                }
+
                 const msg = {
                     topic: node.outputTopic,
                     payload: result,
+                    topics: topics,
                     inputs: inputDetails,
+                    timestamps: timestamps,
                     expression: node.expression,
                     trigger: triggerTopic,
                     timestamp: Date.now()
                 };
 
-                node.send(msg);
+                node.send([msg, null]);
 
-                // Store result back in cache so it can be used by other calculations
                 node.cacheConfig.setValue(node.outputTopic, result, {
                     source: 'event-calc',
                     expression: node.expression,
                     inputs: Object.keys(inputDetails)
                 });
 
-                // Update status with result (truncate if too long)
                 const resultStr = String(result);
                 const displayResult = resultStr.length > 15 ? resultStr.substring(0, 12) + '...' : resultStr;
                 node.status({ fill: "green", shape: "dot", text: `= ${displayResult}` });
 
             } catch (err) {
+                const errorMsg = {
+                    topic: node.outputTopic,
+                    payload: {
+                        error: err.message,
+                        expression: node.expression,
+                        context: context
+                    },
+                    inputs: inputDetails,
+                    trigger: triggerTopic,
+                    timestamp: Date.now()
+                };
+                node.send([null, errorMsg]);
                 node.status({ fill: "red", shape: "ring", text: "eval error" });
-                node.error(`Expression evaluation failed: ${err.message}`, { expression: node.expression, context: context });
             }
         }
 
-        // Subscribe to each input pattern
+        // Subscribe to inputs
+        const latestValues = new Map();
+
         for (const input of node.inputMappings) {
-            if (!input.name || !input.pattern) {
-                continue;
-            }
+            const topicName = input.topic || input.pattern;
+            if (!input.name || !topicName) continue;
 
-            const subId = node.cacheConfig.subscribe(input.pattern, (topic, entry) => {
+            const subId = node.cacheConfig.subscribe(topicName, (topic, entry) => {
                 latestValues.set(input.name, {
                     topic: topic,
                     value: entry.value,
                     ts: entry.ts
                 });
-
-                tryCalculate(topic);
+                tryCalculate(topic, latestValues);
             });
             subscriptionIds.push(subId);
         }
@@ -193,9 +240,19 @@ module.exports = function(RED) {
                 node.status({ fill: "blue", shape: "dot", text: "expr updated" });
             }
 
-            // Force recalculation
+            // External trigger: any incoming message triggers calculation
+            if (node.externalTrigger) {
+                const triggerSource = msg.topic || '_external';
+                tryCalculate(triggerSource, latestValues);
+                done();
+                return;
+            }
+
+            // Force recalculation (use special topic to bypass self-output check)
             if (msg.payload === 'recalc' || msg.topic === 'recalc') {
-                tryCalculate('manual');
+                if (latestValues.size > 0) {
+                    tryCalculate('_recalc', latestValues);
+                }
             }
 
             done();
@@ -208,7 +265,6 @@ module.exports = function(RED) {
                 }
             }
             subscriptionIds.length = 0;
-            latestValues.clear();
             done();
         });
     }

package/nodes/event-chart.html

@@ -0,0 +1,239 @@
+<style>
+    .event-calc-white-text { fill: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="event-chart"] .red-ui-palette-label { color: #ffffff !important; }
+</style>
+
+<script type="text/javascript">
+    RED.nodes.registerType('event-chart', {
+        category: 'event calc',
+        color: '#758467',
+        defaults: {
+            name: { value: "" },
+            title: { value: "Event Chart" },
+            maxPoints: { value: 200, validate: RED.validators.number() },
+            timestampField: { value: "timestamp" },
+            valueField: { value: "payload" },
+            seriesField: { value: "topic" }
+        },
+        inputs: 1,
+        outputs: 0,
+        icon: "font-awesome/fa-line-chart",
+        paletteLabel: "chart",
+        label: function() {
+            return this.name || this.title || "Event Chart";
+        },
+        labelStyle: function() {
+            return (this.name ? "node_label_italic" : "") + " event-calc-white-text";
+        },
+        oneditprepare: function() {
+            var node = this;
+            var chartInstance = null;
+            var container = document.getElementById('event-chart-preview-container');
+
+            // Create canvas
+            var canvas = document.createElement('canvas');
+            canvas.id = 'event-chart-canvas-' + node.id;
+            canvas.style.width = '100%';
+            canvas.style.height = '100%';
+            container.innerHTML = '';
+            container.appendChild(canvas);
+
+            // Clear button
+            $('#event-chart-clear-btn').on('click', function() {
+                $.post('event-chart/' + node.id + '/clear', function(data) {
+                    if (chartInstance) {
+                        chartInstance.data.datasets = [];
+                        chartInstance.update('none');
+                    }
+                }).fail(function() {
+                    RED.notify("Failed to clear chart", "error");
+                });
+            });
+
+            function loadScript(src) {
+                return new Promise(function(resolve, reject) {
+                    if (document.querySelector('script[src="' + src + '"]')) {
+                        resolve();
+                        return;
+                    }
+                    var script = document.createElement('script');
+                    script.src = src;
+                    script.onload = resolve;
+                    script.onerror = reject;
+                    document.head.appendChild(script);
+                });
+            }
+
+            function initChart() {
+                if (chartInstance) {
+                    chartInstance.destroy();
+                }
+
+                var ctx = document.getElementById('event-chart-canvas-' + node.id);
+                if (!ctx) return;
+
+                chartInstance = new Chart(ctx, {
+                    type: 'line',
+                    data: { datasets: [] },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: false,
+                        animation: false,
+                        scales: {
+                            x: {
+                                type: 'linear',
+                                title: { display: true, text: 'Time' },
+                                ticks: {
+                                    callback: function(value) {
+                                        return new Date(value).toLocaleTimeString();
+                                    }
+                                }
+                            },
+                            y: { title: { display: true, text: 'Value' } }
+                        },
+                        plugins: {
+                            legend: { position: 'top' },
+                            title: { display: true, text: node.title || 'Event Chart' }
+                        }
+                    }
+                });
+
+                // Subscribe to chart data updates
+                RED.comms.subscribe("event-chart-data-" + node.id, function(topic, msg) {
+                    if (chartInstance && msg && msg.data) {
+                        updateChart(msg.data);
+                    }
+                });
+
+                // Load initial data
+                $.getJSON('event-chart/' + node.id + '/data', function(data) {
+                    if (data && data.data) {
+                        updateChart(data.data);
+                    }
+                });
+            }
+
+            function updateChart(data) {
+                if (!chartInstance) return;
+
+                var colors = [
+                    '#2196F3', '#FF5722', '#4CAF50', '#9C27B0',
+                    '#FF9800', '#00BCD4', '#E91E63', '#8BC34A',
+                    '#3F51B5', '#CDDC39', '#009688', '#FFC107'
+                ];
+                var datasets = [];
+                var i = 0;
+                for (var series in data) {
+                    datasets.push({
+                        label: series,
+                        data: data[series],
+                        borderColor: colors[i % colors.length],
+                        backgroundColor: colors[i % colors.length] + '20',
+                        pointRadius: 2,
+                        borderWidth: 2,
+                        tension: 0.1,
+                        fill: false
+                    });
+                    i++;
+                }
+                chartInstance.data.datasets = datasets;
+                chartInstance.update('none');
+            }
+
+            // Load Chart.js
+            if (typeof Chart === 'undefined') {
+                loadScript('https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js')
+                    .then(function() {
+                        setTimeout(initChart, 100);
+                    })
+                    .catch(function(err) {
+                        container.innerHTML = '<p style="color:red">Failed to load Chart.js</p>';
+                    });
+            } else {
+                initChart();
+            }
+        },
+        oneditcancel: function() {
+            RED.comms.unsubscribe("event-chart-data-" + this.id);
+        },
+        oneditsave: function() {
+            RED.comms.unsubscribe("event-chart-data-" + this.id);
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="event-chart">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-title"><i class="fa fa-header"></i> Title</label>
+        <input type="text" id="node-input-title" placeholder="Event Chart">
+    </div>
+    <div class="form-row">
+        <label for="node-input-valueField"><i class="fa fa-line-chart"></i> Value Field</label>
+        <input type="text" id="node-input-valueField" placeholder="payload">
+    </div>
+    <div class="form-row">
+        <label for="node-input-timestampField"><i class="fa fa-clock-o"></i> Timestamp Field</label>
+        <input type="text" id="node-input-timestampField" placeholder="timestamp">
+    </div>
+    <div class="form-row">
+        <label for="node-input-seriesField"><i class="fa fa-tags"></i> Series Field</label>
+        <input type="text" id="node-input-seriesField" placeholder="topic">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxPoints"><i class="fa fa-database"></i> Max Points</label>
+        <input type="number" id="node-input-maxPoints" placeholder="200">
+    </div>
+    <div class="form-row">
+        <label><i class="fa fa-area-chart"></i> Preview</label>
+        <div id="event-chart-preview-container" style="height: 250px; border: 1px solid #ccc; border-radius: 4px; padding: 5px; background: #fafafa;">
+            <p style="color:#888; text-align:center; padding-top:100px;">Loading chart...</p>
+        </div>
+    </div>
+    <div class="form-row">
+        <button type="button" id="event-chart-clear-btn" class="red-ui-button" style="width: 100%;">
+            <i class="fa fa-trash"></i> Clear Chart Data
+        </button>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-chart">
+    <p>Displays time-series data on an interactive chart.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">number</span></dt>
+        <dd>The value to plot (configurable field name)</dd>
+        <dt class="optional">timestamp <span class="property-type">number</span></dt>
+        <dd>Unix timestamp in ms (defaults to current time)</dd>
+        <dt class="optional">topic <span class="property-type">string</span></dt>
+        <dd>Series name for grouping data (default: "default")</dd>
+    </dl>
+
+    <h3>Properties</h3>
+    <ul>
+        <li><b>Title</b> - Chart title displayed at top</li>
+        <li><b>Value Field</b> - Message property for value (default: payload)</li>
+        <li><b>Timestamp Field</b> - Message property for timestamp</li>
+        <li><b>Series Field</b> - Message property for series name</li>
+        <li><b>Max Points</b> - Maximum points per series (older points removed)</li>
+    </ul>
+
+    <h3>Usage</h3>
+    <p>Connect to any node that outputs numeric data. The chart will automatically:</p>
+    <ul>
+        <li>Group data by series (topic)</li>
+        <li>Display multiple series with different colors</li>
+        <li>Show real-time updates as data arrives</li>
+        <li>Limit data points to prevent memory issues</li>
+    </ul>
+
+    <h3>Clear Data</h3>
+    <p>Use the "Clear Chart Data" button, or send <code>msg.payload = "_clear"</code>.</p>
+
+    <h3>Preview</h3>
+    <p>Double-click the node to see a live preview of the chart with current data.</p>
+</script>