node-red-contrib-event-calc 3.3.3 → 3.3.15

package/nodes/event-frame.js

@@ -0,0 +1,246 @@
+/**
+ * event-frame - ISA-88 batch structure tracking node
+ *
+ * Creates ISA-88 procedural model records:
+ *   Procedure > Unit Procedure > Operation > Phase
+ *
+ * Features:
+ * - Trigger-based: starts on true, ends on false
+ * - Auto-generated unique IDs
+ * - Chainable: start output carries frame_id for child nodes to use as parent_id
+ * - Auto-end children: when a parent ends, all children with matching parent_id end too
+ * - Hierarchical parent-child linking via global context dictionary
+ * - Outputs complete batch record on end
+ */
+module.exports = function(RED) {
+    const crypto = require('crypto');
+    const EventEmitter = require('events');
+
+    // Shared emitter for end-children cascade (one per contextKey)
+    const sharedEmitters = new Map();
+
+    function getEmitter(contextKey) {
+        if (!sharedEmitters.has(contextKey)) {
+            const emitter = new EventEmitter();
+            emitter.setMaxListeners(100);
+            sharedEmitters.set(contextKey, emitter);
+        }
+        return sharedEmitters.get(contextKey);
+    }
+
+    function EventFrameNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.level = config.level || 'operation';
+        node.batchName = config.batchName || '';
+        node.batchNameType = config.batchNameType || 'str';
+        node.unit = config.unit || '';
+        node.unitType = config.unitType || 'str';
+        node.batchId = config.batchId || '';
+        node.batchIdType = config.batchIdType || 'str';
+        node.parentLevel = config.parentLevel || '';
+        node.triggerField = config.triggerField || 'payload';
+        node.metadataField = config.metadataField || '';
+        node.contextKey = config.contextKey || 'isa88_batches';
+        node.endChildren = config.endChildren !== false; // default true
+
+        const globalContext = node.context().global;
+        const emitter = getEmitter(node.contextKey);
+
+        // Tracker key: use node.id so multiple nodes at the same level can coexist
+        const trackerKey = node.id;
+
+        function getTracker() {
+            return globalContext.get(node.contextKey) || {};
+        }
+
+        function setTracker(tracker) {
+            globalContext.set(node.contextKey, tracker);
+        }
+
+        function generateId() {
+            return crypto.randomUUID();
+        }
+
+        function resolveValue(value, type, msg) {
+            if (!value) return '';
+            switch (type) {
+                case 'msg': return RED.util.getMessageProperty(msg, value) || '';
+                case 'flow': return node.context().flow.get(value) || '';
+                case 'global': return globalContext.get(value) || '';
+                case 'env': return RED.util.evaluateNodeProperty(value, 'env', node, msg) || '';
+                default: return value;
+            }
+        }
+
+        // Resolve parent_id: msg.frame_id (from chained wiring) > parentLevel lookup
+        function resolveParentId(tracker, msg) {
+            if (msg.frame_id) {
+                return msg.frame_id;
+            }
+            if (node.parentLevel) {
+                // Search tracker for an active record at the parent level
+                for (const key in tracker) {
+                    const entry = tracker[key];
+                    if (entry && entry.active && entry.record && entry.record.level === node.parentLevel) {
+                        return entry.id;
+                    }
+                }
+            }
+            return '';
+        }
+
+        /**
+         * End the current frame record, emit cascade event, and output
+         */
+        function endFrame(send) {
+            const tracker = getTracker();
+            const entry = tracker[trackerKey];
+            if (!entry || !entry.active) return null;
+
+            const record = entry.record;
+            record.endtime = new Date().toISOString();
+            record.state = 'complete';
+
+            // Clear active record
+            tracker[trackerKey] = { active: false };
+            setTracker(tracker);
+
+            node.status({ fill: "grey", shape: "ring", text: `${node.level}: complete` });
+
+            const endMsg = {
+                topic: `batch/${node.level}/end`,
+                payload: { ...record },
+                frame_id: record.id
+            };
+
+            if (send) {
+                send([null, endMsg]);
+            } else {
+                node.send([null, endMsg]);
+            }
+
+            // Cascade: signal children to end
+            if (node.endChildren) {
+                emitter.emit('end-frame', record.id);
+            }
+
+            return record;
+        }
+
+        // Listen for parent ending — auto-end this frame if our parent_id matches
+        function onParentEnd(parentId) {
+            const tracker = getTracker();
+            const entry = tracker[trackerKey];
+            if (entry && entry.active && entry.record && entry.record.parent_id === parentId) {
+                endFrame(null);
+            }
+        }
+
+        emitter.on('end-frame', onParentEnd);
+
+        node.status({ fill: "grey", shape: "ring", text: "idle" });
+
+        node.on('input', function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+            done = done || function(err) { if (err) node.error(err, msg); };
+
+            try {
+                // Extract trigger value
+                let trigger;
+                if (node.triggerField.startsWith('msg.')) {
+                    trigger = RED.util.getMessageProperty(msg, node.triggerField.substring(4));
+                } else {
+                    trigger = RED.util.getMessageProperty(msg, node.triggerField);
+                }
+                const isActive = !!trigger;
+
+                const tracker = getTracker();
+                const entry = tracker[trackerKey] || { active: false };
+
+                if (isActive && !entry.active) {
+                    // ── START frame record ──
+                    const id = generateId();
+                    const batchName = resolveValue(node.batchName, node.batchNameType, msg);
+                    const unitVal = resolveValue(node.unit, node.unitType, msg);
+                    const batchIdVal = resolveValue(node.batchId, node.batchIdType, msg);
+                    const parentId = resolveParentId(tracker, msg);
+
+                    // Extract optional metadata
+                    let metadata = '';
+                    if (node.metadataField) {
+                        const raw = RED.util.getMessageProperty(msg, node.metadataField);
+                        metadata = (raw !== undefined) ? (typeof raw === 'string' ? raw : JSON.stringify(raw)) : '';
+                    }
+
+                    const record = {
+                        id: id,
+                        starttime: new Date().toISOString(),
+                        endtime: '9999-12-31T23:59:59.000Z',
+                        name: batchName,
+                        parent_id: parentId,
+                        level: node.level,
+                        state: 'running',
+                        batch_id: batchIdVal,
+                        unit: unitVal,
+                        metadata: metadata
+                    };
+
+                    // Store active record in tracker
+                    tracker[trackerKey] = {
+                        active: true,
+                        id: id,
+                        record: record
+                    };
+                    setTracker(tracker);
+
+                    node.status({ fill: "green", shape: "dot", text: `${node.level}: running` });
+
+                    // Output start event — frame_id enables chaining to child nodes
+                    const startMsg = {
+                        topic: `batch/${node.level}/start`,
+                        payload: { ...record },
+                        frame_id: id
+                    };
+                    send([startMsg, null]);
+                    done();
+
+                } else if (!isActive && entry.active) {
+                    // ── END frame record ──
+                    endFrame(send);
+                    done();
+
+                } else {
+                    // No state change
+                    done();
+                }
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: "error" });
+                done(err);
+            }
+        });
+
+        node.on('close', function(done) {
+            emitter.removeListener('end-frame', onParentEnd);
+            done();
+        });
+    }
+
+    RED.nodes.registerType("event-frame", EventFrameNode);
+
+    // Admin endpoint to get current batch tracker state
+    RED.httpAdmin.get("/event-frame/tracker", function(req, res) {
+        const contextKey = req.query.key || 'isa88_batches';
+        let tracker = {};
+        RED.nodes.eachNode(function(n) {
+            if (n.type === 'event-frame') {
+                const frameNode = RED.nodes.getNode(n.id);
+                if (frameNode) {
+                    tracker = frameNode.context().global.get(contextKey) || {};
+                }
+            }
+        });
+        res.json(tracker);
+    });
+};

