@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/victron-read/victron-read.html

@@ -0,0 +1,1074 @@
+<style>
+    .victron-read-editor {
+        --vr-border: #d7dde5;
+        --vr-muted: #667085;
+        --vr-surface: #f8fafc;
+    }
+
+    .victron-read-editor .vr-section {
+        margin: 0 0 18px;
+        padding: 14px 16px 16px;
+        border: 1px solid var(--vr-border);
+        border-radius: 10px;
+        background: var(--vr-surface);
+    }
+
+    .victron-read-editor .vr-section-title {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin: 0 0 4px;
+        font-size: 15px;
+        font-weight: 600;
+        color: #243447;
+    }
+
+    .victron-read-editor .vr-section-note {
+        margin: 0 0 14px;
+        color: var(--vr-muted);
+        font-size: 12px;
+        line-height: 1.45;
+    }
+
+    .victron-read-editor .vr-grid {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 12px 16px;
+    }
+
+    .victron-read-editor .form-row {
+        margin-bottom: 12px;
+    }
+
+    .victron-read-editor .vr-grid .form-row,
+    .victron-read-editor .form-row:last-child {
+        margin-bottom: 0;
+    }
+
+    .victron-read-editor .form-row > label {
+        width: 170px;
+        font-weight: 600;
+    }
+
+    .victron-read-editor .form-row > input[type="text"],
+    .victron-read-editor .form-row > input[type="password"],
+    .victron-read-editor .form-row > select {
+        width: calc(100% - 180px);
+    }
+
+    .victron-read-editor .vr-checkbox-row > input[type="checkbox"] {
+        display: inline-block;
+        width: auto;
+        vertical-align: top;
+    }
+
+    .victron-read-editor .vr-inline-note {
+        margin-left: 8px;
+        color: var(--vr-muted);
+        line-height: 1.4;
+    }
+
+    .victron-read-editor .vr-toolbar {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-bottom: 10px;
+    }
+
+    .victron-read-editor .vr-field-list {
+        max-height: 360px;
+        overflow: auto;
+        padding: 12px;
+        border: 1px solid var(--vr-border);
+        border-radius: 10px;
+        background: #fff;
+    }
+
+    .victron-read-editor .vr-field-group {
+        margin-bottom: 14px;
+    }
+
+    .victron-read-editor .vr-field-group:last-child {
+        margin-bottom: 0;
+    }
+
+    .victron-read-editor .vr-field-group-title {
+        margin: 0 0 8px;
+        font-size: 12px;
+        font-weight: 700;
+        text-transform: uppercase;
+        letter-spacing: 0.03em;
+        color: #344054;
+    }
+
+    .victron-read-editor .vr-field-group-grid {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 8px 16px;
+    }
+
+    @media (max-width: 980px) {
+        .victron-read-editor .vr-grid,
+        .victron-read-editor .vr-field-group-grid {
+            grid-template-columns: 1fr;
+        }
+    }
+
+    .victron-read-editor .vr-field-item {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin: 0;
+        line-height: 1.35;
+    }
+
+    .victron-read-editor .vr-field-meta {
+        margin-left: auto;
+        font-size: 11px;
+        color: var(--vr-muted);
+    }
+
+    .victron-read-editor .vr-load-status {
+        margin-bottom: 10px;
+        font-size: 12px;
+        color: var(--vr-muted);
+    }
+</style>
+
+<script type="text/javascript">
+    (function () {
+        function normalizePayloadFields(payloadFields) {
+            if (Array.isArray(payloadFields)) {
+                const filtered = payloadFields
+                    .map(function (value) { return String(value || "").trim(); })
+                    .filter(Boolean);
+
+                const unique = Array.from(new Set(filtered));
+                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"];
+        }
+
+        const BASIC_CATEGORY_SEGMENTS = new Set([
+            "vebus",
+            "battery",
+            "batteries",
+            "pvinverter",
+            "grid",
+            "solarcharger",
+            "inverter",
+            "invertercharger"
+        ]);
+
+        const SPECIAL_EXPERT_LONG_PRESS_MS = 5000;
+
+        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 isBasicFieldPath(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 groupFields(items) {
+            const groups = {};
+
+            items.forEach(function (item) {
+                const path = String(item.path || "").trim();
+                if (!path) {
+                    return;
+                }
+
+                const topLevel = path.includes(".") ? path.split(".")[0] : "root";
+                if (!groups[topLevel]) {
+                    groups[topLevel] = [];
+                }
+
+                groups[topLevel].push(item);
+            });
+
+            return Object.keys(groups)
+                .sort(function (a, b) { return a.localeCompare(b); })
+                .map(function (name) {
+                    return {
+                        label: name,
+                        fields: groups[name].sort(function (a, b) {
+                            return String(a.path).localeCompare(String(b.path));
+                        })
+                    };
+                });
+        }
+
+        function renderFieldList(items, selectedFields) {
+            const $container = $("#node-victron-read-field-list-container").empty();
+            const selected = new Set(normalizePayloadFields(selectedFields).filter(function (field) {
+                return field !== "full";
+            }));
+
+            if (!Array.isArray(items) || !items.length) {
+                $container.append('<div class="vr-inline-note">Nu s-au detectat campuri pentru sursa curenta. Pentru MQTT, verifica deploy + mesaje primite.</div>');
+                return;
+            }
+
+            const groups = groupFields(items);
+
+            groups.forEach(function (group) {
+                const $group = $('<div class="vr-field-group"></div>');
+                const $title = $('<p class="vr-field-group-title"></p>').text(group.label);
+                const $grid = $('<div class="vr-field-group-grid"></div>');
+
+                group.fields.forEach(function (item) {
+                    const path = String(item.path || "");
+                    const checkboxId = "victron-read-field-" + path.replace(/[^a-zA-Z0-9_]/g, "_");
+                    const $checkbox = $('<input type="checkbox" class="vr-field-checkbox">')
+                        .attr("id", checkboxId)
+                        .attr("data-field", path)
+                        .prop("checked", selected.has(path));
+
+                    const $label = $('<label class="vr-field-item"></label>')
+                        .attr("for", checkboxId)
+                        .append($checkbox)
+                        .append($('<span></span>').text(path));
+
+                    const type = String(item.type || "").trim();
+                    if (type) {
+                        $label.append($('<span class="vr-field-meta"></span>').text(type));
+                    }
+
+                    $grid.append($label);
+                });
+
+                $group.append($title).append($grid);
+                $container.append($group);
+            });
+        }
+
+        function readSelectedFields() {
+            const payloadMode = String($("#node-input-payloadMode").val() || "full");
+            if (payloadMode !== "selected") {
+                return ["full"];
+            }
+
+            const selected = [];
+            $("#node-victron-read-field-list-container .vr-field-checkbox:checked").each(function () {
+                selected.push(String($(this).attr("data-field") || "").trim());
+            });
+
+            return Array.from(new Set(selected));
+        }
+
+        function updatePayloadModeUi() {
+            const payloadMode = String($("#node-input-payloadMode").val() || "full");
+            $("#row-victron-read-field-list").toggle(payloadMode === "selected");
+        }
+
+        function updateSourceUi() {
+            const sourceType = String($("#node-input-sourceType").val() || "global");
+            const isGlobal = sourceType === "global";
+
+            $("#row-victron-global-variable").toggle(isGlobal);
+            $("#row-victron-global-path").toggle(isGlobal);
+
+            $("#row-victron-mqtt-url").toggle(!isGlobal);
+            $("#row-victron-mqtt-topic").toggle(!isGlobal);
+            $("#row-victron-mqtt-topic-qos").toggle(!isGlobal);
+            $("#row-victron-mqtt-auth").toggle(!isGlobal);
+            $("#row-victron-mqtt-auth-pass").toggle(!isGlobal);
+            $("#row-victron-mqtt-client-id").toggle(!isGlobal);
+            $("#row-victron-mqtt-path").toggle(!isGlobal);
+            $("#row-victron-mqtt-root-path").toggle(false);
+            $("#row-victron-mqtt-flags").toggle(!isGlobal);
+            $("#row-victron-mqtt-portal-id").toggle(!isGlobal);
+            $("#row-victron-mqtt-keepalive").toggle(!isGlobal);
+            $("#row-victron-mqtt-freshness").toggle(!isGlobal);
+            $("#row-victron-mqtt-discover").toggle(!isGlobal);
+        }
+
+        function readNodeIdForEndpoint(node) {
+            const id = String((node && node.id) || "").trim();
+            if (!id || id === "_ADD_") {
+                return "";
+            }
+            return "/" + encodeURIComponent(id);
+        }
+
+        RED.nodes.registerType("victron-read", {
+            category: "Atelierul de Tehnologii",
+            color: "#9cc4ff",
+            defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+                name: { value: "" },
+                sourceType: { value: "mqtt" },
+                globalVariable: { value: "victron", required: true },
+                globalPath: { value: "" },
+
+                mqttUrl: { value: "mqtt://127.0.0.1:1883", required: true },
+                mqttTopicFilter: { value: "N/#", required: true },
+                mqttQos: { value: 0, required: true, validate: RED.validators.number() },
+                mqttClientId: { value: "" },
+                mqttUsername: { value: "root" },
+                mqttTopicPathMode: { value: "victron" },
+                mqttStripPortalId: { value: true },
+                mqttRootPath: { value: "" },
+                mqttPortalId: { value: "" },
+                mqttKeepaliveEnabled: { value: true },
+                mqttKeepaliveInterval: { value: 30000, required: true, validate: RED.validators.number() },
+                mqttStaleAfter: { value: 120000, required: true, validate: RED.validators.number() },
+                emitOnlyChanges: { value: true },
+                expertMode: { value: false },
+                includeFieldTokens: { value: "" },
+                excludeFieldTokens: { value: ".serial,.id,.name,.rawvalue,.seqno,.heartbeat,.diagnostics,.leds,.timelastcontact" },
+                onlyNumericFields: { value: true },
+                maxFields: { value: 150, required: true, validate: RED.validators.number() },
+
+                pollInterval: {
+                    value: 5000,
+                    required: true,
+                    validate: function (value) {
+                        const text = String(value || "").trim().toLowerCase();
+                        if (text === "off") return true;
+                        const n = Number(text);
+                        return Number.isFinite(n) && n >= 0;
+                    }
+                },
+                payloadMode: { value: "default" },
+                payloadFields: { value: ["full"] },
+                deviceId: { value: "victron", required: true },
+                topic: { value: "" },
+                influxMeasurement: { value: "victron" }
+            },
+            credentials: {
+                mqttPassword: { type: "password" }
+            },
+            inputs: 0,
+            outputs: 1,
+            icon: "font-awesome/fa-bolt",
+            label: function () {
+                return this.name || this.deviceId || "victron-read";
+            },
+            oneditprepare: function () {
+                const node = this;
+                const initialFields = normalizePayloadFields(node.payloadFields || ["full"]);
+                const initialMode = ["default", "full", "selected"].includes(node.payloadMode)
+                    ? node.payloadMode
+                    : (initialFields.includes("full") ? "default" : "selected");
+                // Extended field selection is session-only and must always start OFF on reopen.
+                let expertModeUnlocked = false;
+                let mqttDiscoveryReady = false;
+                let selectAllLongPressTimer = null;
+                let selectAllLongPressTriggered = false;
+                let lastLoadedFields = [];
+                let visibleFieldPathSet = new Set();
+
+                $("#node-input-payloadMode").val(initialMode);
+                updatePayloadModeUi();
+                updateSourceUi();
+                syncMqttRootPathVisibility();
+                renderFieldList([], initialFields);
+
+                function syncInputs() {
+                    const text = String($("#node-input-pollInterval").val() || "").trim().toLowerCase();
+                    node.inputs = text === "off" || text === "0" ? 1 : 0;
+                }
+                $("#node-input-pollInterval").off(".victronReadPoll").on("keyup.victronReadPoll change.victronReadPoll", syncInputs);
+                syncInputs();
+
+                (function seedRootSelectFromSavedValue() {
+                    const savedRoot = String(node.mqttRootPath || "").trim();
+                    if (!savedRoot) return;
+                    const $root = $("#node-input-mqttRootPath");
+                    const hasOption = $root.find("option").filter(function () {
+                        return String($(this).attr("value") || "") === savedRoot;
+                    }).length > 0;
+                    if (!hasOption) {
+                        $root.append($("<option></option>").attr("value", savedRoot).text(savedRoot));
+                    }
+                    $root.val(savedRoot);
+                })();
+
+                function setLoadStatus(text, isError) {
+                    const $status = $("#node-victron-read-load-status");
+                    $status.text(text || "");
+                    $status.css("color", isError ? "#b42318" : "#667085");
+                }
+
+                function ensureDefaultInputValue(selector, fallback) {
+                    const $el = $(selector);
+                    if (!$el.length) return;
+                    const current = String($el.val() || "").trim();
+                    if (!current) {
+                        $el.val(String(fallback || ""));
+                    }
+                }
+
+                function syncMqttRootPathVisibility() {
+                    const sourceType = String($("#node-input-sourceType").val() || "global");
+                    const isMqtt = sourceType === "mqtt";
+                    $("#row-victron-mqtt-root-path").toggle(isMqtt && mqttDiscoveryReady);
+                }
+
+                function setMqttDiscoveryReady(value) {
+                    mqttDiscoveryReady = !!value;
+                    syncMqttRootPathVisibility();
+                }
+
+                function clearSelectAllLongPressTimer() {
+                    if (selectAllLongPressTimer) {
+                        clearTimeout(selectAllLongPressTimer);
+                        selectAllLongPressTimer = null;
+                    }
+                }
+
+                function getVisibleFields(items) {
+                    const list = Array.isArray(items) ? items : [];
+                    if (expertModeUnlocked) {
+                        return list;
+                    }
+                    return list.filter(function (item) {
+                        return isBasicFieldPath(item && item.path);
+                    });
+                }
+
+                function getCurrentMqttSettings() {
+                    return {
+                        nodeId: String((node && node.id) || "").trim(),
+                        mqttUrl: String($("#node-input-mqttUrl").val() || "").trim(),
+                        mqttTopicFilter: String($("#node-input-mqttTopicFilter").val() || "").trim(),
+                        mqttQos: Number($("#node-input-mqttQos").val() || 0),
+                        mqttClientId: String($("#node-input-mqttClientId").val() || "").trim(),
+                        mqttUsername: String($("#node-input-mqttUsername").val() || "").trim(),
+                        mqttPassword: String($("#node-input-mqttPassword").val() || ""),
+                        mqttTopicPathMode: String($("#node-input-mqttTopicPathMode").val() || "victron"),
+                        mqttStripPortalId: !!$("#node-input-mqttStripPortalId").is(":checked"),
+                        mqttRootPath: String($("#node-input-mqttRootPath").val() || "").trim(),
+                        mqttPortalId: String($("#node-input-mqttPortalId").val() || "").trim(),
+                        timeoutMs: 5000
+                    };
+                }
+
+                function updateMqttRootPathOptions(roots, preserveValue) {
+                    const $select = $("#node-input-mqttRootPath");
+                    const previousValue = String(
+                        preserveValue !== undefined
+                            ? preserveValue
+                            : ($select.val() || "")
+                    ).trim();
+
+                    $select.empty();
+                    $select.append($("<option></option>").attr("value", "").text("All roots"));
+
+                    (Array.isArray(roots) ? roots : []).forEach(function (root) {
+                        const value = String(root || "").trim();
+                        if (!value) return;
+                        $select.append($("<option></option>").attr("value", value).text(value));
+                    });
+
+                    $select.val(previousValue);
+                    if ($select.val() !== previousValue) {
+                        $select.val("");
+                    }
+                }
+
+                function discoverMqttData(done) {
+                    const settings = getCurrentMqttSettings();
+                    if (!settings.mqttUrl) {
+                        setLoadStatus("Completeaza MQTT URL.", true);
+                        setMqttDiscoveryReady(false);
+                        if (typeof done === "function") done(new Error("missing_mqtt_url"));
+                        return;
+                    }
+
+                    setLoadStatus("Conectare MQTT si descoperire campuri...", false);
+
+                    $.ajax({
+                        url: "victron-read/discover-mqtt",
+                        method: "POST",
+                        contentType: "application/json",
+                        data: JSON.stringify(settings),
+                        dataType: "json",
+                        timeout: 9000
+                    }).done(function (response) {
+                        if (!response || !response.ok) {
+                            setLoadStatus((response && response.error) || "Nu s-a putut stabili conexiunea MQTT.", true);
+                            setMqttDiscoveryReady(false);
+                            if (typeof done === "function") done(new Error((response && response.error) || "discover_failed"));
+                            return;
+                        }
+
+                        setMqttDiscoveryReady(true);
+                        if (response.portalId && !String($("#node-input-mqttPortalId").val() || "").trim()) {
+                            $("#node-input-mqttPortalId").val(response.portalId);
+                        }
+                        updateMqttRootPathOptions(response.roots || [], settings.mqttRootPath);
+                        if (typeof done === "function") done(null, response);
+                    }).fail(function (xhr) {
+                        const message = (xhr && xhr.responseJSON && xhr.responseJSON.error)
+                            ? xhr.responseJSON.error
+                            : "Eroare la conectarea MQTT.";
+                        setLoadStatus(message, true);
+                        setMqttDiscoveryReady(false);
+                        if (typeof done === "function") done(new Error(message));
+                    });
+                }
+
+                function loadFields() {
+                    const sourceType = String($("#node-input-sourceType").val() || "global");
+                    const globalVar = String($("#node-input-globalVariable").val() || "").trim();
+                    const globalPath = String($("#node-input-globalPath").val() || "").trim();
+                    const mqttRootPath = String($("#node-input-mqttRootPath").val() || "").trim();
+
+                    if (sourceType === "global" && !globalVar) {
+                        setLoadStatus("Completeaza mai intai Global variable.", true);
+                        renderFieldList([], readSelectedFields());
+                        return;
+                    }
+
+                    function renderFromResponse(response) {
+                        if (!response || !response.ok) {
+                            setLoadStatus((response && response.error) || "Nu s-au putut incarca campurile.", true);
+                            if (sourceType === "mqtt") {
+                                setMqttDiscoveryReady(false);
+                            }
+                            renderFieldList([], readSelectedFields());
+                            return;
+                        }
+
+                        const selected = normalizePayloadFields(readSelectedFields());
+                        lastLoadedFields = Array.isArray(response.fields) ? response.fields.slice() : [];
+                        if (sourceType === "mqtt") {
+                            const roots = Array.isArray(response.roots) ? response.roots : [];
+                            if (response.portalId && !String($("#node-input-mqttPortalId").val() || "").trim()) {
+                                $("#node-input-mqttPortalId").val(response.portalId);
+                            }
+                            const mqttReady = roots.length > 0 || lastLoadedFields.length > 0;
+                            setMqttDiscoveryReady(mqttReady);
+                            updateMqttRootPathOptions(roots, mqttRootPath);
+                        }
+                        const visibleFields = getVisibleFields(lastLoadedFields);
+                        visibleFieldPathSet = new Set(visibleFields.map(function (item) { return String(item.path || ""); }));
+                        node.__victronVisibleFieldPathSet = visibleFieldPathSet;
+                        renderFieldList(visibleFields, selected);
+                        setLoadStatus(
+                            "Campuri afisate: " + String(visibleFields.length) +
+                            " / " + String(lastLoadedFields.length) +
+                            (expertModeUnlocked ? " (expert)" : " (basic)")
+                        , false);
+                    }
+
+                    if (sourceType === "mqtt") {
+                        setLoadStatus("Se incarca campurile MQTT din runtime...", false);
+                        const runtimeEndpoint = "victron-read/fields" + readNodeIdForEndpoint(node);
+                        $.getJSON(runtimeEndpoint, {
+                            sourceType: "mqtt",
+                            mqttRootPath: mqttRootPath
+                        }).done(function (runtimeResponse) {
+                            if (runtimeResponse && runtimeResponse.ok) {
+                                renderFromResponse(runtimeResponse);
+                                return;
+                            }
+
+                            setMqttDiscoveryReady(false);
+                            setLoadStatus(
+                                (runtimeResponse && runtimeResponse.error)
+                                    ? runtimeResponse.error
+                                    : "Nu s-au detectat campuri MQTT. Apasa Connect & Discover.",
+                                true
+                            );
+                            renderFieldList([], readSelectedFields());
+                        }).fail(function () {
+                            setMqttDiscoveryReady(false);
+                            setLoadStatus("Eroare la citirea campurilor MQTT. Apasa Connect & Discover.", true);
+                            renderFieldList([], readSelectedFields());
+                        });
+                        return;
+                    }
+
+                    setLoadStatus("Se incarca campurile disponibile...", false);
+                    const endpoint = "victron-read/fields" + readNodeIdForEndpoint(node);
+                    const params = {
+                        sourceType: sourceType,
+                        globalVar: globalVar,
+                        globalPath: globalPath
+                    };
+
+                    $.getJSON(endpoint, params)
+                        .done(renderFromResponse)
+                        .fail(function (xhr) {
+                            const message = (xhr && xhr.responseJSON && xhr.responseJSON.error)
+                                ? xhr.responseJSON.error
+                                : "Eroare la citirea campurilor.";
+                            setLoadStatus(message, true);
+                        });
+                }
+
+                $("#node-input-sourceType").off(".victronRead").on("change.victronRead", function () {
+                    if (String($("#node-input-sourceType").val() || "global") === "mqtt") {
+                        setMqttDiscoveryReady(false);
+                    }
+                    updateSourceUi();
+                    syncMqttRootPathVisibility();
+                    setLoadStatus("Sursa modificata. Apasa Refresh fields.", false);
+                });
+
+                $("#node-input-payloadMode").off(".victronRead").on("change.victronRead", updatePayloadModeUi);
+
+                $("#node-victron-read-refresh-fields").off(".victronRead").on("click.victronRead", function (event) {
+                    event.preventDefault();
+                    loadFields();
+                });
+
+                $("#node-victron-read-discover-mqtt").off(".victronRead").on("click.victronRead", function (event) {
+                    event.preventDefault();
+                    const runtimeEndpoint = "victron-read/fields" + readNodeIdForEndpoint(node);
+                    const mqttRootPath = String($("#node-input-mqttRootPath").val() || "").trim();
+
+                    $.getJSON(runtimeEndpoint, {
+                        sourceType: "mqtt",
+                        mqttRootPath: mqttRootPath
+                    }).done(function (runtimeResponse) {
+                        if (runtimeResponse && runtimeResponse.ok && (Number(runtimeResponse.count || 0) > 0 || (runtimeResponse.roots || []).length > 0)) {
+                            setMqttDiscoveryReady(true);
+                            updateMqttRootPathOptions(runtimeResponse.roots || [], mqttRootPath);
+                            const selected = normalizePayloadFields(readSelectedFields());
+                            lastLoadedFields = Array.isArray(runtimeResponse.fields) ? runtimeResponse.fields.slice() : [];
+                            const visibleFields = getVisibleFields(lastLoadedFields);
+                            visibleFieldPathSet = new Set(visibleFields.map(function (item) { return String(item.path || ""); }));
+                            node.__victronVisibleFieldPathSet = visibleFieldPathSet;
+                            renderFieldList(visibleFields, selected);
+                            setLoadStatus(
+                                "Conectat (runtime). Campuri afisate: " +
+                                String(visibleFields.length) + " / " + String(lastLoadedFields.length),
+                                false
+                            );
+                            return;
+                        }
+
+                        discoverMqttData(function (err, response) {
+                            if (err) {
+                                return;
+                            }
+                            const selected = normalizePayloadFields(readSelectedFields());
+                            lastLoadedFields = Array.isArray(response.fields) ? response.fields.slice() : [];
+                            const visibleFields = getVisibleFields(lastLoadedFields);
+                            visibleFieldPathSet = new Set(visibleFields.map(function (item) { return String(item.path || ""); }));
+                            node.__victronVisibleFieldPathSet = visibleFieldPathSet;
+                            renderFieldList(visibleFields, selected);
+                            setLoadStatus(
+                                "Conectat. Mesaje: " + String(response.messages || 0) + ". Campuri afisate: " +
+                                String(visibleFields.length) + " / " + String(lastLoadedFields.length),
+                                false
+                            );
+                        });
+                    }).fail(function () {
+                        discoverMqttData(function (err, response) {
+                            if (err) {
+                                return;
+                            }
+                            const selected = normalizePayloadFields(readSelectedFields());
+                            lastLoadedFields = Array.isArray(response.fields) ? response.fields.slice() : [];
+                            const visibleFields = getVisibleFields(lastLoadedFields);
+                            visibleFieldPathSet = new Set(visibleFields.map(function (item) { return String(item.path || ""); }));
+                            node.__victronVisibleFieldPathSet = visibleFieldPathSet;
+                            renderFieldList(visibleFields, selected);
+                            setLoadStatus(
+                                "Conectat. Mesaje: " + String(response.messages || 0) + ". Campuri afisate: " +
+                                String(visibleFields.length) + " / " + String(lastLoadedFields.length),
+                                false
+                            );
+                        });
+                    });
+                });
+
+                $("#node-victron-read-select-all")
+                    .off(".victronRead")
+                    .on("mousedown.victronRead touchstart.victronRead", function () {
+                        if ($("#node-input-payloadMode").val() !== "selected") {
+                            return;
+                        }
+
+                        selectAllLongPressTriggered = false;
+                        clearSelectAllLongPressTimer();
+                        selectAllLongPressTimer = setTimeout(function () {
+                            expertModeUnlocked = true;
+                            selectAllLongPressTriggered = true;
+                            const selected = normalizePayloadFields(readSelectedFields());
+                            const visibleFields = getVisibleFields(lastLoadedFields);
+                            visibleFieldPathSet = new Set(visibleFields.map(function (item) { return String(item.path || ""); }));
+                            node.__victronVisibleFieldPathSet = visibleFieldPathSet;
+                            renderFieldList(visibleFields, selected);
+                            if (RED && RED.notify) {
+                                RED.notify("Selectia extinsa a fost activata.", "success");
+                            }
+                        }, SPECIAL_EXPERT_LONG_PRESS_MS);
+                    })
+                    .on("mouseup.victronRead mouseleave.victronRead touchend.victronRead touchcancel.victronRead", function () {
+                        clearSelectAllLongPressTimer();
+                    })
+                    .on("click.victronRead", function (event) {
+                        if (selectAllLongPressTriggered) {
+                            event.preventDefault();
+                            event.stopImmediatePropagation();
+                            selectAllLongPressTriggered = false;
+                            return;
+                        }
+                        event.preventDefault();
+                        $("#node-victron-read-field-list-container .vr-field-checkbox").prop("checked", true);
+                    });
+
+                $("#node-victron-read-clear-all").off(".victronRead").on("click.victronRead", function (event) {
+                    event.preventDefault();
+                    $("#node-victron-read-field-list-container .vr-field-checkbox").prop("checked", false);
+                });
+
+                $("#node-input-mqttRootPath").off(".victronRead").on("change.victronRead", function () {
+                    if (String($("#node-input-sourceType").val() || "global") !== "mqtt") {
+                        return;
+                    }
+                    loadFields();
+                });
+
+                $("#node-input-globalVariable, #node-input-globalPath")
+                    .off(".victronRead")
+                    .on("change.victronRead keyup.victronRead", function () {
+                        setLoadStatus("Apasa Refresh fields pentru a reincarca lista.", false);
+                    });
+
+                ensureDefaultInputValue("#node-input-mqttUrl", "mqtt://127.0.0.1:1883");
+                ensureDefaultInputValue("#node-input-mqttTopicFilter", "N/#");
+                ensureDefaultInputValue("#node-input-mqttQos", "0");
+                ensureDefaultInputValue("#node-input-mqttUsername", "root");
+                ensureDefaultInputValue("#node-input-mqttKeepaliveInterval", "30000");
+                ensureDefaultInputValue("#node-input-mqttStaleAfter", "120000");
+                ensureDefaultInputValue("#node-input-deviceId", "victron");
+                ensureDefaultInputValue("#node-input-influxMeasurement", "victron");
+                ensureDefaultInputValue("#node-input-maxFields", "150");
+
+                setMqttDiscoveryReady(false);
+                loadFields();
+
+                node.__victronVisibleFieldPathSet = visibleFieldPathSet;
+            },
+            oneditsave: function () {
+                const selectedNow = normalizePayloadFields(readSelectedFields());
+                const payloadMode = String($("#node-input-payloadMode").val() || "full");
+                const previousSaved = normalizePayloadFields(this.payloadFields || ["full"]);
+                const visibleSet = this.__victronVisibleFieldPathSet instanceof Set
+                    ? this.__victronVisibleFieldPathSet
+                    : new Set();
+
+                if (payloadMode !== "selected") {
+                    this.payloadFields = ["full"];
+                } else {
+                    const visibleSelected = selectedNow.filter(function (field) {
+                        return field !== "full";
+                    });
+
+                    const hiddenPreviouslySelected = previousSaved.filter(function (field) {
+                        return field !== "full" && !visibleSet.has(field);
+                    });
+
+                    const merged = Array.from(new Set(visibleSelected.concat(hiddenPreviouslySelected)));
+                    this.payloadFields = merged;
+                }
+
+                // Extended field selection is always session-only and resets on Done/Deploy.
+                this.expertMode = false;
+                const pollText = String($("#node-input-pollInterval").val() || "").trim().toLowerCase();
+                this.inputs = pollText === "off" || pollText === "0" ? 1 : 0;
+                delete this.__victronVisibleFieldPathSet;
+            },
+            oneditcancel: function () {
+                $("#node-input-sourceType").off(".victronRead");
+                $("#node-input-payloadMode").off(".victronRead");
+                $("#node-victron-read-refresh-fields").off(".victronRead");
+                $("#node-victron-read-discover-mqtt").off(".victronRead");
+                $("#node-victron-read-select-all").off(".victronRead");
+                $("#node-victron-read-clear-all").off(".victronRead");
+                $("#node-input-mqttRootPath").off(".victronRead");
+                $("#node-input-globalVariable, #node-input-globalPath").off(".victronRead");
+                delete this.__victronVisibleFieldPathSet;
+            }
+        });
+    })();
+</script>
+
+<script type="text/html" data-template-name="victron-read">
+    <div class="form-row"><label for="node-input-license"><i class="fa fa-key"></i> License</label><input type="text" id="node-input-license"></div>
+    <div class="victron-read-editor">
+        <div class="vr-section">
+            <div class="vr-section-title"><i class="fa fa-sign-in"></i> Source</div>
+            <p class="vr-section-note">Poti citi din MQTT Victron (recomandat) sau din variabila globala existenta.</p>
+
+            <div class="form-row">
+                <label for="node-input-sourceType"><i class="fa fa-random"></i> Source type</label>
+                <select id="node-input-sourceType">
+                    <option value="mqtt">MQTT (Victron)</option>
+                    <option value="global">Global variable</option>
+                </select>
+            </div>
+
+            <div class="vr-grid">
+                <div class="form-row">
+                    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+                    <input type="text" id="node-input-name" placeholder="victron-read">
+                </div>
+
+                <div class="form-row" id="row-victron-global-variable">
+                    <label for="node-input-globalVariable"><i class="fa fa-globe"></i> Global variable</label>
+                    <input type="text" id="node-input-globalVariable" placeholder="victron">
+                </div>
+
+                <div class="form-row" id="row-victron-global-path">
+                    <label for="node-input-globalPath"><i class="fa fa-sitemap"></i> Global path (optional)</label>
+                    <input type="text" id="node-input-globalPath" placeholder="telemetry">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-url">
+                    <label for="node-input-mqttUrl"><i class="fa fa-plug"></i> MQTT URL</label>
+                    <input type="text" id="node-input-mqttUrl" placeholder="mqtt://127.0.0.1:1883">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-topic">
+                    <label for="node-input-mqttTopicFilter"><i class="fa fa-filter"></i> Topic filter</label>
+                    <input type="text" id="node-input-mqttTopicFilter" placeholder="N/#">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-topic-qos">
+                    <label for="node-input-mqttQos"><i class="fa fa-sort-numeric-asc"></i> MQTT QoS</label>
+                    <input type="text" id="node-input-mqttQos" placeholder="0">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-auth">
+                    <label for="node-input-mqttUsername"><i class="fa fa-user"></i> MQTT user</label>
+                    <input type="text" id="node-input-mqttUsername" placeholder="root">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-auth-pass">
+                    <label for="node-input-mqttPassword"><i class="fa fa-lock"></i> MQTT password</label>
+                    <input type="password" id="node-input-mqttPassword" placeholder="optional">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-client-id">
+                    <label for="node-input-mqttClientId"><i class="fa fa-id-badge"></i> MQTT client id</label>
+                    <input type="text" id="node-input-mqttClientId" placeholder="optional">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-portal-id">
+                    <label for="node-input-mqttPortalId"><i class="fa fa-key"></i> Portal ID</label>
+                    <input type="text" id="node-input-mqttPortalId" placeholder="detectat automat sau introdus manual">
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-path">
+                    <label for="node-input-mqttTopicPathMode"><i class="fa fa-sitemap"></i> Topic path mode</label>
+                    <select id="node-input-mqttTopicPathMode">
+                        <option value="victron">Victron (fara prefix/topic id)</option>
+                        <option value="raw">Raw (topic complet)</option>
+                    </select>
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-root-path">
+                    <label for="node-input-mqttRootPath"><i class="fa fa-folder-open"></i> MQTT root path</label>
+                    <select id="node-input-mqttRootPath">
+                        <option value="">All roots</option>
+                    </select>
+                </div>
+
+                <div class="form-row" id="row-victron-mqtt-freshness">
+                    <label for="node-input-mqttStaleAfter"><i class="fa fa-clock-o"></i> Stale after (ms)</label>
+                    <input type="text" id="node-input-mqttStaleAfter" placeholder="120000">
+                </div>
+            </div>
+
+            <div class="form-row vr-checkbox-row" id="row-victron-mqtt-flags">
+                <label for="node-input-mqttStripPortalId"><i class="fa fa-scissors"></i> MQTT options</label>
+                <input type="checkbox" id="node-input-mqttStripPortalId">
+                <span class="vr-inline-note">Elimina portal id din calea topicului (cand mode = Victron).</span>
+            </div>
+
+            <div class="form-row vr-checkbox-row" id="row-victron-mqtt-keepalive">
+                <label for="node-input-mqttKeepaliveEnabled"><i class="fa fa-heartbeat"></i> Victron keepalive</label>
+                <input type="checkbox" id="node-input-mqttKeepaliveEnabled">
+                <span class="vr-inline-note">Publica periodic <code>R/&lt;Portal ID&gt;/keepalive</code>.</span>
+                <input type="text" id="node-input-mqttKeepaliveInterval" style="width:110px; margin-left:8px;" placeholder="30000">
+                <span class="vr-inline-note">ms</span>
+            </div>
+
+            <div class="form-row" id="row-victron-mqtt-discover">
+                <label></label>
+                <button type="button" class="red-ui-button" id="node-victron-read-discover-mqtt"><i class="fa fa-link"></i> Connect & Discover</button>
+                <span class="vr-inline-note">Se conecteaza la broker cu setarile de mai sus si populeaza automat root path + campuri.</span>
+            </div>
+        </div>
+
+        <div class="vr-section">
+            <div class="vr-section-title"><i class="fa fa-line-chart"></i> Influx Mapping</div>
+            <p class="vr-section-note">Format output: <code>msg.influx.measurement</code>, <code>msg.influx.tags</code>, <code>msg.influx.fields</code>, <code>msg.influx.timestamp</code>.</p>
+
+            <div class="vr-grid">
+                <div class="form-row">
+                    <label for="node-input-deviceId"><i class="fa fa-id-badge"></i> Device ID</label>
+                    <input type="text" id="node-input-deviceId" placeholder="victron">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-topic"><i class="fa fa-comment"></i> Topic (optional)</label>
+                    <input type="text" id="node-input-topic" placeholder="victron">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-influxMeasurement"><i class="fa fa-area-chart"></i> Measurement</label>
+                    <input type="text" id="node-input-influxMeasurement" placeholder="victron">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-pollInterval"><i class="fa fa-refresh"></i> Poll interval</label>
+                    <input type="text" id="node-input-pollInterval" placeholder="5000 sau off">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-payloadMode"><i class="fa fa-list"></i> Payload mode</label>
+                    <select id="node-input-payloadMode">
+                        <option value="default">Default operational</option>
+                        <option value="full">Full payload (nefiltrat)</option>
+                        <option value="selected">Selected fields</option>
+                    </select>
+                </div>
+            </div>
+
+            <div class="vr-grid" style="margin-top:12px;">
+                <div class="form-row">
+                    <label for="node-input-includeFieldTokens"><i class="fa fa-plus-circle"></i> Include tokens</label>
+                    <input type="text" id="node-input-includeFieldTokens" placeholder="ex: .dc.,.ac.,battery.,grid.,vebus.">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-excludeFieldTokens"><i class="fa fa-minus-circle"></i> Exclude tokens</label>
+                    <input type="text" id="node-input-excludeFieldTokens" placeholder=".serial,.id,.name,.heartbeat">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-maxFields"><i class="fa fa-compress"></i> Max fields/msg</label>
+                    <input type="text" id="node-input-maxFields" placeholder="150">
+                </div>
+            </div>
+
+            <div class="form-row vr-checkbox-row">
+                <label for="node-input-onlyNumericFields"><i class="fa fa-hashtag"></i> Numeric only</label>
+                <input type="checkbox" id="node-input-onlyNumericFields">
+                <span class="vr-inline-note">Aplicat profilului Default operational.</span>
+            </div>
+
+            <div class="form-row vr-checkbox-row">
+                <label for="node-input-emitOnlyChanges"><i class="fa fa-exchange"></i> Changes only</label>
+                <input type="checkbox" id="node-input-emitOnlyChanges">
+                <span class="vr-inline-note">Emite imediat la modificări și evită mesajele identice.</span>
+            </div>
+        </div>
+
+        <div class="vr-section" id="row-victron-read-field-list" style="display:none;">
+            <div class="vr-section-title"><i class="fa fa-filter"></i> Select Fields</div>
+            <p class="vr-section-note">Apasa <b>Refresh fields</b>. In modul normal vezi valorile de baza.</p>
+
+            <div class="vr-toolbar">
+                <button type="button" class="red-ui-button" id="node-victron-read-refresh-fields"><i class="fa fa-refresh"></i> Refresh fields</button>
+                <button type="button" class="red-ui-button" id="node-victron-read-select-all"><i class="fa fa-check-square-o"></i> Select all</button>
+                <button type="button" class="red-ui-button" id="node-victron-read-clear-all"><i class="fa fa-square-o"></i> Clear</button>
+            </div>
+
+            <div class="vr-load-status" id="node-victron-read-load-status"></div>
+            <div id="node-victron-read-field-list-container" class="vr-field-list"></div>
+        </div>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="victron-read">
+    <p>Nodul <b>victron-read</b> poate citi direct din MQTT Victron sau dintr-o variabila globala si emite date pregatite pentru <code>adt-influxdb</code>.</p>
+    <ul>
+        <li><b>MQTT source</b> foloseste keepalive Victron pentru a solicita si mentine telemetria completa.</li>
+        <li><b>Portal ID</b> poate fi introdus manual sau detectat automat din topicurile primite.</li>
+        <li><b>Default operational</b> aplica filtrele de trafic; <b>Full</b> trimite toate campurile; <b>Selected</b> trimite strict valorile bifate.</li>
+        <li><b>Stale after</b> elimina valorile MQTT care nu au mai fost actualizate, prevenind transmiterea datelor vechi.</li>
+        <li>Pentru selectia campurilor pe MQTT, fa deploy, asteapta mesaje, apoi <b>Refresh fields</b>.</li>
+    </ul>
+
+    <h3>Referinta completa parametri</h3>
+    <ul>
+        <li><code>sourceType</code>: <code>global</code> sau <code>mqtt</code>.</li>
+        <li><code>globalVariable</code> si <code>globalPath</code>: sursa cand se citeste din context global.</li>
+        <li><code>mqttUrl</code>, <code>mqttTopicFilter</code>, <code>mqttQos</code>, <code>mqttClientId</code>, <code>mqttUsername</code>, <code>mqttPassword</code>: conexiunea MQTT.</li>
+        <li><code>mqttTopicPathMode</code>: modul in care topicul MQTT este convertit in cale de payload.</li>
+        <li><code>mqttStripPortalId</code>: elimina portal ID-ul din calea rezultata.</li>
+        <li><code>mqttRootPath</code>: prefixul radacina pentru datele MQTT mapate.</li>
+        <li><code>mqttPortalId</code>: portal ID Victron, manual sau autodetectat.</li>
+        <li><code>mqttKeepaliveEnabled</code> si <code>mqttKeepaliveInterval</code>: mentin fluxul MQTT Victron activ.</li>
+        <li><code>mqttStaleAfter</code>: elimina campuri MQTT care nu au mai fost actualizate.</li>
+        <li><code>emitOnlyChanges</code>: emite doar cand apar modificari.</li>
+        <li><code>includeFieldTokens</code> si <code>excludeFieldTokens</code>: filtre text pentru campurile emise.</li>
+        <li><code>onlyNumericFields</code>: pastreaza doar valori numerice in profilul operational.</li>
+        <li><code>maxFields</code>: limiteaza numarul de campuri per mesaj.</li>
+        <li><code>pollInterval</code>: intervalul de emitere pentru sursa globala sau snapshot MQTT. Valoarea <code>off</code> sau <code>0</code> opreste emiterea periodica si activeaza intrarea pentru trigger manual.</li>
+        <li><code>payloadMode</code>: <code>default</code>, <code>full</code> sau <code>selected</code>.</li>
+        <li><code>payloadFields</code>: lista campurilor selectate.</li>
+        <li><code>deviceId</code>: ID-ul dispozitivului inclus in topic/tag-uri.</li>
+        <li><code>topic</code>: topic-ul de iesire configurat manual.</li>
+        <li><code>influxMeasurement</code>: measurement-ul folosit pentru <code>msg.influx</code>.</li>
+    </ul>
+
+    <h3>Exemplu MQTT operational</h3>
+    <pre>{
+  "topic": "victron/site",
+  "payload": {
+    "battery.soc": 72.4,
+    "grid.power_w": 1300,
+    "pv.power_w": 6400
+  }
+}</pre>
+</script>
+