@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/victron-read/victron-read.js

@@ -0,0 +1,1222 @@
+module.exports = function (RED) {
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const {
+        atLeast,
+        clampNumber,
+        roundedAtLeast
+    } = require("../lib/numbers");
+    const mqttState = require("./lib/mqtt-state");
+
+    let mqttLib = null;
+    try {
+        mqttLib = require("mqtt");
+    } catch (error) {
+        mqttLib = null;
+    }
+
+    function isPlainObject(value) {
+        return value !== null && typeof value === "object" && !Array.isArray(value);
+    }
+
+    function normalizePayloadMode(mode) {
+        if (mode === "selected" || mode === "full") {
+            return mode;
+        }
+        return "default";
+    }
+
+    function normalizeSourceType(sourceType) {
+        return sourceType === "mqtt" ? "mqtt" : "global";
+    }
+
+    const BASIC_CATEGORY_SEGMENTS = new Set([
+        "vebus",
+        "battery",
+        "batteries",
+        "pvinverter",
+        "grid",
+        "solarcharger",
+        "inverter",
+        "invertercharger"
+    ]);
+
+    function isBasicMetricSegment(segment) {
+        const s = String(segment || "").toLowerCase();
+        if (!s) {
+            return false;
+        }
+
+        if (["v", "i", "p", "temp", "soc", "soh", "state", "mode"].includes(s)) {
+            return true;
+        }
+
+        return s.includes("voltage") || s.includes("current") || s.includes("power") ||
+            s.includes("temperature") || s.includes("frequency") || s.includes("energy") ||
+            s.includes("yield") || s.includes("consumption");
+    }
+
+    function isBasicOperationalFieldPath(path) {
+        const segments = String(path || "").toLowerCase().split(".").filter(Boolean);
+        if (!segments.length) {
+            return false;
+        }
+
+        const hasCategory = segments.some(function (segment) {
+            return BASIC_CATEGORY_SEGMENTS.has(segment);
+        });
+        if (!hasCategory) {
+            return false;
+        }
+
+        return segments.some(isBasicMetricSegment);
+    }
+
+    function normalizeCsvTokens(value) {
+        if (Array.isArray(value)) {
+            return value
+                .map(function (item) { return String(item || "").trim().toLowerCase(); })
+                .filter(Boolean);
+        }
+
+        if (typeof value === "string") {
+            return value
+                .split(",")
+                .map(function (item) { return String(item || "").trim().toLowerCase(); })
+                .filter(Boolean);
+        }
+
+        return [];
+    }
+
+    function pathMatchesAnyToken(path, tokens) {
+        if (!tokens || !tokens.length) {
+            return false;
+        }
+
+        const normalized = String(path || "").trim().toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+
+        for (let index = 0; index < tokens.length; index += 1) {
+            const token = tokens[index];
+            if (token && normalized.includes(token)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function normalizePayloadFields(payloadFields) {
+        if (Array.isArray(payloadFields)) {
+            const unique = Array.from(new Set(payloadFields.map(function (value) {
+                return String(value || "").trim();
+            }).filter(Boolean)));
+
+            if (unique.includes("full")) {
+                return ["full"];
+            }
+
+            return unique;
+        }
+
+        if (typeof payloadFields === "string") {
+            const trimmed = payloadFields.trim();
+            if (!trimmed) {
+                return ["full"];
+            }
+
+            if (trimmed[0] === "[") {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (Array.isArray(parsed)) {
+                        return normalizePayloadFields(parsed);
+                    }
+                } catch (error) {
+                    // ignore invalid JSON
+                }
+            }
+
+            return [trimmed];
+        }
+
+        return ["full"];
+    }
+
+    function getByPath(source, path) {
+        if (!path) {
+            return source;
+        }
+
+        if (source !== null && source !== undefined && Object.prototype.hasOwnProperty.call(source, path)) {
+            return source[path];
+        }
+
+        if (!path.includes(".")) {
+            return source ? source[path] : undefined;
+        }
+
+        const parts = path.split(".").map(function (part) {
+            return part.trim();
+        }).filter(Boolean);
+
+        let current = source;
+        for (let index = 0; index < parts.length; index += 1) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+
+            // Support flattened keys that already contain dots, e.g. "a.b.c"
+            // stored directly on the current object.
+            if (isPlainObject(current)) {
+                const remainingPath = parts.slice(index).join(".");
+                if (Object.prototype.hasOwnProperty.call(current, remainingPath)) {
+                    return current[remainingPath];
+                }
+            }
+
+            current = current[parts[index]];
+        }
+
+        return current;
+    }
+
+    function setByPath(target, path, value) {
+        if (!isPlainObject(target) || !path) {
+            return;
+        }
+
+        const parts = String(path).split(".").map(function (part) {
+            return part.trim();
+        }).filter(Boolean);
+
+        if (!parts.length) {
+            return;
+        }
+
+        let current = target;
+        for (let index = 0; index < parts.length - 1; index += 1) {
+            const key = parts[index];
+            if (!isPlainObject(current[key])) {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+
+        current[parts[parts.length - 1]] = value;
+    }
+
+    function isSupportedInfluxValue(value) {
+        if (typeof value === "number") {
+            return Number.isFinite(value);
+        }
+
+        if (typeof value === "boolean") {
+            return true;
+        }
+
+        if (typeof value === "string") {
+            return value.trim() !== "";
+        }
+
+        return false;
+    }
+
+    function fieldPathToCompactKey(path) {
+        const compact = String(path || "")
+            .trim()
+            .replace(/[^a-zA-Z0-9_]+/g, "_")
+            .replace(/^_+|_+$/g, "")
+            .toLowerCase();
+
+        return compact || "value";
+    }
+
+    function flattenSupportedFields(source, prefix, target, meta, seen, depth) {
+        const nextDepth = Number.isFinite(depth) ? depth : 0;
+        if (nextDepth > 20) {
+            return;
+        }
+
+        if (source === null || source === undefined) {
+            return;
+        }
+
+        if (isSupportedInfluxValue(source) && prefix) {
+            target[prefix] = source;
+            if (meta) {
+                meta[prefix] = typeof source;
+            }
+            return;
+        }
+
+        if (Array.isArray(source)) {
+            source.forEach(function (item, index) {
+                const key = prefix ? (prefix + "." + index) : String(index);
+                flattenSupportedFields(item, key, target, meta, seen, nextDepth + 1);
+            });
+            return;
+        }
+
+        if (!isPlainObject(source)) {
+            return;
+        }
+
+        if (seen.has(source)) {
+            return;
+        }
+        seen.add(source);
+
+        Object.keys(source).forEach(function (key) {
+            const cleanKey = String(key || "").trim();
+            if (!cleanKey) {
+                return;
+            }
+
+            const value = source[key];
+            const path = prefix ? (prefix + "." + cleanKey) : cleanKey;
+            flattenSupportedFields(value, path, target, meta, seen, nextDepth + 1);
+        });
+    }
+
+    function decodeMqttPayload(payloadBuffer) {
+        return mqttState.decodePayload(payloadBuffer);
+    }
+
+    function scopeFlatMapByPrefix(source, prefixPath) {
+        if (!isPlainObject(source) || !prefixPath) {
+            return null;
+        }
+
+        const prefix = String(prefixPath || "").trim();
+        if (!prefix) {
+            return null;
+        }
+
+        const subset = {};
+        const fullPrefix = prefix + ".";
+        Object.keys(source).forEach(function (key) {
+            const stringKey = String(key || "");
+            if (stringKey === prefix) {
+                subset["value"] = source[key];
+                return;
+            }
+            if (stringKey.indexOf(fullPrefix) === 0) {
+                // Keep full path keys to preserve field categorization in basic mode
+                // and keep selection stable between scoped/unscoped views.
+                subset[stringKey] = source[key];
+            }
+        });
+
+        return Object.keys(subset).length ? subset : null;
+    }
+
+    function getScopedSource(source, path) {
+        if (!path) {
+            return source;
+        }
+
+        const byPath = getByPath(source, path);
+        if (byPath !== undefined) {
+            return byPath;
+        }
+
+        const byPrefix = scopeFlatMapByPrefix(source, path);
+        if (byPrefix !== null) {
+            return byPrefix;
+        }
+
+        return undefined;
+    }
+
+    function rootFromFieldPath(path) {
+        const segments = String(path || "").split(".").filter(Boolean);
+        if (segments.length >= 2) {
+            return segments.slice(0, 2).join(".");
+        }
+        return segments[0] || "";
+    }
+
+    function extractFieldInventory(source) {
+        const flat = {};
+        const types = {};
+
+        flattenSupportedFields(source, "", flat, types, new WeakSet(), 0);
+
+        return Object.keys(flat)
+            .sort(function (a, b) { return a.localeCompare(b); })
+            .map(function (path) {
+                return {
+                    path: path,
+                    type: types[path] || typeof flat[path],
+                    sample: flat[path]
+                };
+            });
+    }
+
+    function extractRootInventory(source) {
+        const fields = extractFieldInventory(source);
+        const roots = new Set();
+
+        fields.forEach(function (item) {
+            const root = rootFromFieldPath(item.path);
+            if (root) {
+                roots.add(root);
+            }
+        });
+
+        return Array.from(roots).sort(function (a, b) { return a.localeCompare(b); });
+    }
+
+    function mergeDecodedMqttMessage(snapshot, topic, decodedValue, topicPathMode, stripPortalId) {
+        mqttState.mergeDecodedMessage(snapshot, new Map(), topic, decodedValue, {
+            topicPathMode: topicPathMode,
+            stripPortalId: stripPortalId
+        });
+    }
+
+    function discoverMqttSnapshot(options, timeoutMs) {
+        return new Promise(function (resolve, reject) {
+            if (!mqttLib) {
+                reject(new Error("Lipseste pachetul 'mqtt'."));
+                return;
+            }
+
+            const mqttUrl = String(options.mqttUrl || "mqtt://127.0.0.1:1883").trim();
+            const topicFilter = String(options.mqttTopicFilter || "N/#").trim() || "N/#";
+            const qos = clampNumber(options.mqttQos, 0, 2, 0);
+            const topicPathMode = options.mqttTopicPathMode === "raw" ? "raw" : "victron";
+            const stripPortalId = options.mqttStripPortalId !== false;
+            const username = String(options.mqttUsername || "").trim();
+            const password = String(options.mqttPassword || "");
+            const configuredClientId = String(options.mqttClientId || "").trim();
+            const clientId = configuredClientId
+                ? ("victron-discover-" + Math.random().toString(16).slice(2, 8))
+                : "";
+            let portalId = String(options.mqttPortalId || "").trim();
+            let keepaliveSent = false;
+
+            const connectOptions = {
+                keepalive: 30,
+                reconnectPeriod: 0,
+                connectTimeout: clampNumber(timeoutMs, 2000, 30000, 5000),
+                clean: true
+            };
+
+            if (clientId) connectOptions.clientId = clientId;
+            if (username) connectOptions.username = username;
+            if (password) connectOptions.password = password;
+
+            const snapshot = {};
+            let messages = 0;
+            let done = false;
+            let timeoutHandle = null;
+            let client = null;
+
+            function finish(err) {
+                if (done) return;
+                done = true;
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                    timeoutHandle = null;
+                }
+
+                if (client) {
+                    try {
+                        client.removeAllListeners("connect");
+                        client.removeAllListeners("message");
+                        client.removeAllListeners("error");
+                        client.end(true);
+                    } catch (closeError) {
+                        // ignore close errors
+                    }
+                }
+
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve({
+                    snapshot: snapshot,
+                    messages: messages,
+                    portalId: portalId
+                });
+            }
+
+            try {
+                client = mqttLib.connect(mqttUrl, connectOptions);
+            } catch (connectError) {
+                finish(connectError);
+                return;
+            }
+
+            timeoutHandle = setTimeout(function () {
+                finish();
+            }, clampNumber(timeoutMs, 2000, 20000, 5000));
+
+            client.on("connect", function () {
+                client.subscribe(topicFilter, { qos: qos }, function (subErr) {
+                    if (subErr) {
+                        finish(subErr);
+                        return;
+                    }
+                    if (portalId) {
+                        client.publish("R/" + portalId + "/keepalive", "");
+                        keepaliveSent = true;
+                    }
+                });
+            });
+
+            client.on("message", function (topic, payloadBuffer) {
+                const value = decodeMqttPayload(payloadBuffer);
+                if (value === undefined) {
+                    return;
+                }
+                mergeDecodedMqttMessage(snapshot, topic, value, topicPathMode, stripPortalId);
+                messages += 1;
+                if (!portalId) {
+                    portalId = mqttState.detectPortalId(topic);
+                }
+                if (portalId && !keepaliveSent) {
+                    client.publish("R/" + portalId + "/keepalive", "");
+                    keepaliveSent = true;
+                }
+            });
+
+            client.on("error", function (err) {
+                finish(err || new Error("MQTT connection error"));
+            });
+        });
+    }
+
+    RED.httpAdmin.get("/victron-read/fields/:id?", function (req, res) {
+        const nodeId = String((req.params && req.params.id) || "").trim();
+        const sourceType = normalizeSourceType(req.query && req.query.sourceType);
+        const queryGlobalVar = String((req.query && req.query.globalVar) || "").trim();
+        const queryGlobalPath = String((req.query && req.query.globalPath) || "").trim();
+
+        const runtimeNode = nodeId ? RED.nodes.getNode(nodeId) : null;
+
+        if (sourceType === "mqtt") {
+            if (!runtimeNode || typeof runtimeNode.__getMqttSnapshot !== "function") {
+                res.json({
+                    ok: false,
+                    error: "Nu exista inca date MQTT in cache. Pune nodul in flow, deploy si asteapta mesaje.",
+                    fields: []
+                });
+                return;
+            }
+
+            const mqttSnapshot = runtimeNode.__getMqttSnapshot();
+            const queryMqttRootPath = String((req.query && req.query.mqttRootPath) || "").trim();
+            const scopedMqtt = getScopedSource(mqttSnapshot, queryMqttRootPath);
+            const fields = extractFieldInventory(scopedMqtt);
+            const roots = extractRootInventory(mqttSnapshot);
+
+            res.json({
+                ok: true,
+                sourceType: "mqtt",
+                mqttRootPath: queryMqttRootPath,
+                portalId: String(runtimeNode.mqttPortalId || ""),
+                roots: roots,
+                count: fields.length,
+                fields: fields
+            });
+            return;
+        }
+
+        if (!runtimeNode) {
+            res.json({
+                ok: false,
+                error: "Nodul editat nu este disponibil in runtime. Salveaza si fa Deploy pentru a citi contextul global.",
+                fields: []
+            });
+            return;
+        }
+
+        const sourceGlobalVar = queryGlobalVar || "victron";
+        const globalCtx = runtimeNode.context().global;
+        const rootValue = globalCtx.get(sourceGlobalVar);
+        const scopedValue = queryGlobalPath ? getByPath(rootValue, queryGlobalPath) : rootValue;
+        const fields = extractFieldInventory(scopedValue);
+
+        res.json({
+            ok: true,
+            sourceType: "global",
+            globalVar: sourceGlobalVar,
+            globalPath: queryGlobalPath,
+            count: fields.length,
+            fields: fields
+        });
+    });
+
+    function sanitizePasswordInput(value) {
+        if (value === undefined || value === null) {
+            return "";
+        }
+        const text = String(value);
+        const trimmed = text.trim();
+        if (!trimmed) return "";
+        if (trimmed === "__PWRD__") return "";
+        if (/^[*\u2022]+$/.test(trimmed)) return "";
+        if (/^[•*]+$/.test(trimmed)) return "";
+        return text;
+    }
+
+    function handleDiscoverMqttRequest(source, res) {
+        const input = (source && typeof source === "object") ? source : {};
+        const timeoutMs = clampNumber(input.timeoutMs, 2000, 20000, 5000);
+        const mqttRootPath = String(input.mqttRootPath || "").trim();
+        const nodeId = String(input.nodeId || "").trim();
+        const runtimeNode = nodeId ? RED.nodes.getNode(nodeId) : null;
+
+        const requestOptions = {
+            mqttUrl: String(input.mqttUrl || "").trim() || (runtimeNode ? String(runtimeNode.mqttUrl || "").trim() : ""),
+            mqttTopicFilter: String(input.mqttTopicFilter || "").trim() || (runtimeNode ? String(runtimeNode.mqttTopicFilter || "").trim() : ""),
+            mqttQos: Number.isFinite(Number(input.mqttQos)) ? Number(input.mqttQos) : (runtimeNode ? Number(runtimeNode.mqttQos || 0) : 0),
+            mqttClientId: String(input.mqttClientId || "").trim() || (runtimeNode ? String(runtimeNode.mqttClientId || "").trim() : ""),
+            mqttUsername: String(input.mqttUsername || "").trim() || (runtimeNode ? String(runtimeNode.mqttUsername || "").trim() : ""),
+            mqttPassword: sanitizePasswordInput(input.mqttPassword) || (runtimeNode ? String(runtimeNode.mqttPassword || "") : ""),
+            mqttPortalId: String(input.mqttPortalId || "").trim() || (runtimeNode ? String(runtimeNode.mqttPortalId || "").trim() : ""),
+            mqttTopicPathMode: (input.mqttTopicPathMode === "raw" || input.mqttTopicPathMode === "victron")
+                ? input.mqttTopicPathMode
+                : (runtimeNode ? String(runtimeNode.mqttTopicPathMode || "victron") : "victron"),
+            mqttStripPortalId: (input.mqttStripPortalId !== undefined && input.mqttStripPortalId !== null)
+                ? !(String(input.mqttStripPortalId).toLowerCase() === "false" || String(input.mqttStripPortalId) === "0")
+                : (runtimeNode ? !!runtimeNode.mqttStripPortalId : true)
+        };
+
+        discoverMqttSnapshot(requestOptions, timeoutMs)
+            .then(function (result) {
+                const snapshot = result.snapshot || {};
+                const roots = extractRootInventory(snapshot);
+                const scoped = getScopedSource(snapshot, mqttRootPath);
+                const fields = extractFieldInventory(scoped);
+
+                res.json({
+                    ok: true,
+                    messages: Number(result.messages || 0),
+                    portalId: String(result.portalId || ""),
+                    roots: roots,
+                    mqttRootPath: mqttRootPath,
+                    count: fields.length,
+                    fields: fields
+                });
+            })
+            .catch(function (error) {
+                res.json({
+                    ok: false,
+                    error: error && error.message ? error.message : String(error || "Eroare necunoscuta"),
+                    roots: [],
+                    fields: []
+                });
+            });
+    }
+
+    RED.httpAdmin.post("/victron-read/discover-mqtt", function (req, res) {
+        const body = (req && req.body && typeof req.body === "object") ? req.body : {};
+        handleDiscoverMqttRequest(body, res);
+    });
+
+    function VictronReadNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.name = String(config.name || "").trim();
+        node.sourceType = normalizeSourceType(config.sourceType);
+
+        node.globalVariable = String(config.globalVariable || "victron").trim() || "victron";
+        node.globalPath = String(config.globalPath || "").trim();
+
+        node.pollInterval = (function () {
+            const text = String(config.pollInterval || "").trim().toLowerCase();
+            if (text === "off" || text === "0") return 0;
+            const n = Math.round(Number(config.pollInterval));
+            return Number.isFinite(n) && n > 0 ? n : 5000;
+        })();
+        node.payloadMode = normalizePayloadMode(config.payloadMode);
+        node.payloadFields = normalizePayloadFields(config.payloadFields);
+
+        node.deviceId = String(config.deviceId || "victron").trim() || "victron";
+        node.topic = String(config.topic || "").trim();
+        node.influxMeasurement = String(config.influxMeasurement || "").trim();
+
+        node.mqttUrl = String(config.mqttUrl || "mqtt://127.0.0.1:1883").trim() || "mqtt://127.0.0.1:1883";
+        node.mqttTopicFilter = String(config.mqttTopicFilter || "N/#").trim() || "N/#";
+        node.mqttQos = clampNumber(config.mqttQos, 0, 2, 0);
+        node.mqttClientId = String(config.mqttClientId || "").trim();
+        node.mqttUsername = String(config.mqttUsername || "root").trim();
+        node.mqttPassword = node.credentials && node.credentials.mqttPassword ? String(node.credentials.mqttPassword) : "";
+        node.mqttTopicPathMode = config.mqttTopicPathMode === "raw" ? "raw" : "victron";
+        node.mqttStripPortalId = config.mqttStripPortalId !== false;
+        node.mqttRootPath = String(config.mqttRootPath || "").trim();
+        node.mqttPortalId = String(config.mqttPortalId || "").trim();
+        node.mqttKeepaliveEnabled = config.mqttKeepaliveEnabled !== false;
+        node.mqttKeepaliveInterval = atLeast(config.mqttKeepaliveInterval, 10000, 30000);
+        node.mqttStaleAfter = roundedAtLeast(config.mqttStaleAfter, 0, 120000);
+        node.emitOnlyChanges = config.emitOnlyChanges === true;
+        // Expert mode is UI-session only (for selecting hidden fields),
+        // never a persisted runtime mode after Done/Deploy.
+        node.expertMode = false;
+        node.includeFieldTokens = normalizeCsvTokens(config.includeFieldTokens);
+        node.excludeFieldTokens = normalizeCsvTokens(config.excludeFieldTokens);
+        node.onlyNumericFields = config.onlyNumericFields !== false;
+        node.maxFields = roundedAtLeast(config.maxFields, 0, 150);
+
+        let timer = null;
+        let mqttKeepaliveTimer = null;
+        let mqttEmitTimer = null;
+        let busy = false;
+        let mqttClient = null;
+        let mqttConnected = false;
+        let mqttMessageCount = 0;
+        let mqttLastUpdateMs = null;
+        let mqttLastFullPublishMs = null;
+        let mqttRevision = 0;
+        let lastEmittedRevision = -1;
+        let lastGlobalSignature = "";
+        let missingMqttLibWarned = false;
+
+        const mqttSnapshot = {};
+        const mqttFieldUpdatedAt = new Map();
+
+        node.__getMqttSnapshot = function () {
+            return mqttSnapshot;
+        };
+
+        function getMeasurement() {
+            return node.influxMeasurement || node.deviceId;
+        }
+
+        function readScopedGlobalValue() {
+            const sourceGlobalVar = node.globalVariable;
+            const sourcePath = node.globalPath;
+            const globalCtx = node.context().global;
+
+            const rootValue = globalCtx.get(sourceGlobalVar);
+            const scopedValue = sourcePath ? getByPath(rootValue, sourcePath) : rootValue;
+
+            return {
+                sourceType: "global",
+                sourceGlobalVar: sourceGlobalVar,
+                sourcePath: sourcePath,
+                scopedValue: scopedValue
+            };
+        }
+
+        function readMqttValue() {
+            const removed = mqttState.pruneStale(mqttSnapshot, mqttFieldUpdatedAt, node.mqttStaleAfter);
+            if (removed.length) {
+                mqttRevision += 1;
+            }
+            const sourcePath = node.mqttRootPath;
+            const scopedValue = sourcePath ? getScopedSource(mqttSnapshot, sourcePath) : mqttSnapshot;
+
+            return {
+                sourceType: "mqtt",
+                sourcePath: sourcePath,
+                sourceGlobalVar: "",
+                scopedValue: scopedValue,
+                staleFieldsRemoved: removed.length
+            };
+        }
+
+        function buildInfluxFields(snapshot, selectedFields, mode) {
+            const scopedValue = snapshot.scopedValue;
+            const fields = {};
+
+            if (mode === "full") {
+                flattenSupportedFields(scopedValue, "", fields, null, new WeakSet(), 0);
+                return {
+                    fields: fields,
+                    effectivePaths: ["full"]
+                };
+            }
+
+            const normalized = normalizePayloadFields(selectedFields).filter(function (field) {
+                return field !== "full";
+            });
+
+            normalized.forEach(function (fieldPath) {
+                const value = getByPath(scopedValue, fieldPath);
+
+                if (isSupportedInfluxValue(value)) {
+                    fields[fieldPathToCompactKey(fieldPath)] = value;
+                    return;
+                }
+
+                if (Array.isArray(value) || isPlainObject(value)) {
+                    flattenSupportedFields(value, fieldPathToCompactKey(fieldPath), fields, null, new WeakSet(), 0);
+                }
+            });
+
+            return {
+                fields: fields,
+                effectivePaths: normalized
+            };
+        }
+
+        function applyFieldTokensAndTypeFilters(fields) {
+            if (normalizePayloadMode(node.payloadMode) !== "default") {
+                return Object.assign({}, fields || {});
+            }
+
+            const filtered = {};
+            const keys = Object.keys(fields || {});
+
+            keys.forEach(function (key) {
+                const value = fields[key];
+                const isNumeric = typeof value === "number" && Number.isFinite(value);
+                if (node.onlyNumericFields && !isNumeric) {
+                    return;
+                }
+
+                if (node.includeFieldTokens.length && !pathMatchesAnyToken(key, node.includeFieldTokens)) {
+                    return;
+                }
+
+                if (node.excludeFieldTokens.length && pathMatchesAnyToken(key, node.excludeFieldTokens)) {
+                    return;
+                }
+
+                filtered[key] = value;
+            });
+
+            return filtered;
+        }
+
+        function applyBasicOperationalFilter(fields, sourcePath) {
+            if (normalizePayloadMode(node.payloadMode) !== "default") {
+                return fields;
+            }
+
+            const filtered = {};
+            Object.keys(fields || {}).forEach(function (key) {
+                const categorizedPath = sourcePath ? (sourcePath + "." + key) : key;
+                if (!isBasicOperationalFieldPath(categorizedPath)) {
+                    return;
+                }
+
+                filtered[key] = fields[key];
+            });
+
+            return filtered;
+        }
+
+        function applyMaxFieldsLimit(fields) {
+            if (normalizePayloadMode(node.payloadMode) !== "default") {
+                return fields;
+            }
+
+            if (!node.maxFields || node.maxFields <= 0) {
+                return fields;
+            }
+
+            const keys = Object.keys(fields || {});
+            if (keys.length <= node.maxFields) {
+                return fields;
+            }
+
+            const limited = {};
+            keys.sort(function (a, b) { return a.localeCompare(b); })
+                .slice(0, node.maxFields)
+                .forEach(function (key) {
+                    limited[key] = fields[key];
+                });
+
+            return limited;
+        }
+
+        function buildMessage(snapshot) {
+            const mode = normalizePayloadMode(node.payloadMode);
+            const selected = normalizePayloadFields(node.payloadFields);
+            const useFull = mode === "full" || selected.includes("full");
+
+            const built = buildInfluxFields(snapshot, selected, useFull ? "full" : "selected");
+            const nowIso = new Date().toISOString();
+            const measurement = getMeasurement();
+            const topic = node.topic || node.deviceId || node.name || "victron-read";
+
+            return {
+                topic: topic,
+                payload: built.fields,
+                payload_field: built.effectivePaths[0] || (mode === "selected" ? "none" : "full"),
+                payload_fields: built.effectivePaths,
+                source_type: snapshot.sourceType,
+                source_global_var: snapshot.sourceGlobalVar || "",
+                source_path: snapshot.sourcePath || "",
+                device_id: node.deviceId,
+                mqtt_portal_id: snapshot.sourceType === "mqtt" ? node.mqttPortalId : "",
+                mqtt_last_update: mqttLastUpdateMs ? new Date(mqttLastUpdateMs).toISOString() : "",
+                mqtt_last_full_publish: mqttLastFullPublishMs ? new Date(mqttLastFullPublishMs).toISOString() : "",
+                influx: {
+                    measurement: measurement,
+                    tags: {
+                        device_type: "victron",
+                        device_id: node.deviceId,
+                        source_type: snapshot.sourceType,
+                        source_global_var: snapshot.sourceGlobalVar || "",
+                        source_path: snapshot.sourcePath || "",
+                        portal_id: snapshot.sourceType === "mqtt" ? node.mqttPortalId : ""
+                    },
+                    fields: built.fields,
+                    timestamp: nowIso
+                }
+            };
+        }
+
+        function updateStatusFromMessage(msg) {
+            const fields = (msg && msg.influx && msg.influx.fields) || {};
+            const count = Object.keys(fields).length;
+
+            if (node.sourceType === "mqtt") {
+                if (!mqttConnected) {
+                    node.status({
+                        fill: "yellow",
+                        shape: "ring",
+                        text: "mqtt disconnected"
+                    });
+                    return;
+                }
+
+                if (!count) {
+                    node.status({
+                        fill: "yellow",
+                        shape: "ring",
+                        text: "mqtt on, fara campuri"
+                    });
+                    return;
+                }
+
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: String(count) + " campuri | mqtt " + String(mqttMessageCount)
+                });
+                return;
+            }
+
+            if (!count) {
+                node.status({
+                    fill: "yellow",
+                    shape: "ring",
+                    text: "fara campuri valide"
+                });
+                return;
+            }
+
+            node.status({
+                fill: "green",
+                shape: "dot",
+                text: String(count) + " campuri -> influx"
+            });
+        }
+
+        function emitSnapshot(reason) {
+            if (busy) {
+                return;
+            }
+
+            busy = true;
+
+            try {
+                const snapshot = node.sourceType === "mqtt" ? readMqttValue() : readScopedGlobalValue();
+                const scopedValue = snapshot.scopedValue;
+
+                if (scopedValue === undefined || scopedValue === null) {
+                    if (node.sourceType === "mqtt") {
+                        node.status({
+                            fill: "yellow",
+                            shape: "ring",
+                            text: mqttConnected ? "mqtt fara date" : "mqtt disconnected"
+                        });
+                    } else {
+                        node.status({
+                            fill: "yellow",
+                            shape: "ring",
+                            text: "lipseste variabila globala"
+                        });
+                    }
+                    return;
+                }
+
+                if (!isPlainObject(scopedValue) && !Array.isArray(scopedValue)) {
+                    node.status({
+                        fill: "yellow",
+                        shape: "ring",
+                        text: "sursa invalida"
+                    });
+                    return;
+                }
+
+                const msg = buildMessage(snapshot);
+                let filteredFields = applyFieldTokensAndTypeFilters(msg.influx.fields || {});
+                filteredFields = applyBasicOperationalFilter(filteredFields, snapshot.sourcePath);
+                filteredFields = applyMaxFieldsLimit(filteredFields);
+
+                if (!Object.keys(filteredFields).length) {
+                    node.status({
+                        fill: node.sourceType === "mqtt" ? "yellow" : "blue",
+                        shape: "ring",
+                        text: node.sourceType === "mqtt" ? "mqtt: 0 campuri proaspete" : "filtrat: 0 campuri"
+                    });
+                    return;
+                }
+
+                msg.payload = filteredFields;
+                msg.influx.fields = filteredFields;
+
+                if (node.emitOnlyChanges) {
+                    if (snapshot.sourceType === "mqtt") {
+                        if (lastEmittedRevision === mqttRevision) {
+                            return;
+                        }
+                        lastEmittedRevision = mqttRevision;
+                    } else {
+                        const signature = JSON.stringify(filteredFields);
+                        if (signature === lastGlobalSignature) {
+                            return;
+                        }
+                        lastGlobalSignature = signature;
+                    }
+                }
+
+                updateStatusFromMessage(msg);
+                node.send(msg);
+            } catch (error) {
+                node.status({
+                    fill: "red",
+                    shape: "ring",
+                    text: "error"
+                });
+                node.error(error && error.message ? error.message : error);
+            } finally {
+                busy = false;
+            }
+        }
+
+        function applyMqttPayload(topic, decodedValue) {
+            const result = mqttState.mergeDecodedMessage(mqttSnapshot, mqttFieldUpdatedAt, topic, decodedValue, {
+                topicPathMode: node.mqttTopicPathMode,
+                stripPortalId: node.mqttStripPortalId
+            });
+            if (!node.mqttPortalId && result.portalId) {
+                node.mqttPortalId = result.portalId;
+                startMqttKeepalive();
+            }
+            if (result.changed) {
+                mqttRevision += 1;
+            }
+            if (String(topic || "").endsWith("/full_publish_completed")) {
+                mqttLastFullPublishMs = Date.now();
+            }
+            mqttMessageCount += 1;
+            mqttLastUpdateMs = Date.now();
+        }
+
+        function publishMqttKeepalive(suppressRepublish) {
+            if (!mqttConnected || !mqttClient || !node.mqttKeepaliveEnabled || !node.mqttPortalId) {
+                return;
+            }
+
+            const payload = suppressRepublish
+                ? JSON.stringify({ "keepalive-options": ["suppress-republish"] })
+                : "";
+            mqttClient.publish("R/" + node.mqttPortalId + "/keepalive", payload, { qos: 0 }, function (error) {
+                if (error) {
+                    node.warn("Eroare keepalive MQTT Victron: " + (error.message || error));
+                }
+            });
+        }
+
+        function startMqttKeepalive() {
+            if (mqttKeepaliveTimer) {
+                clearInterval(mqttKeepaliveTimer);
+                mqttKeepaliveTimer = null;
+            }
+            if (!node.mqttKeepaliveEnabled || !node.mqttPortalId) {
+                return;
+            }
+            publishMqttKeepalive(false);
+            mqttKeepaliveTimer = setInterval(function () {
+                publishMqttKeepalive(true);
+            }, node.mqttKeepaliveInterval);
+        }
+
+        function connectMqtt() {
+            if (node.sourceType !== "mqtt") {
+                return;
+            }
+
+            if (!mqttLib) {
+                if (!missingMqttLibWarned) {
+                    missingMqttLibWarned = true;
+                    node.error("Lipseste pachetul 'mqtt'. Ruleaza npm install in proiect pentru a activa sursa MQTT.");
+                }
+                node.status({
+                    fill: "red",
+                    shape: "ring",
+                    text: "mqtt lib missing"
+                });
+                return;
+            }
+
+            const options = {
+                keepalive: 60,
+                reconnectPeriod: 5000,
+                connectTimeout: 30000,
+                clean: true
+            };
+
+            if (node.mqttClientId) {
+                options.clientId = node.mqttClientId;
+            }
+            if (node.mqttUsername) {
+                options.username = node.mqttUsername;
+            }
+            if (node.mqttPassword) {
+                options.password = node.mqttPassword;
+            }
+
+            mqttClient = mqttLib.connect(node.mqttUrl, options);
+
+            mqttClient.on("connect", function () {
+                mqttConnected = true;
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: "mqtt connected"
+                });
+
+                mqttClient.subscribe(node.mqttTopicFilter, { qos: node.mqttQos }, function (err) {
+                    if (err) {
+                        node.error("Eroare subscribe MQTT: " + (err.message || err));
+                        return;
+                    }
+
+                    node.status({
+                        fill: node.mqttKeepaliveEnabled && !node.mqttPortalId ? "yellow" : "green",
+                        shape: node.mqttKeepaliveEnabled && !node.mqttPortalId ? "ring" : "dot",
+                        text: node.mqttKeepaliveEnabled && !node.mqttPortalId
+                            ? "mqtt: lipseste Portal ID"
+                            : "mqtt subscribed"
+                    });
+                    startMqttKeepalive();
+                });
+            });
+
+            mqttClient.on("reconnect", function () {
+                mqttConnected = false;
+                node.status({
+                    fill: "yellow",
+                    shape: "ring",
+                    text: "mqtt reconnect"
+                });
+            });
+
+            mqttClient.on("close", function () {
+                mqttConnected = false;
+                if (mqttKeepaliveTimer) {
+                    clearInterval(mqttKeepaliveTimer);
+                    mqttKeepaliveTimer = null;
+                }
+                node.status({
+                    fill: "yellow",
+                    shape: "ring",
+                    text: "mqtt closed"
+                });
+            });
+
+            mqttClient.on("error", function (error) {
+                mqttConnected = false;
+                node.status({
+                    fill: "red",
+                    shape: "ring",
+                    text: "mqtt error"
+                });
+                node.error(error && error.message ? error.message : error);
+            });
+
+            mqttClient.on("message", function (topic, payloadBuffer) {
+                const value = decodeMqttPayload(payloadBuffer);
+                if (value === undefined) {
+                    return;
+                }
+
+                applyMqttPayload(topic, value);
+                if (node.emitOnlyChanges) {
+                    if (mqttEmitTimer) {
+                        clearTimeout(mqttEmitTimer);
+                    }
+                    mqttEmitTimer = setTimeout(function () {
+                        mqttEmitTimer = null;
+                        emitSnapshot("mqtt-change");
+                    }, 250);
+                }
+                const ageMs = mqttLastUpdateMs ? (Date.now() - mqttLastUpdateMs) : 0;
+                node.status({
+                    fill: mqttConnected ? "green" : "yellow",
+                    shape: mqttConnected ? "dot" : "ring",
+                    text: "mqtt " + String(mqttMessageCount) + " | " + String(ageMs) + "ms"
+                });
+            });
+        }
+
+        if (node.pollInterval > 0) {
+            timer = setInterval(function () {
+                emitSnapshot("interval");
+            }, node.pollInterval);
+        }
+
+        connectMqtt();
+        if (node.pollInterval > 0) {
+            emitSnapshot("startup");
+        }
+
+        node.on("input", function () {
+            emitSnapshot("input");
+        });
+
+        node.on("close", function (done) {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            if (mqttKeepaliveTimer) {
+                clearInterval(mqttKeepaliveTimer);
+                mqttKeepaliveTimer = null;
+            }
+            if (mqttEmitTimer) {
+                clearTimeout(mqttEmitTimer);
+                mqttEmitTimer = null;
+            }
+
+            if (mqttClient) {
+                try {
+                    mqttClient.end(true, done);
+                    mqttClient = null;
+                    return;
+                } catch (error) {
+                    // ignore close errors
+                }
+                mqttClient = null;
+            }
+
+            done();
+        });
+    
+        });
+    }
+
+    RED.nodes.registerType("victron-read", VictronReadNode, {
+        credentials: {
+            mqttPassword: { type: "password" }
+        }
+    });
+};