package/nodes/simple-frame.html

@@ -0,0 +1,125 @@
+<style>
+    .event-calc-white-text { fill: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="simple-frame"] .red-ui-palette-label { color: #ffffff !important; }
+</style>
+
+<script type="text/javascript">
+    RED.nodes.registerType('simple-frame', {
+        category: 'event calc',
+        color: '#4A90D9',
+        defaults: {
+            name: { value: "" },
+            eventType: { value: "" },
+            eventTypeType: { value: "str" },
+            eventName: { value: "" },
+            eventNameType: { value: "str" },
+            triggerField: { value: "payload" },
+            metadataField: { value: "" },
+            outputTopic: { value: "" }
+        },
+        inputs: 1,
+        outputs: 2,
+        outputLabels: ["start", "end"],
+        icon: "font-awesome/fa-bookmark",
+        label: function() {
+            return this.name || "simple frame";
+        },
+        paletteLabel: "simple frame",
+        labelStyle: function() { return (this.name ? "node_label_italic" : "") + " event-calc-white-text"; },
+        oneditprepare: function() {
+            $("#node-input-eventType").typedInput({
+                default: 'str',
+                types: ['str', 'msg', 'flow', 'global', 'env'],
+                typeField: "#node-input-eventTypeType"
+            });
+            $("#node-input-eventName").typedInput({
+                default: 'str',
+                types: ['str', 'msg', 'flow', 'global', 'env'],
+                typeField: "#node-input-eventNameType"
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="simple-frame">
+    <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-eventType"><i class="fa fa-bookmark"></i> Event Type</label>
+        <input type="text" id="node-input-eventType" placeholder="e.g. maintenance">
+        <input type="hidden" id="node-input-eventTypeType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-eventName"><i class="fa fa-pencil"></i> Event Name</label>
+        <input type="text" id="node-input-eventName" placeholder="e.g. Oil Change">
+        <input type="hidden" id="node-input-eventNameType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-triggerField"><i class="fa fa-bolt"></i> Trigger Field</label>
+        <input type="text" id="node-input-triggerField" placeholder="payload">
+        <div class="form-tips">Message property: <code>truthy</code> starts, <code>falsy</code> ends the event.</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-metadataField"><i class="fa fa-info-circle"></i> Metadata Field</label>
+        <input type="text" id="node-input-metadataField" placeholder="e.g. metadata">
+        <div class="form-tips">Optional <code>msg</code> property containing extra metadata (string or object).</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-outputTopic"><i class="fa fa-envelope"></i> Output Topic</label>
+        <input type="text" id="node-input-outputTopic" placeholder="auto: event/{type}/start|end">
+        <div class="form-tips">Override <code>msg.topic</code>. Leave blank for automatic: <code>event/{type}/start</code> and <code>event/{type}/end</code>.</div>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="simple-frame">
+    <p>A simple event frame that tracks start and end times.</p>
+
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Event Type</dt>
+        <dd>A label for the kind of event (e.g. "maintenance", "downtime", "shift").
+        Can be a static string, msg property, flow/global context, or env variable.</dd>
+        <dt>Event Name</dt>
+        <dd>A descriptive name for the event (e.g. "Oil Change", "Day Shift").
+        Supports the same input types as Event Type.</dd>
+        <dt>Trigger Field</dt>
+        <dd>Message property: truthy starts, falsy ends the event record.</dd>
+        <dt>Metadata Field</dt>
+        <dd>Optional msg property for extra metadata (stored as string).</dd>
+        <dt>Output Topic</dt>
+        <dd>Override msg.topic. Leave blank to auto-generate <code>event/{type}/start</code> and <code>event/{type}/end</code>.</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <p>Any message. The trigger field determines start/end:</p>
+    <ul>
+        <li><b>Truthy</b> (and no active event): starts a new event record</li>
+        <li><b>Falsy</b> (and event is active): ends the current record</li>
+    </ul>
+
+    <h3>Outputs</h3>
+    <ol>
+        <li><b>Start</b> — emits when a new event begins (state: "running")</li>
+        <li><b>End</b> — emits the completed record with <code>endtime</code> filled in (state: "complete")</li>
+    </ol>
+
+    <h3>Output Record</h3>
+    <pre>{
+  "id": "auto-generated UUID",
+  "starttime": "2024-01-15T10:30:00.000Z",
+  "endtime": "9999-12-31T23:59:59.000Z",
+  "type": "maintenance",
+  "name": "Oil Change",
+  "state": "complete",
+  "metadata": ""
+}</pre>
+
+    <h3>Details</h3>
+    <p>A simplified event frame — no ISA-88 hierarchy, no parent-child
+    relationships, no cascade. Just a clean start/end record for any event you
+    want to track.</p>
+    <p>Each node tracks one active event at a time. Send a truthy trigger to start,
+    and a falsy trigger to end. The active record is stored in node context.</p>
+</script>

package/nodes/simple-frame.js

@@ -0,0 +1,126 @@
+/**
+ * simple-frame - Simple event recorder node
+ *
+ * Records events with start/end time, type, name, and metadata.
+ * No ISA-88 hierarchy, no parent-child relationships, no cascade.
+ *
+ * Features:
+ * - Trigger-based: truthy starts, falsy ends
+ * - Auto-generated unique IDs
+ * - Configurable type and name (str/msg/flow/global/env)
+ * - Optional metadata from msg field
+ * - Two outputs: [start, end]
+ */
+module.exports = function(RED) {
+    const crypto = require('crypto');
+
+    function SimpleFrameNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.eventType = config.eventType || '';
+        node.eventTypeType = config.eventTypeType || 'str';
+        node.eventName = config.eventName || '';
+        node.eventNameType = config.eventNameType || 'str';
+        node.triggerField = config.triggerField || 'payload';
+        node.metadataField = config.metadataField || '';
+        node.outputTopic = config.outputTopic || '';
+
+        function resolveValue(value, type, msg) {
+            if (!value) return '';
+            switch (type) {
+                case 'msg': return RED.util.getMessageProperty(msg, value) || '';
+                case 'flow': return node.context().flow.get(value) || '';
+                case 'global': return node.context().global.get(value) || '';
+                case 'env': return RED.util.evaluateNodeProperty(value, 'env', node, msg) || '';
+                default: return value;
+            }
+        }
+
+        node.status({ fill: "grey", shape: "ring", text: "idle" });
+
+        node.on('input', function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+            done = done || function(err) { if (err) node.error(err, msg); };
+
+            try {
+                // Extract trigger value
+                let trigger;
+                if (node.triggerField.startsWith('msg.')) {
+                    trigger = RED.util.getMessageProperty(msg, node.triggerField.substring(4));
+                } else {
+                    trigger = RED.util.getMessageProperty(msg, node.triggerField);
+                }
+                const isActive = !!trigger;
+
+                // Get active record from node context
+                const activeRecord = node.context().get('activeRecord') || null;
+
+                if (isActive && !activeRecord) {
+                    // ── START event ──
+                    const typeVal = resolveValue(node.eventType, node.eventTypeType, msg);
+                    const nameVal = resolveValue(node.eventName, node.eventNameType, msg);
+
+                    // Extract optional metadata
+                    let metadata = '';
+                    if (node.metadataField) {
+                        const raw = RED.util.getMessageProperty(msg, node.metadataField);
+                        metadata = (raw !== undefined) ? (typeof raw === 'string' ? raw : JSON.stringify(raw)) : '';
+                    }
+
+                    const record = {
+                        id: crypto.randomUUID(),
+                        starttime: new Date().toISOString(),
+                        endtime: '9999-12-31T23:59:59.000Z',
+                        type: typeVal,
+                        name: nameVal,
+                        state: 'running',
+                        metadata: metadata
+                    };
+
+                    // Store in node context
+                    node.context().set('activeRecord', record);
+
+                    node.status({ fill: "green", shape: "dot", text: "running" });
+
+                    const topic = node.outputTopic || (typeVal ? `event/${typeVal}/start` : 'event/start');
+                    const startMsg = {
+                        topic: topic,
+                        payload: { ...record }
+                    };
+                    send([startMsg, null]);
+                    done();
+
+                } else if (!isActive && activeRecord) {
+                    // ── END event ──
+                    const record = { ...activeRecord };
+                    record.endtime = new Date().toISOString();
+                    record.state = 'complete';
+
+                    // Clear active record
+                    node.context().set('activeRecord', null);
+
+                    node.status({ fill: "grey", shape: "ring", text: "complete" });
+
+                    const typeVal = record.type;
+                    const topic = node.outputTopic || (typeVal ? `event/${typeVal}/end` : 'event/end');
+                    const endMsg = {
+                        topic: topic,
+                        payload: { ...record }
+                    };
+                    send([null, endMsg]);
+                    done();
+
+                } else {
+                    // No state change
+                    done();
+                }
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: "error" });
+                done(err);
+            }
+        });
+    }
+
+    RED.nodes.registerType("simple-frame", SimpleFrameNode);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-event-calc",
-  "version": "3.3.3",
+  "version": "3.3.15",
   "description": "Node-RED nodes for event caching and calculations",
   "author": {
     "name": "Holger Amort"
@@ -29,9 +29,13 @@
       "event-in": "nodes/event-in.js",
       "event-topic": "nodes/event-topic.js",
       "event-calc": "nodes/event-calc.js",
+      "event-flatten": "nodes/event-flatten.js",
       "event-preview": "nodes/event-preview.js",
       "event-simulator": "nodes/event-simulator.js",
-      "event-chart": "nodes/event-chart.js"
+      "event-chart": "nodes/event-chart.js",
+      "event-frame": "nodes/event-frame.js",
+      "event-alarm": "nodes/event-alarm.js",
+      "simple-frame": "nodes/simple-frame.js"
     }
   },
   "engines": {

package/playwright.config.js

@@ -1,22 +0,0 @@
-// @ts-check
-const { defineConfig } = require('@playwright/test');
-
-module.exports = defineConfig({
-  testDir: './tests',
-  fullyParallel: false,
-  forbidOnly: !!process.env.CI,
-  retries: process.env.CI ? 2 : 0,
-  workers: 1,
-  reporter: 'html',
-  use: {
-    baseURL: 'http://localhost:1880',
-    trace: 'on-first-retry',
-    screenshot: 'only-on-failure',
-  },
-  projects: [
-    {
-      name: 'chromium',
-      use: { browserName: 'chromium' },
-    },
-  ],
-});