@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/multi-grid/multi-grid.js

@@ -0,0 +1,1392 @@
+module.exports = function (RED) {
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const {
+        atLeast,
+        clampNumber,
+        roundedAtLeast
+    } = require("../lib/numbers");
+
+    function normalizeMeterOrder(value) {
+        return String(value || "")
+            .split(",")
+            .map(function (x) { return x.trim(); })
+            .filter(Boolean)
+            .filter(function (v, i, arr) { return arr.indexOf(v) === i; });
+    }
+
+    function normalizeOutputKeys(value) {
+        return String(value || "")
+            .split(",")
+            .map(function (x) { return x.trim(); })
+            .filter(Boolean)
+            .filter(function (v, i, arr) { return arr.indexOf(v) === i; });
+    }
+
+    function normalizeOutputCount(value, fallback) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed) && parsed >= 1) {
+            return Math.max(1, Math.floor(parsed));
+        }
+        return fallback;
+    }
+
+    function extractMeterId(msg, source, customPath) {
+        if (source === "topic") {
+            return String(msg.topic || "").trim();
+        }
+
+        if (source === "meterId") {
+            return String(msg.meterId || "").trim();
+        }
+
+        if (source === "meter_id") {
+            return String(msg.meter_id || "").trim();
+        }
+
+        if (source === "payload.meterId") {
+            return String(msg.payload && msg.payload.meterId || "").trim();
+        }
+
+        if (source === "custom") {
+            const path = String(customPath || "").trim();
+            if (!path) {
+                return "";
+            }
+
+            const value = path.split(".").reduce(function (acc, key) {
+                return acc !== null && acc !== undefined ? acc[key] : undefined;
+            }, msg);
+
+            return String(value || "").trim();
+        }
+
+        return String(msg.topic || "").trim();
+    }
+
+    function isPlainObject(value) {
+        return value !== null && typeof value === "object" && !Array.isArray(value);
+    }
+
+    function cloneObject(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+
+    function onlyNumericEntries(obj) {
+        const result = {};
+
+        Object.keys(obj || {}).forEach(function (key) {
+            const value = obj[key];
+
+            if (typeof value === "number" && Number.isFinite(value)) {
+                result[key] = value;
+                return;
+            }
+
+            if (typeof value === "string" && value.trim() !== "") {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    result[key] = parsed;
+                }
+            }
+        });
+
+        return result;
+    }
+
+    function firstDefined(values) {
+        for (let i = 0; i < values.length; i += 1) {
+            if (values[i] !== undefined && values[i] !== null && String(values[i]).trim() !== "") {
+                return values[i];
+            }
+        }
+        return "";
+    }
+
+    function extractMeterMetadata(msg, meterId) {
+        const influxTags = msg && msg.influx && msg.influx.tags || {};
+        return {
+            meter_id: meterId,
+            ip: String(firstDefined([msg.ip, msg.host, influxTags.host])).trim(),
+            port: String(firstDefined([msg.port, influxTags.port])).trim(),
+            unit_id: String(firstDefined([msg.unit_id, msg.unitId, influxTags.unit_id])).trim(),
+            device_type: String(firstDefined([msg.device_type, influxTags.device_type])).trim(),
+            model: String(firstDefined([msg.model, influxTags.model])).trim()
+        };
+    }
+
+    function aggregateValues(operation, values) {
+        if (!Array.isArray(values) || !values.length) {
+            return undefined;
+        }
+
+        if (operation === "sum") {
+            return values.reduce(function (acc, v) { return acc + v; }, 0);
+        }
+
+        if (operation === "subtract") {
+            return values.slice(1).reduce(function (acc, v) { return acc - v; }, values[0]);
+        }
+
+        if (operation === "min") {
+            return Math.min.apply(null, values);
+        }
+
+        if (operation === "max") {
+            return Math.max.apply(null, values);
+        }
+
+        if (operation === "avg") {
+            const total = values.reduce(function (acc, v) { return acc + v; }, 0);
+            return total / values.length;
+        }
+
+        return values.reduce(function (acc, v) { return acc + v; }, 0);
+    }
+
+    function normalizeMissingDataStrategy(value) {
+        const normalized = String(value || "skip").trim().toLowerCase();
+        if (normalized === "zero-fill" || normalized === "zero_fill" || normalized === "zerofill") {
+            return "zero-fill";
+        }
+        if (normalized === "use-last" || normalized === "use_last" || normalized === "uselast") {
+            return "use-last";
+        }
+        return "skip";
+    }
+
+    function buildOrderedMeterIds(store, configuredOrder) {
+        const seen = new Set();
+        const result = [];
+
+        configuredOrder.forEach(function (id) {
+            if (store[id] && !seen.has(id)) {
+                seen.add(id);
+                result.push(id);
+            }
+        });
+
+        Object.keys(store).forEach(function (id) {
+            if (!seen.has(id)) {
+                seen.add(id);
+                result.push(id);
+            }
+        });
+
+        return result;
+    }
+
+    function parseExpression(expression) {
+        const expr = String(expression || "").replace(/\s+/g, "");
+        if (!expr) {
+            return [];
+        }
+
+        const tokens = expr.match(/[+-]?[^+-]+/g) || [];
+        const result = [];
+
+        tokens.forEach(function (token) {
+            if (!token) {
+                return;
+            }
+
+            let sign = 1;
+            let meterId = token;
+
+            if (token[0] === "+") {
+                sign = 1;
+                meterId = token.slice(1);
+            } else if (token[0] === "-") {
+                sign = -1;
+                meterId = token.slice(1);
+            }
+
+            meterId = String(meterId || "").trim();
+
+            if (!meterId) {
+                return;
+            }
+
+            result.push({
+                meterId: meterId,
+                sign: sign
+            });
+        });
+
+        return result;
+    }
+
+    function expressionMeterIds(tokens) {
+        return tokens.map(function (item) {
+            return item.meterId;
+        }).filter(function (v, i, arr) {
+            return arr.indexOf(v) === i;
+        });
+    }
+
+    function evaluateExpressionForKey(tokens, store, key, options) {
+        const zeroFill = !!(options && options.zeroFill);
+        let hasAny = false;
+        let result = 0;
+
+        tokens.forEach(function (token) {
+            const entry = store[token.meterId];
+            if (!entry || !entry.payload) {
+                if (zeroFill) {
+                    hasAny = true;
+                }
+                return;
+            }
+
+            const value = entry.payload[key];
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                if (zeroFill) {
+                    hasAny = true;
+                }
+                return;
+            }
+
+            result += token.sign * value;
+            hasAny = true;
+        });
+
+        return hasAny ? result : undefined;
+    }
+
+    function detectCategoryFromKey(key) {
+        const k = String(key || "").toLowerCase();
+
+        if (k.indexOf("voltage") === 0 || k.indexOf("u_") === 0) {
+            return "voltage";
+        }
+        if (k.indexOf("current") === 0 || k.indexOf("i_") === 0) {
+            return "current";
+        }
+        if (k.indexOf("power_factor") === 0 || k === "pf" || k.indexOf("pf_") === 0) {
+            return "power_factor";
+        }
+        if (k.indexOf("frequency") === 0 || k.indexOf("freq") === 0) {
+            return "frequency";
+        }
+        if (k.indexOf("reactive") === 0 || k.indexOf("_var") !== -1 || k === "var") {
+            return "reactive";
+        }
+        if (k.indexOf("apparent") === 0 || k.indexOf("_va") !== -1 || k === "va") {
+            return "apparent";
+        }
+        if (k.indexOf("power") === 0 || k.indexOf("_w") !== -1 || k === "w") {
+            return "power";
+        }
+        if (k.indexOf("energy") === 0 || k.indexOf("kwh") !== -1 || k.indexOf("kvarh") !== -1) {
+            return "energy";
+        }
+
+        return "other";
+    }
+
+    function getPayloadCategories(payload) {
+        const categories = [];
+
+        Object.keys(payload || {}).forEach(function (key) {
+            const category = detectCategoryFromKey(key);
+            if (categories.indexOf(category) === -1) {
+                categories.push(category);
+            }
+        });
+
+        return categories.sort();
+    }
+
+    function validateMeterCategoryConsistency(meterIds, store) {
+        const result = {
+            ok: true,
+            reason: "",
+            categoriesByMeter: {}
+        };
+
+        const uniqueSignatureMap = {};
+
+        meterIds.forEach(function (meterId) {
+            const entry = store[meterId];
+            if (!entry || !entry.payload) {
+                return;
+            }
+
+            const categories = getPayloadCategories(entry.payload);
+            result.categoriesByMeter[meterId] = categories;
+
+            const signature = categories.join("|");
+            if (!uniqueSignatureMap[signature]) {
+                uniqueSignatureMap[signature] = [];
+            }
+            uniqueSignatureMap[signature].push(meterId);
+        });
+
+        const signatures = Object.keys(uniqueSignatureMap);
+
+        if (signatures.length <= 1) {
+            return result;
+        }
+
+        result.ok = false;
+        result.reason = signatures.map(function (signature) {
+            const label = signature || "none";
+            return uniqueSignatureMap[signature].join(",") + " -> [" + label + "]";
+        }).join(" ; ");
+
+        return result;
+    }
+
+    function sumValuesByCategory(payload) {
+        const result = {};
+
+        Object.keys(payload || {}).forEach(function (key) {
+            const value = payload[key];
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                return;
+            }
+
+            const category = detectCategoryFromKey(key);
+            if (!Object.prototype.hasOwnProperty.call(result, category)) {
+                result[category] = 0;
+            }
+
+            result[category] += value;
+        });
+
+        return result;
+    }
+
+    function collectRawCategoryValues(meterIds, store) {
+        const valuesByCategory = {};
+
+        meterIds.forEach(function (meterId) {
+            const entry = store[meterId];
+            if (!entry || !entry.payload) {
+                return;
+            }
+
+            Object.keys(entry.payload).forEach(function (key) {
+                const value = entry.payload[key];
+                if (typeof value !== "number" || !Number.isFinite(value)) {
+                    return;
+                }
+
+                const category = detectCategoryFromKey(key);
+
+                if (!valuesByCategory[category]) {
+                    valuesByCategory[category] = [];
+                }
+
+                valuesByCategory[category].push(value);
+            });
+        });
+
+        return valuesByCategory;
+    }
+
+    function collectMeterCategoryTotals(meterIds, store) {
+        const result = {};
+
+        meterIds.forEach(function (meterId) {
+            const entry = store[meterId];
+            if (!entry || !entry.payload) {
+                return;
+            }
+
+            result[meterId] = sumValuesByCategory(entry.payload);
+        });
+
+        return result;
+    }
+
+    function buildScadaPayload(payload) {
+        const src = isPlainObject(payload) ? payload : {};
+        const out = {};
+
+        function copyNumber(targetKey, sourceKeys) {
+            let i;
+            for (i = 0; i < sourceKeys.length; i += 1) {
+                const key = sourceKeys[i];
+                const value = src[key];
+                if (typeof value === "number" && Number.isFinite(value)) {
+                    out[targetKey] = value;
+                    return;
+                }
+            }
+        }
+
+        copyNumber("active_power_w", ["active_power_w", "power_w", "total_power_w"]);
+        copyNumber("reactive_power_var", ["reactive_power_var", "reactive_total_var", "reactive_var"]);
+        copyNumber("frequency_hz", ["frequency_hz", "freq_hz"]);
+        copyNumber("voltage_l1_l2_v", ["voltage_l1_l2_v"]);
+        copyNumber("voltage_l2_l3_v", ["voltage_l2_l3_v"]);
+        copyNumber("voltage_l1_l3_v", ["voltage_l1_l3_v", "voltage_l3_l1_v"]);
+
+        Object.keys(src).forEach(function (key) {
+            const value = src[key];
+            if (!Object.prototype.hasOwnProperty.call(out, key) && typeof value === "number" && Number.isFinite(value)) {
+                out[key] = value;
+            }
+        });
+
+        return out;
+    }
+
+    function buildControlExportReactivePayload(payload) {
+        const src = isPlainObject(payload) ? payload : {};
+        const out = cloneObject(src);
+
+        function firstNumber(keys) {
+            let i;
+            for (i = 0; i < keys.length; i += 1) {
+                const value = src[keys[i]];
+                if (typeof value === "number" && Number.isFinite(value)) {
+                    return value;
+                }
+            }
+            return undefined;
+        }
+
+        const activeTotal = firstNumber(["power_w", "power_total_w", "active_power_w", "total_power_w", "grid_reference_w", "grid_power_w"]);
+        if (typeof activeTotal === "number") {
+            out.power_w = activeTotal;
+            out.active_power_w = activeTotal;
+            out.grid_reference_w = activeTotal;
+        }
+
+        const reactiveTotal = firstNumber(["reactive_total_var", "reactive_power_var", "grid_reactive_power_var", "q_total_var"]);
+        if (typeof reactiveTotal === "number") {
+            out.reactive_total_var = reactiveTotal;
+            out.reactive_power_var = reactiveTotal;
+            out.grid_reactive_power_var = reactiveTotal;
+        }
+
+        return out;
+    }
+
+    function MultiGridNode(config) {
+        RED.nodes.createNode(this, config);
+
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.name = config.name;
+        node.operation = config.operation || "sum";
+        node.expression = String(config.expression || "").trim();
+        node.meterIdSource = config.meterIdSource || "topic";
+        node.customMeterPath = config.customMeterPath || "";
+        node.meterOrder = normalizeMeterOrder(config.meterOrder);
+        node.primaryMeterId = String(config.primaryMeterId || "").trim();
+        node.secondaryMeterId = String(config.secondaryMeterId || "").trim();
+        node.expectedMeterCount = atLeast(config.expectedMeterCount, 0, 0);
+        node.emitPartial = config.emitPartial !== false;
+        node.valueTimeoutMs = atLeast(config.valueTimeoutMs, 0, 0);
+        node.roundDigits = clampNumber(config.roundDigits, 0, 8, 3);
+        node.preserveOriginalMsg = config.preserveOriginalMsg !== false;
+        node.strictCategoryCheck = config.strictCategoryCheck !== false;
+        node.groupByCategory = config.groupByCategory === true;
+        node.scadaServer = config.scadaServer === true;
+        node.controlExportReactive = config.controlExportReactive === true;
+        node.influxDb = config.influxDb === true;
+        node.influxMeasurement = String(config.influxMeasurement || "multi_grid").trim() || "multi_grid";
+        node.influxNode = String(config.influxNode || "").trim();
+        node.splitValueOutputs = config.splitValueOutputs === true;
+        node.splitOutputCount = normalizeOutputCount(config.splitOutputCount, normalizeOutputKeys(config.outputKeys).length || 4);
+        node.missingDataStrategy = normalizeMissingDataStrategy(config.missingDataStrategy);
+        node.primarySecondaryTimeoutMs = atLeast(
+            config.primarySecondaryTimeoutMs || config.valueTimeoutMs,
+            0,
+            10000
+        );
+        node.failSecureEnabled = !!config.failSecureEnabled;
+        node.failSecureTimeSec = roundedAtLeast(config.failSecureTimeSec, 1, 10);
+
+        node.meterStore = {};
+        let failSecureBreachStartMs = null;
+        let failSecureActive = false;
+
+        function roundValue(value) {
+            if (!Number.isFinite(value)) {
+                return value;
+            }
+
+            const factor = Math.pow(10, node.roundDigits);
+            return Math.round(value * factor) / factor;
+        }
+
+        function cleanupExpiredMeters() {
+            if (!node.valueTimeoutMs) {
+                return;
+            }
+
+            const now = Date.now();
+
+            Object.keys(node.meterStore).forEach(function (meterId) {
+                const entry = node.meterStore[meterId];
+                if (!entry || !entry.ts) {
+                    return;
+                }
+
+                if ((now - entry.ts) > node.valueTimeoutMs) {
+                    delete node.meterStore[meterId];
+                }
+            });
+        }
+
+        function getActiveMeterIds() {
+            cleanupExpiredMeters();
+            return buildOrderedMeterIds(node.meterStore, node.meterOrder);
+        }
+
+        function getExpressionTokens() {
+            return parseExpression(node.expression);
+        }
+
+        function getRequiredMeterIds() {
+            if (node.operation === "expression") {
+                return expressionMeterIds(getExpressionTokens());
+            }
+            return [];
+        }
+
+        function getExpectedMeterIds() {
+            if (node.operation === "expression") {
+                return getRequiredMeterIds();
+            }
+
+            if (node.operation === "primary-secondary") {
+                const ids = getPrimarySecondaryMeterIds();
+                return [ids.primaryMeterId, ids.secondaryMeterId].filter(Boolean);
+            }
+
+            if (!node.meterOrder.length) {
+                return [];
+            }
+
+            if (node.expectedMeterCount > 0) {
+                return node.meterOrder.slice(0, node.expectedMeterCount);
+            }
+
+            return node.meterOrder.slice();
+        }
+
+        function formatAge(ms) {
+            if (!Number.isFinite(ms) || ms < 0) {
+                return "n/a";
+            }
+            if (ms < 1000) {
+                return String(Math.round(ms)) + "ms";
+            }
+            if (ms < 60000) {
+                return (Math.round(ms / 100) / 10) + "s";
+            }
+            return (Math.round(ms / 6000) / 10) + "m";
+        }
+
+        function buildHealthSnapshot() {
+            const meterIds = getActiveMeterIds();
+            const requiredMeterIds = getExpectedMeterIds();
+            const now = Date.now();
+            const availableSet = new Set(meterIds);
+            const missingMeterIds = requiredMeterIds.filter(function (id) {
+                return !availableSet.has(id);
+            });
+            const meterAgeMs = {};
+
+            meterIds.forEach(function (id) {
+                const entry = node.meterStore[id];
+                if (!entry || !entry.ts) {
+                    meterAgeMs[id] = null;
+                    return;
+                }
+                meterAgeMs[id] = Math.max(0, now - entry.ts);
+            });
+
+            return {
+                meter_ids: meterIds,
+                meter_count: meterIds.length,
+                required_meter_ids: requiredMeterIds,
+                missing_meter_ids: missingMeterIds,
+                meter_age_ms: meterAgeMs
+            };
+        }
+
+        function buildAgesStatusText(meterIds, meterAgeMs) {
+            if (!meterIds.length) {
+                return "";
+            }
+
+            return meterIds.map(function (id) {
+                return id + ":" + formatAge(meterAgeMs[id]);
+            }).join(",");
+        }
+
+        function updateStatus(customWarningText, health) {
+            const snapshot = health || buildHealthSnapshot();
+            const meterIds = snapshot.meter_ids;
+            const opLabelMap = {
+                sum: "SUM",
+                subtract: "SUB",
+                min: "MIN",
+                max: "MAX",
+                avg: "AVG",
+                expression: "EXPR",
+                "primary-secondary": "PRI/SEC"
+            };
+
+            let text = opLabelMap[node.operation] + " | " + meterIds.length + " metere";
+
+            if (node.operation === "expression" && node.expression) {
+                text = "EXPR | " + node.expression;
+            }
+
+            if (node.groupByCategory) {
+                text += " | cat";
+            }
+
+            if (node.missingDataStrategy !== "skip") {
+                text += " | " + node.missingDataStrategy;
+            }
+
+            if (snapshot.missing_meter_ids.length) {
+                text += " | lipsă:" + snapshot.missing_meter_ids.join(",");
+            }
+
+            const agesText = buildAgesStatusText(meterIds, snapshot.meter_age_ms);
+            if (agesText) {
+                text += " | age " + agesText;
+            }
+
+            if (customWarningText) {
+                node.status({
+                    fill: "yellow",
+                    shape: "ring",
+                    text: customWarningText
+                });
+                return;
+            }
+
+            if (node.operation === "expression" && !node.emitPartial) {
+                const requiredIds = getRequiredMeterIds();
+                const availableSet = new Set(snapshot.meter_ids);
+                const missing = requiredIds.filter(function (id) {
+                    return !availableSet.has(id);
+                });
+
+                if (missing.length) {
+                    node.status({
+                        fill: "yellow",
+                        shape: "ring",
+                        text: "EXPR | lipsă: " + missing.join(",")
+                    });
+                    return;
+                }
+            }
+
+            if (node.expectedMeterCount > 0 && node.operation !== "expression" && node.operation !== "primary-secondary" && snapshot.meter_count < node.expectedMeterCount) {
+                node.status({
+                    fill: "yellow",
+                    shape: "ring",
+                    text: text + " / " + node.expectedMeterCount
+                });
+                return;
+            }
+
+            if (!snapshot.meter_count) {
+                node.status({
+                    fill: "grey",
+                    shape: "ring",
+                    text: "fără date"
+                });
+                return;
+            }
+
+            node.status({
+                fill: "green",
+                shape: "dot",
+                text: text
+            });
+        }
+
+        function buildAggregatePayload(meterIds) {
+            const keys = {};
+            const payload = {};
+            const targetMeterCount = (
+                node.missingDataStrategy === "zero-fill" &&
+                node.expectedMeterCount > meterIds.length
+            )
+                ? node.expectedMeterCount
+                : meterIds.length;
+
+            meterIds.forEach(function (meterId) {
+                const entry = node.meterStore[meterId];
+                if (!entry || !isPlainObject(entry.payload)) {
+                    return;
+                }
+
+                Object.keys(entry.payload).forEach(function (key) {
+                    keys[key] = true;
+                });
+            });
+
+            Object.keys(keys).forEach(function (key) {
+                const values = [];
+
+                meterIds.forEach(function (meterId) {
+                    const entry = node.meterStore[meterId];
+                    if (!entry || !entry.payload) {
+                        if (node.missingDataStrategy === "zero-fill") {
+                            values.push(0);
+                        }
+                        return;
+                    }
+
+                    const value = entry.payload[key];
+                    if (typeof value === "number" && Number.isFinite(value)) {
+                        values.push(value);
+                    } else if (node.missingDataStrategy === "zero-fill") {
+                        values.push(0);
+                    }
+                });
+
+                if (!values.length) {
+                    return;
+                }
+
+                if (node.missingDataStrategy === "zero-fill" && values.length < targetMeterCount) {
+                    while (values.length < targetMeterCount) {
+                        values.push(0);
+                    }
+                }
+
+                payload[key] = roundValue(aggregateValues(node.operation, values));
+            });
+
+            return payload;
+        }
+
+        function buildExpressionPayload() {
+            const tokens = getExpressionTokens();
+            const payload = {};
+            const keys = {};
+            const zeroFill = node.missingDataStrategy === "zero-fill";
+
+            tokens.forEach(function (token) {
+                const entry = node.meterStore[token.meterId];
+                if (!entry || !entry.payload) {
+                    return;
+                }
+
+                Object.keys(entry.payload).forEach(function (key) {
+                    keys[key] = true;
+                });
+            });
+
+            Object.keys(keys).forEach(function (key) {
+                const value = evaluateExpressionForKey(tokens, node.meterStore, key, { zeroFill: zeroFill });
+                if (typeof value === "number" && Number.isFinite(value)) {
+                    payload[key] = roundValue(value);
+                }
+            });
+
+            return payload;
+        }
+
+        function buildCategoryAggregatePayload(meterIds) {
+            const payload = {};
+            const zeroFill = node.missingDataStrategy === "zero-fill";
+            const targetMeterCount = (
+                zeroFill &&
+                node.expectedMeterCount > meterIds.length
+            )
+                ? node.expectedMeterCount
+                : meterIds.length;
+
+            if (node.operation === "subtract") {
+                const meterCategoryTotals = collectMeterCategoryTotals(meterIds, node.meterStore);
+                const categoryMap = {};
+
+                meterIds.forEach(function (meterId) {
+                    const categories = meterCategoryTotals[meterId] || {};
+                    Object.keys(categories).forEach(function (category) {
+                        if (!categoryMap[category]) {
+                            categoryMap[category] = [];
+                        }
+                        categoryMap[category].push(categories[category]);
+                    });
+                });
+
+                Object.keys(categoryMap).forEach(function (category) {
+                    const values = categoryMap[category].slice();
+                    if (zeroFill && values.length < targetMeterCount) {
+                        while (values.length < targetMeterCount) {
+                            values.push(0);
+                        }
+                    }
+                    const value = aggregateValues("subtract", values);
+                    if (typeof value === "number" && Number.isFinite(value)) {
+                        payload[category] = roundValue(value);
+                    }
+                });
+
+                return payload;
+            }
+
+            const rawValuesByCategory = collectRawCategoryValues(meterIds, node.meterStore);
+
+            Object.keys(rawValuesByCategory).forEach(function (category) {
+                const values = rawValuesByCategory[category].slice();
+                if (zeroFill && values.length < targetMeterCount) {
+                    while (values.length < targetMeterCount) {
+                        values.push(0);
+                    }
+                }
+                const value = aggregateValues(node.operation, values);
+                if (typeof value === "number" && Number.isFinite(value)) {
+                    payload[category] = roundValue(value);
+                }
+            });
+
+            return payload;
+        }
+
+        function buildCategoryExpressionPayload() {
+            const tokens = getExpressionTokens();
+            const payload = {};
+            const categoryTotalsByMeter = {};
+            const allCategories = {};
+            const zeroFill = node.missingDataStrategy === "zero-fill";
+
+            tokens.forEach(function (token) {
+                const entry = node.meterStore[token.meterId];
+                if (!entry || !entry.payload) {
+                    return;
+                }
+
+                const totals = sumValuesByCategory(entry.payload);
+                categoryTotalsByMeter[token.meterId] = totals;
+
+                Object.keys(totals).forEach(function (category) {
+                    allCategories[category] = true;
+                });
+            });
+
+            Object.keys(allCategories).forEach(function (category) {
+                let hasAny = false;
+                let value = 0;
+
+                tokens.forEach(function (token) {
+                    const totals = categoryTotalsByMeter[token.meterId] || {};
+                    if (!Object.prototype.hasOwnProperty.call(totals, category)) {
+                        if (zeroFill) {
+                            hasAny = true;
+                        }
+                        return;
+                    }
+
+                    value += token.sign * totals[category];
+                    hasAny = true;
+                });
+
+                if (hasAny && Number.isFinite(value)) {
+                    payload[category] = roundValue(value);
+                }
+            });
+
+            return payload;
+        }
+
+        function getOutputPayloadKeys(payload) {
+            return Object.keys(payload || {}).slice(0, node.splitOutputCount);
+        }
+
+        function buildSplitOutputMessages(baseMsg, payload) {
+            const keys = getOutputPayloadKeys(payload);
+            const aggregatePayload = cloneObject(payload || {});
+
+            return Array.from({ length: node.splitOutputCount }, function (_, index) {
+                const key = keys[index];
+                if (!key || !Object.prototype.hasOwnProperty.call(payload || {}, key)) {
+                    return null;
+                }
+
+                const msg = RED.util.cloneMessage(baseMsg);
+                msg.topic = String(baseMsg.topic || "multi-grid") + "/" + key;
+                msg.payload = payload[key];
+                msg.payload_key = key;
+                msg.output_index = index + 1;
+                msg.output_count = node.splitOutputCount;
+                msg.aggregate_payload = aggregatePayload;
+                return msg;
+            });
+        }
+
+        function buildInfluxMessage(aggregatedPayload, meterIds) {
+            if (!node.influxDb) {
+                return null;
+            }
+
+            const fields = {};
+            Object.keys(aggregatedPayload || {}).forEach(function (key) {
+                const value = aggregatedPayload[key];
+                if (typeof value === "number" && Number.isFinite(value)) {
+                    fields[key] = value;
+                }
+            });
+
+            if (!Object.keys(fields).length) {
+                return null;
+            }
+
+            const meters = (meterIds || []).map(function (meterId) {
+                const entry = node.meterStore[meterId];
+                return cloneObject(entry && entry.metadata || { meter_id: meterId });
+            });
+            function joinedTag(key) {
+                return meters.map(function (meter) { return meter[key]; }).filter(Boolean).join(",");
+            }
+
+            return {
+                topic: "multi-grid/influx",
+                payload: fields,
+                influx: {
+                    measurement: node.influxMeasurement,
+                    tags: {
+                        source: "multi-grid",
+                        operation: node.operation,
+                        meter_count: String(meters.length),
+                        meter_ids: joinedTag("meter_id"),
+                        meter_ips: joinedTag("ip"),
+                        unit_ids: joinedTag("unit_id"),
+                        device_types: joinedTag("device_type"),
+                        meter_models: joinedTag("model")
+                    },
+                    fields: fields,
+                    timestamp: new Date().toISOString()
+                },
+                influx_meter_ids: (meterIds || []).slice(),
+                influx_meters: meters
+            };
+        }
+
+        function sendToInfluxNode(influxMsg) {
+            if (!node.influxDb || !node.influxNode || !influxMsg || !influxMsg.influx) {
+                return;
+            }
+
+            const influxNode = RED.nodes.getNode(node.influxNode);
+            if (!influxNode || typeof influxNode.receive !== "function") {
+                node.warn("multi-grid: nodul adt-influxdb selectat nu este disponibil.");
+                return;
+            }
+
+            influxNode.receive(influxMsg);
+        }
+
+        function sendValueResult(send, outMsg, payload, failMsg) {
+            if (!node.splitValueOutputs) {
+                if (failMsg) {
+                    send([outMsg, failMsg]);
+                } else {
+                    send(outMsg);
+                }
+                return;
+            }
+
+            const messages = buildSplitOutputMessages(outMsg, payload);
+            if (failMsg) {
+                messages.push(failMsg);
+            }
+            send(messages);
+        }
+
+        function canEmit(meterIds) {
+            if (!meterIds.length) {
+                return false;
+            }
+
+            if (node.operation === "expression") {
+                const tokens = getExpressionTokens();
+                if (!tokens.length) {
+                    return false;
+                }
+
+                if (node.emitPartial) {
+                    return true;
+                }
+
+                const requiredIds = expressionMeterIds(tokens);
+                return requiredIds.every(function (id) {
+                    return !!node.meterStore[id];
+                });
+            }
+
+            if (node.operation === "primary-secondary") {
+                return !!selectPrimarySecondaryMeter();
+            }
+
+            if (node.emitPartial) {
+                return true;
+            }
+
+            if (node.expectedMeterCount > 0) {
+                return meterIds.length >= node.expectedMeterCount;
+            }
+
+            return false;
+        }
+
+        function getPrimarySecondaryMeterIds() {
+            return {
+                primaryMeterId: node.primaryMeterId || node.meterOrder[0] || "",
+                secondaryMeterId: node.secondaryMeterId || node.meterOrder[1] || ""
+            };
+        }
+
+        function isMeterFresh(meterId, timeoutMs, now) {
+            if (!meterId) {
+                return false;
+            }
+
+            const entry = node.meterStore[meterId];
+            if (!entry || !entry.ts) {
+                return false;
+            }
+
+            if (!timeoutMs) {
+                return true;
+            }
+
+            return (now - entry.ts) <= timeoutMs;
+        }
+
+        function selectPrimarySecondaryMeter() {
+            const ids = getPrimarySecondaryMeterIds();
+            const now = Date.now();
+            const primaryActive = isMeterFresh(ids.primaryMeterId, node.primarySecondaryTimeoutMs, now);
+            const secondaryActive = isMeterFresh(ids.secondaryMeterId, node.primarySecondaryTimeoutMs, now);
+            let selectedMeterId = "";
+
+            if (primaryActive) {
+                selectedMeterId = ids.primaryMeterId;
+            } else if (secondaryActive) {
+                selectedMeterId = ids.secondaryMeterId;
+            }
+
+            if (!selectedMeterId) {
+                return null;
+            }
+
+            return {
+                selectedMeterId: selectedMeterId,
+                primaryMeterId: ids.primaryMeterId,
+                secondaryMeterId: ids.secondaryMeterId,
+                primaryActive: primaryActive,
+                secondaryActive: secondaryActive
+            };
+        }
+
+        function evaluateFailSecurePrimaryInactive(primaryMeterId) {
+            if (!node.failSecureEnabled || node.operation !== "primary-secondary") {
+                failSecureBreachStartMs = null;
+                failSecureActive = false;
+                return {
+                    enabled: false,
+                    active: false,
+                    durationMs: 0,
+                    timeoutSec: node.failSecureTimeSec
+                };
+            }
+
+            const nowMs = Date.now();
+            const primaryActive = isMeterFresh(primaryMeterId, node.primarySecondaryTimeoutMs, nowMs);
+
+            if (!primaryActive) {
+                if (!Number.isFinite(failSecureBreachStartMs)) {
+                    failSecureBreachStartMs = nowMs;
+                }
+                const durationMs = Math.max(0, nowMs - failSecureBreachStartMs);
+                const triggerMs = Math.max(1000, Math.round(node.failSecureTimeSec * 1000));
+                failSecureActive = durationMs >= triggerMs;
+                return {
+                    enabled: true,
+                    active: failSecureActive,
+                    durationMs: durationMs,
+                    timeoutSec: node.failSecureTimeSec
+                };
+            }
+
+            failSecureBreachStartMs = null;
+            failSecureActive = false;
+            return {
+                enabled: true,
+                active: false,
+                durationMs: 0,
+                timeoutSec: node.failSecureTimeSec
+            };
+        }
+
+        function getMetersUsedForValidation(allActiveMeterIds) {
+            if (node.operation === "expression") {
+                return getExpressionTokens()
+                    .map(function (token) { return token.meterId; })
+                    .filter(function (id, index, arr) {
+                        return arr.indexOf(id) === index && !!node.meterStore[id];
+                    });
+            }
+
+            if (node.operation === "primary-secondary") {
+                const ids = getPrimarySecondaryMeterIds();
+                return [ids.primaryMeterId, ids.secondaryMeterId].filter(function (id, index, arr) {
+                    return !!id && arr.indexOf(id) === index && !!node.meterStore[id];
+                });
+            }
+
+            return allActiveMeterIds.slice();
+        }
+
+        node.on("input", function (msg, send, done) {
+            send = send || function () {
+                node.send.apply(node, arguments);
+            };
+
+            try {
+                const meterId = extractMeterId(msg, node.meterIdSource, node.customMeterPath);
+
+                if (!meterId) {
+                    node.status({
+                        fill: "red",
+                        shape: "ring",
+                        text: "meterId lipsă"
+                    });
+                    done(new Error("multi-grid: mesajul nu conține un meterId valid."));
+                    return;
+                }
+
+                if (!isPlainObject(msg.payload)) {
+                    node.status({
+                        fill: "red",
+                        shape: "ring",
+                        text: "payload invalid"
+                    });
+                    done(new Error("multi-grid: msg.payload trebuie să fie un obiect."));
+                    return;
+                }
+
+                const numericPayload = onlyNumericEntries(msg.payload);
+
+                if (!Object.keys(numericPayload).length) {
+                    node.status({
+                        fill: "red",
+                        shape: "ring",
+                        text: "fără valori numerice"
+                    });
+                    done(new Error("multi-grid: msg.payload nu conține valori numerice."));
+                    return;
+                }
+
+                node.meterStore[meterId] = {
+                    payload: (function () {
+                        if (node.missingDataStrategy !== "use-last" || !node.meterStore[meterId] || !isPlainObject(node.meterStore[meterId].payload)) {
+                            return cloneObject(numericPayload);
+                        }
+                        const merged = cloneObject(node.meterStore[meterId].payload);
+                        Object.keys(numericPayload).forEach(function (key) {
+                            merged[key] = numericPayload[key];
+                        });
+                        return merged;
+                    })(),
+                    ts: Date.now(),
+                    metadata: extractMeterMetadata(msg, meterId)
+                };
+
+                const health = buildHealthSnapshot();
+                const meterIds = health.meter_ids;
+                const validationMeterIds = getMetersUsedForValidation(meterIds);
+
+                if (node.strictCategoryCheck && validationMeterIds.length >= 2) {
+                    const validation = validateMeterCategoryConsistency(validationMeterIds, node.meterStore);
+
+                    if (!validation.ok) {
+                        updateStatus("categorii diferite", health);
+                        node.warn("multi-grid: datele primite nu sunt din aceeași categorie. " + validation.reason);
+                        done();
+                        return;
+                    }
+                }
+
+                updateStatus("", health);
+
+                if (node.operation === "primary-secondary") {
+                    const primarySecondaryIds = getPrimarySecondaryMeterIds();
+                    const primarySecondarySelection = selectPrimarySecondaryMeter();
+                    const failSecureState = evaluateFailSecurePrimaryInactive(primarySecondaryIds.primaryMeterId);
+
+                    if (!primarySecondarySelection && !node.failSecureEnabled) {
+                        done();
+                        return;
+                    }
+
+                    const outMsg = primarySecondarySelection ? (node.preserveOriginalMsg ? RED.util.cloneMessage(msg) : {}) : null;
+                    if (outMsg) {
+                        const aggregatedPayload = cloneObject(node.meterStore[primarySecondarySelection.selectedMeterId].payload || {});
+                        outMsg.topic = node.scadaServer ? "scada-server" : "multi-grid";
+                        outMsg.payload = node.scadaServer
+                            ? buildScadaPayload(aggregatedPayload)
+                            : node.controlExportReactive
+                                ? buildControlExportReactivePayload(aggregatedPayload)
+                                : aggregatedPayload;
+                        outMsg.operation = node.operation;
+                        outMsg.expression = "";
+                        outMsg.meter_count = meterIds.length;
+                        outMsg.meter_ids = meterIds.slice();
+                        outMsg.missing_data_strategy = node.missingDataStrategy;
+                        outMsg.health = {
+                            meter_count: health.meter_count,
+                            meter_ids: health.meter_ids.slice(),
+                            required_meter_ids: health.required_meter_ids.slice(),
+                            missing_meter_ids: health.missing_meter_ids.slice(),
+                            meter_age_ms: cloneObject(health.meter_age_ms)
+                        };
+                        outMsg.parts = meterIds.reduce(function (acc, id) {
+                            acc[id] = cloneObject(node.meterStore[id].payload);
+                            return acc;
+                        }, {});
+                        outMsg.updated_meter_id = meterId;
+                        outMsg.categories = validationMeterIds.reduce(function (acc, id) {
+                            const entry = node.meterStore[id];
+                            acc[id] = entry && entry.payload ? getPayloadCategories(entry.payload) : [];
+                            return acc;
+                        }, {});
+                        outMsg.group_by_category = node.groupByCategory;
+                        outMsg.scada_server = node.scadaServer;
+                        outMsg.control_export_reactive = node.controlExportReactive;
+                        sendToInfluxNode(buildInfluxMessage(aggregatedPayload, meterIds));
+                        delete outMsg.influx;
+                        delete outMsg.influx_meter_ids;
+                        delete outMsg.influx_meters;
+                        outMsg.primary_secondary = {
+                            primary_meter_id: primarySecondarySelection.primaryMeterId,
+                            secondary_meter_id: primarySecondarySelection.secondaryMeterId,
+                            selected_meter_id: primarySecondarySelection.selectedMeterId,
+                            primary_active: primarySecondarySelection.primaryActive,
+                            secondary_active: primarySecondarySelection.secondaryActive,
+                            timeout_ms: node.primarySecondaryTimeoutMs
+                        };
+                    }
+
+                    if (node.failSecureEnabled) {
+                        const failMsg = {
+                            topic: "multi-grid-primary-health",
+                            payload: failSecureState.active ? 1 : 0,
+                            fail_secure: {
+                                active: failSecureState.active,
+                                duration_ms: failSecureState.durationMs,
+                                timeout_s: failSecureState.timeoutSec
+                            },
+                            primary_meter_id: primarySecondaryIds.primaryMeterId,
+                            secondary_meter_id: primarySecondaryIds.secondaryMeterId,
+                            selected_meter_id: primarySecondarySelection ? primarySecondarySelection.selectedMeterId : "",
+                            primary_active: !!(primarySecondarySelection && primarySecondarySelection.primaryActive),
+                            secondary_active: !!(primarySecondarySelection && primarySecondarySelection.secondaryActive),
+                            timeout_ms: node.primarySecondaryTimeoutMs
+                        };
+                        if (outMsg) {
+                            sendValueResult(send, outMsg, outMsg.payload, failMsg);
+                        } else {
+                            const messages = node.splitValueOutputs ? new Array(node.splitOutputCount).fill(null) : [null];
+                            messages.push(failMsg);
+                            send(messages);
+                        }
+                    } else if (outMsg) {
+                        sendValueResult(send, outMsg, outMsg.payload);
+                    }
+                    done();
+                    return;
+                }
+
+                if (!canEmit(meterIds)) {
+                    done();
+                    return;
+                }
+
+                let aggregatedPayload;
+
+                if (node.groupByCategory) {
+                    aggregatedPayload = node.operation === "expression"
+                        ? buildCategoryExpressionPayload()
+                        : buildCategoryAggregatePayload(meterIds);
+                } else {
+                    aggregatedPayload = node.operation === "expression"
+                        ? buildExpressionPayload()
+                        : buildAggregatePayload(meterIds);
+                }
+
+                const outMsg = node.preserveOriginalMsg ? RED.util.cloneMessage(msg) : {};
+
+                outMsg.topic = node.scadaServer ? "scada-server" : "multi-grid";
+                outMsg.payload = node.scadaServer
+                    ? buildScadaPayload(aggregatedPayload)
+                    : node.controlExportReactive
+                        ? buildControlExportReactivePayload(aggregatedPayload)
+                        : aggregatedPayload;
+                outMsg.operation = node.operation;
+                outMsg.expression = node.operation === "expression" ? node.expression : "";
+                outMsg.meter_count = meterIds.length;
+                outMsg.meter_ids = meterIds.slice();
+                outMsg.missing_data_strategy = node.missingDataStrategy;
+                outMsg.health = {
+                    meter_count: health.meter_count,
+                    meter_ids: health.meter_ids.slice(),
+                    required_meter_ids: health.required_meter_ids.slice(),
+                    missing_meter_ids: health.missing_meter_ids.slice(),
+                    meter_age_ms: cloneObject(health.meter_age_ms)
+                };
+                outMsg.parts = meterIds.reduce(function (acc, id) {
+                    acc[id] = cloneObject(node.meterStore[id].payload);
+                    return acc;
+                }, {});
+                outMsg.updated_meter_id = meterId;
+                outMsg.categories = validationMeterIds.reduce(function (acc, id) {
+                    const entry = node.meterStore[id];
+                    acc[id] = entry && entry.payload ? getPayloadCategories(entry.payload) : [];
+                    return acc;
+                }, {});
+                outMsg.group_by_category = node.groupByCategory;
+                outMsg.scada_server = node.scadaServer;
+                outMsg.control_export_reactive = node.controlExportReactive;
+                sendToInfluxNode(buildInfluxMessage(aggregatedPayload, meterIds));
+                delete outMsg.influx;
+                delete outMsg.influx_meter_ids;
+                delete outMsg.influx_meters;
+
+                sendValueResult(send, outMsg, outMsg.payload);
+                done();
+            } catch (err) {
+                node.status({
+                    fill: "red",
+                    shape: "ring",
+                    text: err.message
+                });
+                done(err);
+            }
+        });
+
+        node.on("close", function (done) {
+            node.meterStore = {};
+            if (typeof done === "function") {
+                done();
+            }
+        });
+
+        updateStatus();
+    
+        });
+    }
+
+    RED.nodes.registerType("multi-grid", MultiGridNode);
+};