@bldgblocks/node-red-contrib-control 0.1.32 → 0.1.33

package/nodes/global-setter.js

@@ -12,6 +12,7 @@ module.exports = function(RED) {
         node.inputProperty = config.property;        
         node.defaultValue = config.defaultValue;
         node.writePriority = config.writePriority;
+        node.type = config.defaultValueType;
         
         // Cast default value logic
         if(!isNaN(node.defaultValue) && node.defaultValue !== "") node.defaultValue = Number(node.defaultValue);
@@ -22,16 +23,71 @@ module.exports = function(RED) {
         function calculateWinner(state) {
             for (let i = 1; i <= 16; i++) {
                 if (state.priority[i] !== undefined && state.priority[i] !== null) {
-                    return state.priority[i];
+                    return { value: state.priority[i], priority: `${i}` };
                 }
             }
-            return state.defaultValue;
+            return { value: state.defaultValue, priority: "default" };
+        }
+
+        function getState() {
+            if (!node.varName) {
+                node.status({ fill: "red", shape: "ring", text: "no variable defined" });
+                return null;
+            }
+
+            let state = node.context().global.get(node.varName, node.storeName);
+            if (!state || typeof state !== 'object' || !state.priority) {
+                state = {
+                    payload: node.defaultValue,
+                    value: node.defaultValue,
+                    defaultValue: node.defaultValue,
+                    activePriority: "default",
+                    units: null,
+                    priority: {
+                        1: null,
+                        2: null,
+                        3: null,
+                        4: null,
+                        5: null,
+                        6: null,
+                        7: null,
+                        8: null,
+                        9: null,
+                        10: null,
+                        11: null,
+                        12: null,
+                        13: null,
+                        14: null,
+                        15: null,
+                        16: null,
+                    },
+                    metadata: {
+                        sourceId: node.id,
+                        lastSet: new Date().toISOString(),
+                        name: node.name || config.path,
+                        path: node.varName,
+                        store: node.storeName || 'default',
+                        type: typeof(node.defaultValue)
+                    }
+                };
+                return { state: state, existing: false };
+            }
+            return { state: state, existing: true };
         }
 
         node.isBusy = false;
 
+        const st = getState();
+        if (st !== null && st.existing === false) {
+            // Initialize global variable
+            node.context().global.set(node.varName, st.state, node.storeName);
+            node.status({ fill: "grey", shape: "dot", text: `initialized: default:${node.defaultValue}` });
+        }
+
         node.on('input', async function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
+            let prefix = '';
+            let valPretty = '';
 
             // Guard against invalid msg
             if (!msg) {
@@ -76,98 +132,117 @@ module.exports = function(RED) {
                 node.isBusy = false;
             }
 
-            if (node.varName) {
-                const inputValue = RED.util.getMessageProperty(msg, node.inputProperty);
-                const globalContext = node.context().global;
-
-                // Get existing state or initialize new
-                let state = globalContext.get(node.varName, node.storeName);
-                if (!state || typeof state !== 'object' || !state.priority) {
-                    state = {
-                        value: null,
-                        defaultValue: node.defaultValue,
-                        priority: {
-                            1: null,
-                            2: null,
-                            3: null,
-                            4: null,
-                            5: null,
-                            6: null,
-                            7: null,
-                            8: null,
-                            9: null,
-                            10: null,
-                            11: null,
-                            12: null,
-                            13: null,
-                            14: null,
-                            15: null,
-                            16: null,
-                        },
-                        metadata: {}
-                    };
+            // Get existing state or initialize new
+            let state = {};
+            state = getState().state;
+
+            if (msg.hasOwnProperty("context") && typeof msg.context === "string") {
+                if (msg.context === "reload") {
+                    // Fire Event
+                    RED.events.emit("bldgblocks-global-update", {
+                        key: node.varName,
+                        store: node.storeName,
+                        data: state
+                    });
+                    
+                    // Send flow
+                    node.context().global.set(node.varName, state, node.storeName);
+                    prefix = state.activePriority === 'default' ? '' : 'P';
+                    node.status({ fill: "green", shape: "dot", text: `reload: ${prefix}${state.activePriority}:${state.value}${state.units}` });
+                    node.send({ ...state });
+                    if (done) done();
+                    return;
                 }
+            }
 
-                // Update Default, can not be set null
-                if (node.writePriority === 'default') {
-                    state.defaultValue = inputValue !== null ? inputValue : node.defaultValue;
-                } else {
-                    const priority = parseInt(node.writePriority, 10);
-                    if (isNaN(priority) || priority < 1 || priority > 16) {
-                        node.status({ fill: "red", shape: "ring", text: `Invalid priority: ${node.writePriority}` });
-                        if (done) done();
-                        return;
-                    }
-                    
-                    if (inputValue !== undefined) {
-                        state.priority[node.writePriority] = inputValue;
-                    }
+            const inputValue = RED.util.getMessageProperty(msg, node.inputProperty);
+            try {
+                if (inputValue === undefined) {
+                    node.status({ fill: "red", shape: "ring", text: `msg.${node.inputProperty} not found` });
+                    if (done) done();
+                    return;
+                }
+            } catch (error) {
+                node.status({ fill: "red", shape: "ring", text: `Error accessing msg.${node.inputProperty}` });
+                if (done) done();
+                return;
+            }
+
+
+            // Update Default, can not be set null
+            if (node.writePriority === 'default') {
+                state.defaultValue = inputValue === null || inputValue === "null" ? node.defaultValue : inputValue;
+            } else {
+                const priority = parseInt(node.writePriority, 10);
+                if (isNaN(priority) || priority < 1 || priority > 16) {
+                    node.status({ fill: "red", shape: "ring", text: `Invalid priority: ${node.writePriority}` });
+                    if (done) done();
+                    return;
                 }
                 
-                // Ensure defaultValue always has a value
-                if (state.defaultValue === null || state.defaultValue === undefined) {
-                    state.defaultValue = node.defaultValue;
+                if (inputValue !== undefined) {
+                    state.priority[node.writePriority] = inputValue;
                 }
+            }
+            
+            // Ensure defaultValue always has a value
+            if (state.defaultValue === null || state.defaultValue === "null" || state.defaultValue === undefined) {
+                state.defaultValue = node.defaultValue;
+            }
 
-                // Calculate Winner
-                state.value = calculateWinner(state);
+            // Calculate Winner
+            const { value, priority } = calculateWinner(state);
+            if (value === state.value && priority === state.activePriority) {
+                // No change, exit early
+                prefix = `${node.writePriority === 'default' ? '' : 'P'}`;
+                node.status({ fill: "green", shape: "dot", text: `no change: ${prefix}${node.writePriority}:${state.value}${state.units}` });
+                if (done) done();
+                return;
+            }
+            state.payload = value;
+            state.value = value;
+            state.activePriority = priority;
+
+            // Update Metadata
+            state.metadata.sourceId = node.id;
+            state.metadata.lastSet = new Date().toISOString();
+            state.metadata.name = node.name || config.path;
+            state.metadata.path = node.varName; 
+            state.metadata.store = node.storeName || 'default';
+            state.metadata.type = typeof(value) || node.type;
+
+            // Units logic
+            let capturedUnits = null;
+            if (msg.units !== undefined) {
+                capturedUnits = msg.units;
+            } else if (inputValue !== null && typeof inputValue === 'object' && inputValue.units) {
+                capturedUnits = inputValue.units;
+            }
 
-                // Update Metadata
-                state.metadata.sourceId = node.id;
-                state.metadata.lastSet = new Date().toISOString();
-                state.metadata.sourceName = node.name || config.path;
-                state.metadata.sourcePath = node.varName; 
-                state.metadata.store = node.storeName; 
+            state.units = capturedUnits;
 
-                // Units logic
-                let capturedUnits = msg.units; 
-                if (!capturedUnits && typeof inputValue === 'object' && inputValue !== null && inputValue.units) {
-                     capturedUnits = inputValue.units;
-                }
-                if(capturedUnits) state.units = capturedUnits;
+            // Save & Emit
+            node.context().global.set(node.varName, state, node.storeName);
+            prefix = `${node.writePriority === 'default' ? '' : 'P'}`;
+            const statePrefix = `${state.activePriority === 'default' ? '' : 'P'}`;
+            node.status({ fill: "blue", shape: "dot", text: `write: ${prefix}${node.writePriority}:${inputValue}${state.units} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units}` });
 
-                // Save & Emit
-                globalContext.set(node.varName, state, node.storeName);
-                
-                node.status({ fill: "blue", shape: "dot", text: `P${node.writePriority}:${inputValue} > Val:${state.value}` });
-
-                // Fire Event
-                RED.events.emit("bldgblocks-global-update", {
-                    key: node.varName,
-                    store: node.storeName,
-                    data: state
-                });
-            }
+            // Fire Event
+            RED.events.emit("bldgblocks-global-update", {
+                key: node.varName,
+                store: node.storeName,
+                data: state
+            });
             
-            node.send(msg);
+            // Send copy
+            node.send({ ...state });
             if (done) done();
         });
 
         node.on('close', function(removed, done) {
             if (removed && node.varName) {
-                //RED.events.removeAllListeners("bldgblocks-global-update");
-                const globalContext = node.context().global;
-                globalContext.set(node.varName, undefined, node.storeName); 
+                RED.events.removeAllListeners("bldgblocks-global-update");
+                node.context().global.set(node.varName, undefined, node.storeName); 
             }
             done();
         });

package/nodes/history-collector.html

@@ -0,0 +1,283 @@
+<script type="text/html" data-template-name="history-collector">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-historyConfig" title="Select the history configuration node"><i class="fa fa-book"></i> History Config</label>
+        <input type="text" id="node-input-historyConfig">
+    </div>
+    <div class="form-row">
+        <label for="node-input-seriesName" title="Specify the measurement series name"><i class="fa fa-list"></i> Series</label>
+        <input type="text" id="node-input-seriesName">
+    </div>
+    <div class="form-row">
+        <label for="node-input-tags"><i class="fa fa-tags"></i> Tags</label>
+        <input type="hidden" id="node-input-tags">
+        
+        <!-- Visible Container for Checkboxes -->
+        <div id="node-input-tag-container-div" style="display: inline-block; width: 70%; border: 1px solid #ccc; border-radius: 4px; box-sizing: border-box;">
+            <!-- Header for 'Select All' or filtering could go here -->
+            <div id="node-input-tag-container" style="height: 150px; overflow-y: scroll; padding: 5px; background: #00000000;">
+                <div style="color: #00000000; padding: 5px;">Select a History Config...</div>
+            </div>
+        </div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-storageType" title="Choose the storage output format"><i class="fa fa-database"></i> Storage Type</label>
+        <select id="node-input-storageType">
+            <option value="memory">Memory (Flow Context)</option>
+            <option value="lineProtocol">Line Protocol</option>
+            <option value="object">Object</option>
+            <option value="objectArray">ObjectArray (InfluxDB v2)</option>
+            <option value="batchObject">BatchObject (InfluxDB v2 Batch)</option>
+        </select>
+    </div>
+
+    <div class="form-row node-changed-values" style="display: none;" id="node-changed-values">
+        <label><i class="fa fa-info-circle"></i> Changed Values</label>
+        <div style="margin-left: 10px;">
+            <p>Tags: <span id="node-changed-tags"></span></p>
+        </div>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('history-collector', {
+        category: 'bldgblocks history',
+        color: '#b9f2ff',
+        defaults: {
+            historyConfig: { value: "", type: "history-config", required: true },
+            seriesName: { value: "", required: true },
+            tags: { value: "" },
+            storageType: { value: "batchObject" },
+            name: { value: "" }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "file.png",
+        paletteLabel: "history collector",
+        label: function() {
+            return this.name || this.seriesName || "history collector";
+        },
+        oneditprepare: function() {
+            const node = this;
+            const seriesInput = $("#node-input-seriesName");
+            const storageType = $("#node-input-storageType");
+            const tagContainer = $("#node-input-tag-container");
+            const hiddenTagInput = $("#node-input-tags");
+
+            // Initialize empty typedInputs first
+            seriesInput.typedInput({
+                types: [{ value: "series", options: [] }]
+            });
+
+            function updateConfigOptions(configId) {
+                const configNode = RED.nodes.node(configId);
+                
+                // 1. Update Series Dropdown
+                const seriesOptions = configNode && configNode.series ?
+                    configNode.series.map(s => ({ value: s.seriesName, label: s.seriesName })) :
+                    [];
+                
+                seriesInput.typedInput('types', [{
+                    value: "series",
+                    options: seriesOptions
+                }]);
+                
+                if (node.seriesName && seriesOptions.find(o => o.value === node.seriesName)) {
+                    seriesInput.typedInput('value', node.seriesName);
+                } else {
+                    seriesInput.typedInput('value', '');
+                }
+
+                // 2. Update Tags Multi-Select List
+                tagContainer.empty();
+                
+                if (!configNode || !configNode.tags || configNode.tags.length === 0) {
+                    tagContainer.append('<div style="color: #999; padding: 5px;">No tags defined in config</div>');
+                    return;
+                }
+
+                // Parse currently selected tags (CSV string -> Array)
+                const currentTags = (hiddenTagInput.val() || "").split(',').map(t => t.trim()).filter(t => t);
+                const currentTagSet = new Set(currentTags);
+
+                for (let i = 0; i < configNode.tags.length; i++) {
+                    const t = configNode.tags[i];
+                    
+                    const tagKey = "tag" + i;
+                    const tagString = tagKey + (t.tagValue ? '=' + t.tagValue : '');
+                    
+                    const isChecked = currentTagSet.has(tagString);
+
+                    const row = $('<div style="padding: 2px 0;"></div>').appendTo(tagContainer);
+                    const label = $('<label style="width: 100%; display: flex; align-items: center; margin: 0; cursor: pointer;"></label>').appendTo(row);
+                    
+                    const checkbox = $('<input type="checkbox" style="width: auto; margin: 0 6px 0 0; vertical-align: middle;">')
+                        .attr('value', tagString)
+                        .prop('checked', isChecked)
+                        .on('change', function() {
+                            updateHiddenTagInput();
+                        })
+                        .appendTo(label);
+                    
+                    $('<span>').text(tagString).appendTo(label);
+                }
+            }
+
+            // Function to gather checked boxes and update hidden input
+            function updateHiddenTagInput() {
+                const selected = [];
+                tagContainer.find('input[type="checkbox"]:checked').each(function() {
+                    selected.push($(this).val());
+                });
+                hiddenTagInput.val(selected.join(','));
+            }
+
+            $("#node-input-historyConfig").on("change", function() {
+                updateConfigOptions($(this).val());
+            });
+
+            if (node.historyConfig) {
+                updateConfigOptions(node.historyConfig);
+            }
+
+            storageType.val(node.storageType || 'memory');
+        },
+        oneditsave: function() {
+            const seriesInput = $("#node-input-seriesName");
+            this.seriesName = seriesInput.typedInput('value');
+            this.storageType = $("#node-input-storageType").val();
+            // tags are already in the hidden input thanks to the checkbox change handler
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="history-collector">
+Receives data points to be tagged and bundled for storage in various formats, preparing them for a history collector or custom storage solution.
+
+### Inputs
+- payload (any): The data point to store (number, boolean, or string). Numbers are validated to exclude `NaN`, strings ending in `i` are parsed as integers (e.g., `123i` → `123`), and invalid values are rejected with a warning.
+
+### Outputs
+- payload (string | object | array): The formatted data package, depending on the selected `storageType`. See **Data Package Formats** for details.
+- measurement (string): The measurement name (e.g., `Return_Temp`), set for `lineProtocol`, `object`, and `objectArray` formats.
+- timestamp (number): Nanosecond timestamp, set for `objectArray` format.
+
+### Details
+The `history-collector` node is the entry point for collecting and formatting time-series data before storage. It validates the input payload, applies tags, and formats the output based on the configured `storageType`. The node supports integration with InfluxDB v2 (via `node-red-contrib-influxdb`) and other storage systems.
+
+### Configuration
+- History Config: Links to a `history-config` node defining the bucket or storage context.
+- Series: The measurement name (e.g., `Return_Temp`) for the data series.
+- Tags: Comma-separated key-value pairs (e.g., `tag0=physical,location=attic`) or single values (e.g., `physical,attic`). Automatically includes `historyGroup` with the `history-config` name.
+- Storage Type: Determines the output format (see below).
+
+### Data Package Formats
+The node supports five `storageType` options, each producing a unique output format for `msg.payload` and related fields:
+
+1. **Memory (Flow Context)**:
+   - Description: Stores data in Node-RED’s global context (`history_data_${historyConfig.name}`) as an array of InfluxDB line protocol strings. No message is sent to the output.
+   - Structure: Line protocol strings, e.g., `Return_Temp,historyGroup=ConfigName,tag0=physical value=74.096 1749782400000000000`.
+   - Fields: None (no output `msg`).
+   - Use Case: Temporary in-memory storage for later processing by a `history-collector` or custom logic.
+   - InfluxDB v2 Compatibility: Requires conversion to line protocol or batch format for writing.
+   - Example: Data is appended to a global array.
+
+2. **Line Protocol**:
+   - Description: Outputs an InfluxDB line protocol string, suitable for direct writing to InfluxDB v1.x or v2.
+   - Structure:
+     ```javascript
+     msg = {
+         measurement: "Return_Temp",
+         payload: "Return_Temp,historyGroup=ConfigName,tag0=physical value=74.096 1749782400000000000"
+     }
+     ```
+   - Fields:
+     - `msg.measurement`: Escaped measurement name.
+     - `msg.payload`: Line protocol string with measurement, tags, `value`, and nanosecond timestamp.
+   - Use Case: Direct write to InfluxDB using `influxdb out` node in line protocol mode.
+   - InfluxDB v2 Compatibility: Works with `influxdb out` (v1.x mode), but less efficient for v2 batch writes.
+   - Example: `msg.payload` is ready for an `influxdb out` node to write a single point.
+
+3. **Object**:
+   - Description: Outputs a structured object with measurement, tags, value, and timestamp, ideal for custom processing.
+   - Structure:
+     ```javascript
+     msg = {
+         measurement: "Return_Temp",
+         payload: {
+             measurement: "Return_Temp",
+             tags: ["historyGroup=ConfigName", "tag0=physical"],
+             value: 74.096,
+             timestamp: 1749782400000000000
+         }
+     }
+     ```
+   - Fields:
+     - `msg.measurement`: Escaped measurement name.
+     - `msg.payload.measurement`: Same as `msg.measurement`.
+     - `msg.payload.tags`: Array of `key=value` strings.
+     - `msg.payload.value`: Number, boolean, or string.
+     - `msg.payload.timestamp`: Nanosecond timestamp.
+   - Use Case: Custom storage or processing (e.g., JSON-based databases, MQTT).
+   - InfluxDB v2 Compatibility: Requires transformation to line protocol or batch format.
+   - Example: Useful for logging or non-InfluxDB storage systems.
+
+4. **ObjectArray (InfluxDB v2)**:
+   - Description: Outputs an array with a value object and tags object, designed for InfluxDB v2 batch processing after transformation.
+   - Structure:
+     ```javascript
+     msg = {
+         measurement: "Return_Temp",
+         timestamp: 1749782400000000000,
+         payload: [
+             { value: 74.096 },
+             { historyGroup: "ConfigName", tag0: "physical" }
+         ]
+     }
+     ```
+   - Fields:
+     - `msg.measurement`: Escaped measurement name.
+     - `msg.timestamp`: Nanosecond timestamp.
+     - `msg.payload[0]`: Object with `value` (number, boolean, or string).
+     - `msg.payload[1]`: Object with tag key-value pairs.
+   - Use Case: Prepares data for InfluxDB v2 batch writes via `influxdb batch` node after a function node converts to `[{ measurement, fields, tags, timestamp }]`.
+   - InfluxDB v2 Compatibility: Common in your flow, needs transformation for `influxdb batch`.
+   - Example: Matches your flow’s input format for batching (e.g., `Return_Temp`).
+
+5. **BatchObject (InfluxDB v2 Batch)**:
+   - Description: Outputs an object formatted for direct use with `node-red-contrib-influxdb`’s `influxdb batch` node for InfluxDB v2.
+   - Structure:
+     ```javascript
+     msg = {
+         payload: {
+             measurement: "Return_Temp",
+             timestamp: 1749782400000000000,
+             fields: { value: 74.096 },
+             tags: { historyGroup: "ConfigName", tag0: "physical" }
+         }
+     }
+     ```
+   - Fields:
+     - `msg.payload.measurement`: Escaped measurement name.
+     - `msg.payload.timestamp`: Nanosecond timestamp.
+     - `msg.payload.fields`: Object with `value` (number, boolean, or string).
+     - `msg.payload.tags`: Object with tag key-value pairs.
+   - Use Case: Direct input to `influxdb batch` node for efficient batch writes to InfluxDB v2.
+   - InfluxDB v2 Compatibility: Ideal for your setup, matches `influxdb batch` requirements.
+   - Example: Streamlines batch writes for measurements like `Stats_Compressor_PPH`.
+
+### Notes
+- Validation: The node validates `payload` to ensure it’s a number (excluding `NaN`), boolean, or string. Strings ending in `i` are parsed as integers.
+- Tags: Tags are parsed from the `Tags` field as key-value pairs (e.g., `key=value`) or indexed tags (e.g., `tag0=physical`). "historyGroup":<node.historyConfig.name> is always included in tags. Special characters are escaped.
+- Timestamp: Generated as nanoseconds (ms * 1e6) for InfluxDB v2 precision.
+- Error Handling: Invalid configurations or payloads trigger warnings and status updates (red ring).
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control)
+- [InfluxDB Line Protocol](https://docs.influxdata.com/influxdb/v2.0/reference/syntax/line-protocol/)
+- [node-red-contrib-influxdb](https://flows.nodered.org/node/node-red-contrib-influxdb)
+</script>