@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/janitza/janitza.html

@@ -0,0 +1,2562 @@
+<style>
+
+    .janitza-editor {
+
+        --pr-border: #d7dde5;
+
+        --pr-muted: #667085;
+
+        --pr-surface: #f8fafc;
+
+    }
+
+
+    .janitza-editor .pr-section {
+
+        margin: 0 0 18px;
+
+        padding: 14px 16px 16px;
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 8px;
+
+        background: var(--pr-surface);
+
+    }
+
+
+    .janitza-editor .pr-section-title {
+
+        display: flex;
+
+        align-items: center;
+
+        gap: 8px;
+
+        margin: 0 0 4px;
+
+        font-size: 15px;
+
+        font-weight: 600;
+
+        color: #243447;
+
+    }
+
+
+    .janitza-editor .pr-section-note {
+
+        margin: 0 0 14px;
+
+        color: var(--pr-muted);
+
+        font-size: 12px;
+
+        line-height: 1.45;
+
+    }
+
+
+    .janitza-editor .pr-grid {
+
+        display: grid;
+
+        grid-template-columns: repeat(auto-fit, minmax(230px, 1fr));
+
+        gap: 12px 16px;
+
+    }
+
+
+    .janitza-editor .form-row {
+
+        margin-bottom: 12px;
+
+    }
+
+
+    .janitza-editor .pr-grid .form-row,
+
+    .janitza-editor .form-row:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .janitza-editor .form-row > label {
+
+        width: 150px;
+
+        font-weight: 600;
+
+    }
+
+
+    .janitza-editor .form-row > input[type="text"],
+
+    .janitza-editor .form-row > input[type="number"],
+
+    .janitza-editor .form-row > select {
+
+        width: calc(100% - 160px);
+
+    }
+
+
+    .janitza-editor .pr-checkbox-row > input[type="checkbox"] {
+
+        display: inline-block;
+
+        width: auto;
+
+        vertical-align: top;
+
+    }
+
+
+    .janitza-editor .pr-checkbox-row > label {
+
+        width: 180px;
+
+        white-space: nowrap;
+
+    }
+
+
+    .janitza-editor .pr-inline-note {
+
+        margin-left: 8px;
+
+        color: var(--pr-muted);
+
+        line-height: 1.4;
+
+    }
+
+
+    .janitza-editor .pr-field-list {
+
+        max-height: 320px;
+
+        overflow: auto;
+
+        padding: 12px;
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 8px;
+
+        background: #fff;
+
+    }
+
+
+    .janitza-editor .pr-field-group {
+
+        margin-bottom: 14px;
+
+    }
+
+
+    .janitza-editor .pr-field-group:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .janitza-editor .pr-field-group-title {
+
+        margin: 0 0 8px;
+
+        font-size: 12px;
+
+        font-weight: 700;
+
+        text-transform: uppercase;
+
+        letter-spacing: 0.03em;
+
+        color: #344054;
+
+    }
+
+
+    .janitza-editor .pr-field-group-grid {
+
+        display: grid;
+
+        grid-template-columns: repeat(auto-fit, minmax(230px, 1fr));
+
+        gap: 8px 16px;
+
+    }
+
+
+    .janitza-editor .pr-field-item {
+
+        display: flex;
+
+        align-items: center;
+
+        min-height: 28px;
+
+        margin: 0;
+
+        color: #243447;
+
+        font-size: 13px;
+
+    }
+
+
+    .janitza-editor .pr-field-item input {
+
+        margin: 0 8px 0 0;
+
+    }
+
+
+    .janitza-editor .pr-actions {
+
+        display: flex;
+
+        flex-wrap: wrap;
+
+        gap: 8px;
+
+        margin-bottom: 10px;
+
+    }
+
+
+    .janitza-editor .pr-actions button {
+
+        min-width: 110px;
+
+    }
+
+</style>
+
+
+<script type="text/javascript">
+
+    (function () {
+
+        const FIELD_GROUPS = [
+
+            {
+
+                label: "General",
+
+                fields: [
+
+                    "summary.power.total_w",
+
+                    "summary.frequency_hz",
+
+                    "summary.phase_sequence"
+
+                ]
+
+            },
+
+            {
+
+                label: "Voltage",
+
+                fields: [
+
+                    "summary.voltage.l1_n_v",
+
+                    "summary.voltage.l2_n_v",
+
+                    "summary.voltage.l3_n_v",
+
+                    "summary.voltage.l1_l2_v",
+
+                    "summary.voltage.l2_l3_v",
+
+                    "summary.voltage.l3_l1_v"
+
+                ]
+
+            },
+
+            {
+
+                label: "Current",
+
+                fields: [
+
+                    "summary.current.l1_a",
+
+                    "summary.current.l2_a",
+
+                    "summary.current.l3_a",
+
+                    "summary.current.neutral_a"
+
+                ]
+
+            },
+
+            {
+
+                label: "Active Power",
+
+                fields: [
+
+                    "summary.power.l1_w",
+
+                    "summary.power.l2_w",
+
+                    "summary.power.l3_w"
+
+                ]
+
+            },
+
+            {
+
+                label: "Apparent Power",
+
+                fields: [
+
+                    "summary.apparent.l1_va",
+
+                    "summary.apparent.l2_va",
+
+                    "summary.apparent.l3_va",
+
+                    "summary.apparent.total_va"
+
+                ]
+
+            },
+
+            {
+
+                label: "Reactive Power",
+
+                fields: [
+
+                    "summary.reactive.l1_var",
+
+                    "summary.reactive.l2_var",
+
+                    "summary.reactive.l3_var",
+
+                    "summary.reactive.total_var"
+
+                ]
+
+            },
+
+            {
+
+                label: "Power Factor",
+
+                fields: [
+
+                    "summary.power_factor.l1",
+
+                    "summary.power_factor.l2",
+
+                    "summary.power_factor.l3"
+
+                ]
+
+            },
+
+            {
+
+                label: "Energy",
+
+                fields: [
+
+                    "summary.energy.import_kwh",
+
+                    "summary.energy.export_kwh",
+
+                    "summary.energy.l1_kwh",
+
+                    "summary.energy.l2_kwh",
+
+                    "summary.energy.l3_kwh",
+
+                    "summary.energy.apparent_kvah",
+
+                    "summary.energy.reactive_import_kvarh",
+
+                    "summary.energy.reactive_inductive_kvarh",
+
+                    "summary.energy.reactive_capacitive_kvarh"
+
+                ]
+
+            },
+
+            {
+
+                label: "Harmonics",
+
+                fields: [
+
+                    "summary.thd.voltage.l1_pct",
+
+                    "summary.thd.voltage.l2_pct",
+
+                    "summary.thd.voltage.l3_pct",
+
+                    "summary.thd.current.l1_pct",
+
+                    "summary.thd.current.l2_pct",
+
+                    "summary.thd.current.l3_pct"
+
+                ]
+
+            }
+
+        ];
+
+        const EXTENDED_FIELD_GROUPS = [
+
+            {
+
+                label: "Extended L4 / Totals",
+
+                fields: [
+
+                    "summary.extended.voltage.l4_n_v",
+
+                    "summary.extended.current.l4_a",
+
+                    "summary.extended.power.l4_w",
+
+                    "summary.extended.reactive.l4_var",
+
+                    "summary.extended.apparent.l4_va",
+
+                    "summary.extended.current.sum_l1_l4_a",
+
+                    "summary.extended.power.total_l1_l4_w",
+
+                    "summary.extended.reactive.total_l1_l4_var",
+
+                    "summary.extended.apparent.total_l1_l4_va",
+
+                    "summary.extended.power_factor.total_l1_l4"
+
+                ]
+
+            },
+
+            {
+
+                label: "Power Quality",
+
+                fields: [
+
+                    "summary.power_quality.voltage.avg_l_n_v",
+
+                    "summary.power_quality.voltage.avg_l_l_v",
+
+                    "summary.power_quality.current.avg_a",
+
+                    "summary.power_quality.power_factor.avg",
+
+                    "summary.power_quality.current.tdd_l1_pct",
+
+                    "summary.power_quality.current.tdd_l2_pct",
+
+                    "summary.power_quality.current.tdd_l3_pct",
+
+                    "summary.power_quality.current.unsymmetry_pct",
+
+                    "summary.power_quality.crest_factor.voltage_l1",
+
+                    "summary.power_quality.crest_factor.current_l1",
+
+                    "summary.power_quality.distortion_reactive.l1_var",
+
+                    "summary.power_quality.k_factor.l1",
+
+                    "summary.power_quality.k_factor.l2",
+
+                    "summary.power_quality.k_factor.l3"
+
+                ]
+
+            },
+
+            {
+
+                label: "Maximum Values",
+
+                fields: [
+
+                    "summary.max.voltage.l1_n_v",
+
+                    "summary.max.voltage.l2_n_v",
+
+                    "summary.max.voltage.l3_n_v",
+
+                    "summary.max.current.l1_a",
+
+                    "summary.max.current.l2_a",
+
+                    "summary.max.current.l3_a",
+
+                    "summary.max.power.total_w",
+
+                    "summary.max.reactive.total_var",
+
+                    "summary.max.frequency_hz"
+
+                ]
+
+            },
+
+            {
+
+                label: "Detailed Energy / Inputs",
+
+                fields: [
+
+                    "summary.energy.tariff.active",
+
+                    "summary.energy.tariff.reactive",
+
+                    "summary.energy.detail.active_total_kwh",
+
+                    "summary.energy.detail.consumed_total_kwh",
+
+                    "summary.energy.detail.supplied_total_kwh",
+
+                    "summary.energy.detail.reactive_inductive_total_kvarh",
+
+                    "summary.energy.detail.reactive_capacitive_total_kvarh",
+
+                    "summary.digital_inputs.pulse_counter_1",
+
+                    "summary.digital_inputs.pulse_counter_2"
+
+                ]
+
+            },
+
+            {
+
+                label: "Device / Events",
+
+                fields: [
+
+                    "summary.device.serial_number",
+
+                    "summary.device.production_number",
+
+                    "summary.device.modbus_address",
+
+                    "summary.device.ip_address",
+
+                    "summary.device.ip_mask",
+
+                    "summary.device.ip_gateway",
+
+                    "summary.device.current_transformer.primary_l1_a",
+
+                    "summary.device.voltage_transformer.primary_l1_v",
+
+                    "summary.events.current_threshold_l1_pct",
+
+                    "summary.events.voltage_max_l1_pct",
+
+                    "summary.events.voltage_min_l1_pct",
+
+                    "summary.temperature.offset_c"
+
+                ]
+
+            },
+
+            {
+
+                label: "Quick 200 ms",
+
+                fields: [
+
+                    "summary.quick.frequency_hz",
+
+                    "summary.quick.voltage.l1_n_v",
+
+                    "summary.quick.voltage.l2_n_v",
+
+                    "summary.quick.voltage.l3_n_v",
+
+                    "summary.quick.current.l1_a",
+
+                    "summary.quick.current.l2_a",
+
+                    "summary.quick.current.l3_a",
+
+                    "summary.quick.power.l1_w",
+
+                    "summary.quick.power.l2_w",
+
+                    "summary.quick.power.l3_w",
+
+                    "summary.quick.reactive.l1_var",
+
+                    "summary.quick.reactive.l2_var",
+
+                    "summary.quick.reactive.l3_var"
+
+                ]
+
+            }
+
+        ];
+
+
+        const MULTI_GRID_DEFAULT_FIELDS = [
+
+            "summary.power.total_w",
+
+            "summary.power.l1_w",
+
+            "summary.power.l2_w",
+
+            "summary.power.l3_w"
+
+        ];
+
+        const BESS_CONTROL_DEFAULT_FIELDS = MULTI_GRID_DEFAULT_FIELDS.slice();
+
+        const CONTROL_EXPORT_REACTIVE_DEFAULT_FIELDS = [
+
+            "summary.power.total_w",
+
+            "summary.power.l1_w",
+
+            "summary.power.l2_w",
+
+            "summary.power.l3_w",
+
+            "summary.reactive.total_var",
+
+            "summary.reactive.l1_var",
+
+            "summary.reactive.l2_var",
+
+            "summary.reactive.l3_var"
+
+        ];
+
+        const SCADA_DEFAULT_FIELDS = [
+
+            "summary.power.total_w",
+
+            "summary.reactive.total_var",
+
+            "summary.frequency_hz",
+
+            "summary.voltage.l1_l2_v",
+
+            "summary.voltage.l2_l3_v",
+
+            "summary.voltage.l3_l1_v"
+
+        ];
+
+
+        let payloadSelectionState = ["full"];
+
+        let customModeSelections = {
+
+            multiGrid: [],
+
+            bessControl: [],
+
+            controlExportReactive: [],
+
+            scadaServer: [],
+
+            influxDb: []
+
+        };
+
+        let customModeEnabledState = {
+
+            multiGrid: false,
+
+            bessControl: false,
+
+            controlExportReactive: false,
+
+            scadaServer: false,
+
+            influxDb: false
+
+        };
+
+        let specialExpertUnlockedState = {
+
+            multiGrid: false,
+
+            bessControl: false,
+
+            controlExportReactive: false,
+
+            scadaServer: false,
+
+            influxDb: false
+
+        };
+
+        let specialLongPressTimer = null;
+
+        let specialLongPressTriggeredMode = "";
+
+        let specialLongPressStartChecked = false;
+
+        let specialLongPressActivationMode = "";
+
+        let extendedFieldsUnlocked = false;
+
+        let selectAllLongPressTimer = null;
+
+        let selectAllLongPressTriggered = false;
+
+        const SPECIAL_EXPERT_LONG_PRESS_MS = 5000;
+
+
+        function getVisibleFieldGroups() {
+
+            return extendedFieldsUnlocked ? FIELD_GROUPS.concat(EXTENDED_FIELD_GROUPS) : FIELD_GROUPS;
+
+        }
+
+
+        function mergeHiddenExtendedSelections(visibleFields) {
+
+            if (extendedFieldsUnlocked) {
+
+                return visibleFields;
+
+            }
+
+
+            const visible = new Set(getAllSelectableFields());
+
+            const hiddenSelected = normalizePayloadFields(payloadSelectionState, true).filter(function (field) {
+
+                return field !== "full" && !visible.has(field);
+
+            });
+
+
+            return Array.from(new Set(hiddenSelected.concat(visibleFields)));
+
+        }
+
+
+        function getAllSelectableFields() {
+
+            return getVisibleFieldGroups().reduce(function (acc, group) {
+
+                return acc.concat(group.fields);
+
+            }, []);
+
+        }
+
+
+        function normalizePayloadFields(fields, allowEmpty) {
+
+            const keepEmpty = !!allowEmpty;
+
+
+            if (Array.isArray(fields) && fields.length) {
+
+                const normalized = Array.from(new Set(fields.map(function (field) {
+
+                    return String(field || "").trim();
+
+                }).filter(Boolean)));
+
+
+                if (!normalized.length) {
+
+                    return keepEmpty ? [] : ["full"];
+
+                }
+
+                if (normalized.includes("full")) {
+
+                    return ["full"];
+
+                }
+
+                return normalized;
+
+            }
+
+
+            if (typeof fields === "string" && fields.trim()) {
+
+                const trimmed = fields.trim();
+
+                if (trimmed[0] === "[") {
+
+                    try {
+
+                        const parsed = JSON.parse(trimmed);
+
+                        if (Array.isArray(parsed)) {
+
+                            return normalizePayloadFields(parsed, keepEmpty);
+
+                        }
+
+                    } catch (e) {
+
+                        // ignore invalid old editor state
+
+                    }
+
+                }
+
+                return [trimmed];
+
+            }
+
+
+            return keepEmpty ? [] : ["full"];
+
+        }
+
+
+        function arraysEqual(a, b) {
+
+            if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+
+                return false;
+
+            }
+
+            for (let i = 0; i < a.length; i += 1) {
+
+                if (a[i] !== b[i]) {
+
+                    return false;
+
+                }
+
+            }
+
+            return true;
+
+        }
+
+
+        function sanitizeCustomModeSelection(values) {
+
+            return normalizePayloadFields(values, true).filter(function (value) {
+
+                return value !== "full";
+
+            });
+
+        }
+
+
+        function getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb) {
+
+            if (multiGrid) {
+
+                return "multiGrid";
+
+            }
+
+            if (bessControl) {
+
+                return "bessControl";
+
+            }
+
+            if (controlExportReactive) {
+
+                return "controlExportReactive";
+
+            }
+
+            if (scadaServer) {
+
+                return "scadaServer";
+
+            }
+
+            if (influxDb) {
+
+                return "influxDb";
+
+            }
+
+            return "";
+
+        }
+
+
+        function getDefaultFieldsForMode(mode) {
+
+            if (mode === "multiGrid") {
+
+                return MULTI_GRID_DEFAULT_FIELDS.slice();
+
+            }
+
+            if (mode === "bessControl") {
+
+                return BESS_CONTROL_DEFAULT_FIELDS.slice();
+
+            }
+
+            if (mode === "controlExportReactive") {
+
+                return CONTROL_EXPORT_REACTIVE_DEFAULT_FIELDS.slice();
+
+            }
+
+            if (mode === "scadaServer") {
+
+                return SCADA_DEFAULT_FIELDS.slice();
+
+            }
+
+            if (mode === "influxDb") {
+
+                return getAllSelectableFields();
+
+            }
+
+            return ["full"];
+
+        }
+
+
+        function isSpecialModeEnabled(mode) {
+
+            return mode === "multiGrid" || mode === "bessControl" || mode === "controlExportReactive" || mode === "scadaServer" || mode === "influxDb";
+
+        }
+
+
+        function getModeCheckbox(mode) {
+
+            if (mode === "multiGrid") {
+
+                return $("#node-input-multiGrid");
+
+            }
+
+            if (mode === "bessControl") {
+
+                return $("#node-input-bessControl");
+
+            }
+
+            if (mode === "controlExportReactive") {
+
+                return $("#node-input-controlExportReactive");
+
+            }
+
+            if (mode === "scadaServer") {
+
+                return $("#node-input-scadaServer");
+
+            }
+
+            if (mode === "influxDb") {
+
+                return $("#node-input-influxDb");
+
+            }
+
+            return $();
+
+        }
+
+
+        function sanitizeForMode(values, multiGrid, bessControl, controlExportReactive, scadaServer, influxDb, options) {
+
+            const mode = getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb);
+
+            const allowEmptySpecial = !!(options && options.allowEmptySpecial && mode);
+
+            const normalized = normalizePayloadFields(values, allowEmptySpecial);
+
+
+            if (mode && normalized.includes("full")) {
+
+                return getDefaultFieldsForMode(mode);
+
+            }
+
+            return normalized;
+
+        }
+
+
+        function getPayloadLabel(path) {
+
+            const labels = {
+
+                "full": "Toate valorile",
+
+                "summary.voltage.l1_n_v": "Tensiune L1-N",
+
+                "summary.voltage.l2_n_v": "Tensiune L2-N",
+
+                "summary.voltage.l3_n_v": "Tensiune L3-N",
+
+                "summary.voltage.l1_l2_v": "Tensiune L1-L2",
+
+                "summary.voltage.l2_l3_v": "Tensiune L2-L3",
+
+                "summary.voltage.l3_l1_v": "Tensiune L3-L1",
+
+                "summary.current.l1_a": "Curent L1",
+
+                "summary.current.l2_a": "Curent L2",
+
+                "summary.current.l3_a": "Curent L3",
+
+                "summary.current.neutral_a": "Curent neutral",
+
+                "summary.power.l1_w": "Putere L1",
+
+                "summary.power.l2_w": "Putere L2",
+
+                "summary.power.l3_w": "Putere L3",
+
+                "summary.power.total_w": "Putere totala",
+
+                "summary.apparent.l1_va": "Putere aparenta L1",
+
+                "summary.apparent.l2_va": "Putere aparenta L2",
+
+                "summary.apparent.l3_va": "Putere aparenta L3",
+
+                "summary.apparent.total_va": "Putere aparenta totala",
+
+                "summary.reactive.l1_var": "Putere reactiva L1",
+
+                "summary.reactive.l2_var": "Putere reactiva L2",
+
+                "summary.reactive.l3_var": "Putere reactiva L3",
+
+                "summary.reactive.total_var": "Putere reactiva totala",
+
+                "summary.power_factor.l1": "Cos phi L1",
+
+                "summary.power_factor.l2": "Cos phi L2",
+
+                "summary.power_factor.l3": "Cos phi L3",
+
+                "summary.frequency_hz": "Frecventa",
+
+                "summary.phase_sequence": "Ordine faze",
+
+                "summary.energy.import_kwh": "Energie importata",
+
+                "summary.energy.export_kwh": "Energie exportata",
+
+                "summary.energy.l1_kwh": "Energie L1",
+
+                "summary.energy.l2_kwh": "Energie L2",
+
+                "summary.energy.l3_kwh": "Energie L3",
+
+                "summary.energy.apparent_kvah": "Energie aparenta",
+
+                "summary.energy.reactive_import_kvarh": "Energie reactiva",
+
+                "summary.energy.reactive_inductive_kvarh": "Energie reactiva inductiva",
+
+                "summary.energy.reactive_capacitive_kvarh": "Energie reactiva capacitiva",
+
+                "summary.thd.voltage.l1_pct": "THD tensiune L1",
+
+                "summary.thd.voltage.l2_pct": "THD tensiune L2",
+
+                "summary.thd.voltage.l3_pct": "THD tensiune L3",
+
+                "summary.thd.current.l1_pct": "THD curent L1",
+
+                "summary.thd.current.l2_pct": "THD curent L2",
+
+                "summary.thd.current.l3_pct": "THD curent L3",
+
+                "summary.extended.voltage.l4_n_v": "Tensiune L4-N",
+
+                "summary.extended.current.l4_a": "Curent L4",
+
+                "summary.extended.power.l4_w": "Putere L4",
+
+                "summary.extended.reactive.l4_var": "Putere reactiva L4",
+
+                "summary.extended.apparent.l4_va": "Putere aparenta L4",
+
+                "summary.extended.current.sum_l1_l4_a": "Curent suma L1-L4",
+
+                "summary.extended.power.total_l1_l4_w": "Putere totala L1-L4",
+
+                "summary.extended.reactive.total_l1_l4_var": "Putere reactiva L1-L4",
+
+                "summary.extended.apparent.total_l1_l4_va": "Putere aparenta L1-L4",
+
+                "summary.extended.power_factor.total_l1_l4": "Factor putere L1-L4",
+
+                "summary.power_quality.voltage.avg_l_n_v": "Tensiune medie L-N",
+
+                "summary.power_quality.voltage.avg_l_l_v": "Tensiune medie L-L",
+
+                "summary.power_quality.current.avg_a": "Curent mediu",
+
+                "summary.power_quality.power_factor.avg": "Factor putere mediu",
+
+                "summary.power_quality.current.tdd_l1_pct": "TDD curent L1",
+
+                "summary.power_quality.current.tdd_l2_pct": "TDD curent L2",
+
+                "summary.power_quality.current.tdd_l3_pct": "TDD curent L3",
+
+                "summary.power_quality.current.unsymmetry_pct": "Dezechilibru curent",
+
+                "summary.power_quality.crest_factor.voltage_l1": "Crest factor tensiune L1",
+
+                "summary.power_quality.crest_factor.current_l1": "Crest factor curent L1",
+
+                "summary.power_quality.distortion_reactive.l1_var": "Putere reactiva distorsiune L1",
+
+                "summary.power_quality.k_factor.l1": "K-factor L1",
+
+                "summary.power_quality.k_factor.l2": "K-factor L2",
+
+                "summary.power_quality.k_factor.l3": "K-factor L3",
+
+                "summary.max.voltage.l1_n_v": "Max tensiune L1-N",
+
+                "summary.max.voltage.l2_n_v": "Max tensiune L2-N",
+
+                "summary.max.voltage.l3_n_v": "Max tensiune L3-N",
+
+                "summary.max.current.l1_a": "Max curent L1",
+
+                "summary.max.current.l2_a": "Max curent L2",
+
+                "summary.max.current.l3_a": "Max curent L3",
+
+                "summary.max.power.total_w": "Max putere totala",
+
+                "summary.max.reactive.total_var": "Max putere reactiva",
+
+                "summary.max.frequency_hz": "Max frecventa",
+
+                "summary.energy.tariff.active": "Tarif energie activa",
+
+                "summary.energy.tariff.reactive": "Tarif energie reactiva",
+
+                "summary.energy.detail.active_total_kwh": "Energie activa totala",
+
+                "summary.energy.detail.consumed_total_kwh": "Energie consumata total",
+
+                "summary.energy.detail.supplied_total_kwh": "Energie livrata total",
+
+                "summary.energy.detail.reactive_inductive_total_kvarh": "Energie reactiva inductiva total",
+
+                "summary.energy.detail.reactive_capacitive_total_kvarh": "Energie reactiva capacitiva total",
+
+                "summary.digital_inputs.pulse_counter_1": "Contor impuls intrare 1",
+
+                "summary.digital_inputs.pulse_counter_2": "Contor impuls intrare 2",
+
+                "summary.device.serial_number": "Serial number",
+
+                "summary.device.production_number": "Production number",
+
+                "summary.device.modbus_address": "Adresa Modbus",
+
+                "summary.device.ip_address": "IP device",
+
+                "summary.device.ip_mask": "Masca IP",
+
+                "summary.device.ip_gateway": "Gateway IP",
+
+                "summary.device.current_transformer.primary_l1_a": "TC primar L1",
+
+                "summary.device.voltage_transformer.primary_l1_v": "TT primar L1",
+
+                "summary.events.current_threshold_l1_pct": "Prag eveniment curent L1",
+
+                "summary.events.voltage_max_l1_pct": "Prag tensiune maxima L1",
+
+                "summary.events.voltage_min_l1_pct": "Prag tensiune minima L1",
+
+                "summary.temperature.offset_c": "Offset temperatura",
+
+                "summary.quick.frequency_hz": "Frecventa quick",
+
+                "summary.quick.voltage.l1_n_v": "Tensiune quick L1-N",
+
+                "summary.quick.voltage.l2_n_v": "Tensiune quick L2-N",
+
+                "summary.quick.voltage.l3_n_v": "Tensiune quick L3-N",
+
+                "summary.quick.current.l1_a": "Curent quick L1",
+
+                "summary.quick.current.l2_a": "Curent quick L2",
+
+                "summary.quick.current.l3_a": "Curent quick L3",
+
+                "summary.quick.power.l1_w": "Putere quick L1",
+
+                "summary.quick.power.l2_w": "Putere quick L2",
+
+                "summary.quick.power.l3_w": "Putere quick L3",
+
+                "summary.quick.reactive.l1_var": "Reactiva quick L1",
+
+                "summary.quick.reactive.l2_var": "Reactiva quick L2",
+
+                "summary.quick.reactive.l3_var": "Reactiva quick L3"
+
+            };
+
+            return labels[path] || path;
+
+        }
+
+
+        function persistPayloadSelection(fields, options) {
+
+            const multiGrid = $("#node-input-multiGrid").is(":checked");
+
+            const bessControl = $("#node-input-bessControl").is(":checked");
+
+            const controlExportReactive = $("#node-input-controlExportReactive").is(":checked");
+
+            const scadaServer = $("#node-input-scadaServer").is(":checked");
+            const influxDb = $("#node-input-influxDb").is(":checked");
+
+            const mode = getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb);
+
+            const expertMode = $("#node-input-expertMode").is(":checked");
+
+            const modeCustomEnabled = !!(mode && customModeEnabledState[mode]);
+
+            const allowEmptySpecial = !!(options && options.allowEmptySpecial && mode && (expertMode || modeCustomEnabled));
+
+
+            payloadSelectionState = sanitizeForMode(
+
+                fields,
+
+                multiGrid,
+
+                bessControl,
+
+                controlExportReactive,
+
+                scadaServer,
+
+                influxDb,
+
+                { allowEmptySpecial: allowEmptySpecial }
+
+            );
+
+            $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+
+            if (mode && (expertMode || modeCustomEnabled)) {
+
+                customModeSelections[mode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+            }
+
+
+            updateOutputs();
+
+        }
+
+
+        function renderFieldSelection(currentFields) {
+
+            const selected = new Set(currentFields || []);
+
+            const $container = $("#node-janitza-field-list").empty();
+
+
+            getVisibleFieldGroups().forEach(function (group) {
+
+                const $group = $('<div class="pr-field-group"></div>');
+
+                const $grid = $('<div class="pr-field-group-grid"></div>');
+
+
+                $group.append($('<p class="pr-field-group-title"></p>').text(group.label));
+
+
+                group.fields.forEach(function (field) {
+
+                    const $checkbox = $('<input type="checkbox">')
+
+                        .attr("data-field", field)
+
+                        .prop("checked", selected.has(field));
+
+
+                    const $label = $('<label class="pr-field-item"></label>')
+
+                        .append($checkbox)
+
+                        .append($('<span></span>').text(getPayloadLabel(field)));
+
+
+                    $grid.append($label);
+
+                });
+
+
+                $group.append($grid);
+
+                $container.append($group);
+
+            });
+
+
+            $container.find("input[type=checkbox]").on("change", function () {
+
+                const fields = [];
+
+                $container.find("input[type=checkbox]:checked").each(function () {
+
+                    fields.push($(this).attr("data-field"));
+
+                });
+
+                persistPayloadSelection(mergeHiddenExtendedSelections(fields), { allowEmptySpecial: true });
+
+            });
+
+        }
+
+
+        function syncPayloadModeUi() {
+
+            const multiGrid = $("#node-input-multiGrid").is(":checked");
+
+            const bessControl = $("#node-input-bessControl").is(":checked");
+
+            const controlExportReactive = $("#node-input-controlExportReactive").is(":checked");
+
+            const scadaServer = $("#node-input-scadaServer").is(":checked");
+            const influxDb = $("#node-input-influxDb").is(":checked");
+
+            const specialMode = getActiveSpecialMode(
+
+                multiGrid,
+
+                bessControl,
+
+                controlExportReactive,
+
+                scadaServer,
+
+                influxDb
+
+            );
+
+            if (!specialMode) {
+
+                $("#node-input-expertMode").prop("checked", false);
+
+            }
+
+
+            const expertMode = $("#node-input-expertMode").is(":checked");
+
+            const specialModeCustomEnabled = !!(specialMode && customModeEnabledState[specialMode]);
+
+            const selectedMode = specialMode ? "selected" : ($("#node-input-payloadMode").val() || "full");
+
+            const showSelectedFields = selectedMode === "selected" && (!specialMode || expertMode);
+
+            const showDefaultButton = showSelectedFields && !!specialMode;
+
+
+            $("#node-input-payloadMode").val(selectedMode);
+
+            $("#node-janitza-field-tools").toggle(showSelectedFields);
+
+            $("#node-janitza-field-list").toggle(showSelectedFields);
+
+            $("#node-janitza-default-values").toggle(showDefaultButton);
+
+            $("#row-expert-mode").toggle(!!specialMode && !!specialExpertUnlockedState[specialMode]);
+
+            $("#row-meter-id").toggle(!!specialMode);
+            $("#row-influx-measurement,#row-influx-node").toggle(!!influxDb);
+
+
+            if (specialMode && !expertMode) {
+
+                payloadSelectionState = (specialModeCustomEnabled ? customModeSelections[specialMode] : getDefaultFieldsForMode(specialMode)).slice();
+
+                $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+                $("#node-input-outputs").val(1);
+
+            } else if (!showSelectedFields) {
+
+                persistPayloadSelection(["full"]);
+
+            } else if (specialMode && expertMode) {
+
+                if (payloadSelectionState.includes("full")) {
+
+                    payloadSelectionState = customModeSelections[specialMode].slice();
+
+                }
+
+                persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+            } else if (payloadSelectionState.includes("full")) {
+
+                persistPayloadSelection([]);
+
+            }
+
+
+            renderFieldSelection(payloadSelectionState);
+
+            updateOutputs();
+
+        }
+
+
+        function clearSpecialLongPressTimer() {
+
+            if (specialLongPressTimer) {
+
+                clearTimeout(specialLongPressTimer);
+
+                specialLongPressTimer = null;
+
+            }
+
+        }
+
+
+        function unlockSpecialExpertMode(mode) {
+
+            if (!isSpecialModeEnabled(mode)) {
+
+                return;
+
+            }
+
+
+            specialExpertUnlockedState[mode] = true;
+
+            $("#node-input-expertMode").prop("checked", true).trigger("change");
+
+            syncPayloadModeUi();
+
+
+            if (RED && RED.notify) {
+
+                RED.notify("Selectia custom a fost activata.", "success");
+
+            }
+
+        }
+
+
+        function setupSpecialModeLongPress() {
+
+            function startLongPress(mode) {
+
+                const $checkbox = getModeCheckbox(mode);
+
+                if (!$checkbox.length || specialExpertUnlockedState[mode]) {
+
+                    return;
+
+                }
+
+
+                specialLongPressTriggeredMode = "";
+
+                specialLongPressStartChecked = $checkbox.is(":checked");
+
+                clearSpecialLongPressTimer();
+
+
+                specialLongPressTimer = setTimeout(function () {
+
+                    if (specialLongPressStartChecked && $checkbox.is(":checked")) {
+
+                        specialLongPressTriggeredMode = mode;
+
+                        unlockSpecialExpertMode(mode);
+
+                    }
+
+                }, SPECIAL_EXPERT_LONG_PRESS_MS);
+
+            }
+
+
+            ["multiGrid", "bessControl", "controlExportReactive", "scadaServer", "influxDb"].forEach(function (mode) {
+
+                const $checkbox = getModeCheckbox(mode);
+
+                $checkbox
+
+                    .off(".janitzaSpecialLongPress")
+
+                    .on("mousedown.janitzaSpecialLongPress touchstart.janitzaSpecialLongPress", function () {
+
+                        startLongPress(mode);
+
+                    })
+
+                    .on("mouseup.janitzaSpecialLongPress mouseleave.janitzaSpecialLongPress touchend.janitzaSpecialLongPress touchcancel.janitzaSpecialLongPress", function () {
+
+                        clearSpecialLongPressTimer();
+
+                    })
+
+                    .on("click.janitzaSpecialLongPress", function (evt) {
+
+                        if (specialLongPressTriggeredMode !== mode) {
+
+                            return;
+
+                        }
+
+                        evt.preventDefault();
+
+                        evt.stopImmediatePropagation();
+
+                        specialLongPressActivationMode = mode;
+
+                        $checkbox.prop("checked", true).trigger("change");
+
+                        specialLongPressTriggeredMode = "";
+
+                    });
+
+            });
+
+        }
+
+
+        function clearSelectAllLongPressTimer() {
+
+            if (selectAllLongPressTimer) {
+
+                clearTimeout(selectAllLongPressTimer);
+
+                selectAllLongPressTimer = null;
+
+            }
+
+        }
+
+
+        function setupSelectAllLongPress() {
+
+            $("#node-janitza-select-all")
+
+                .off(".janitzaExtendedLongPress")
+
+                .on("mousedown.janitzaExtendedLongPress touchstart.janitzaExtendedLongPress", function () {
+
+                    if ($("#node-input-payloadMode").val() !== "selected") {
+
+                        return;
+
+                    }
+
+
+                    selectAllLongPressTriggered = false;
+
+                    clearSelectAllLongPressTimer();
+
+                    selectAllLongPressTimer = setTimeout(function () {
+
+                        extendedFieldsUnlocked = true;
+
+                        selectAllLongPressTriggered = true;
+
+                        renderFieldSelection(payloadSelectionState);
+
+                        if (RED && RED.notify) {
+
+                            RED.notify("Valorile extinse Janitza au fost afisate.", "success");
+
+                        }
+
+                    }, SPECIAL_EXPERT_LONG_PRESS_MS);
+
+                })
+
+                .on("mouseup.janitzaExtendedLongPress mouseleave.janitzaExtendedLongPress touchend.janitzaExtendedLongPress touchcancel.janitzaExtendedLongPress", function () {
+
+                    clearSelectAllLongPressTimer();
+
+                });
+
+        }
+
+
+        function updateSpecialModes(changedId) {
+
+            const ids = ["multiGrid", "bessControl", "controlExportReactive", "scadaServer", "influxDb"];
+
+            const activatedByLongPress = specialLongPressActivationMode === changedId;
+
+            const previousState = {};
+
+            ids.forEach(function (id) {
+
+                previousState[id] = $("#node-input-" + id).is(":checked");
+
+            });
+
+            previousState[changedId] = !previousState[changedId];
+
+            const previousMode = getActiveSpecialMode(previousState.multiGrid, previousState.bessControl, previousState.controlExportReactive, previousState.scadaServer, previousState.influxDb);
+
+
+            if (previousMode && ($("#node-input-expertMode").is(":checked") || customModeEnabledState[previousMode])) {
+
+                customModeSelections[previousMode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+            }
+
+
+            if ($("#node-input-" + changedId).is(":checked")) {
+
+                ids.forEach(function (id) {
+
+                    const keepInfluxPair = changedId === "influxDb" ? id !== "influxDb" : id === "influxDb";
+                    if (id !== changedId && !keepInfluxPair) {
+
+                        $("#node-input-" + id).prop("checked", false);
+
+                    }
+
+                });
+
+            }
+
+
+            const specialMode = getActiveSpecialMode(
+
+                $("#node-input-multiGrid").is(":checked"),
+
+                $("#node-input-bessControl").is(":checked"),
+
+                $("#node-input-controlExportReactive").is(":checked"),
+
+                $("#node-input-scadaServer").is(":checked"),
+
+                $("#node-input-influxDb").is(":checked")
+
+            );
+
+
+            $("#node-input-payloadMode").prop("disabled", !!specialMode);
+
+            if (specialMode) {
+
+                $("#node-input-payloadMode").val("selected");
+
+                if (!activatedByLongPress) {
+
+                    $("#node-input-expertMode").prop("checked", false);
+
+                    ids.forEach(function (id) {
+
+                        specialExpertUnlockedState[id] = false;
+
+                    });
+
+                } else {
+
+                    specialExpertUnlockedState[changedId] = true;
+
+                }
+
+            } else if (changedId) {
+
+                specialExpertUnlockedState[changedId] = false;
+
+            }
+
+            specialLongPressActivationMode = "";
+
+            syncPayloadModeUi();
+
+            persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+        }
+
+
+        function updateOutputs() {
+
+            const specialMode = getActiveSpecialMode(
+
+                $("#node-input-multiGrid").is(":checked"),
+
+                $("#node-input-bessControl").is(":checked"),
+
+                $("#node-input-controlExportReactive").is(":checked"),
+
+                $("#node-input-scadaServer").is(":checked"),
+
+                $("#node-input-influxDb").is(":checked")
+
+            );
+
+            const payloadMode = $("#node-input-payloadMode").val();
+
+            const outputs = specialMode || payloadMode === "full" ? 1 : Math.max(1, payloadSelectionState.length);
+
+            $("#node-input-outputs").val(outputs);
+
+        }
+
+
+        RED.nodes.registerType("janitza", {
+
+            category: "Atelierul de Tehnologii",
+
+            color: "#c7e9c0",
+
+            defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+
+                name: { value: "" },
+
+                model: { value: "umg604pro", required: true },
+
+                host: { value: "", required: true },
+
+                port: { value: 502, required: true, validate: RED.validators.number() },
+
+                unitId: { value: 1, required: true, validate: RED.validators.number() },
+
+                timestep: {
+                    value: 1000,
+                    required: true,
+                    validate: function (v) {
+                        const text = String(v || "").trim().toLowerCase();
+                        const n = Number(text);
+                        return text === "off" || (Number.isFinite(n) && n >= 0);
+                    }
+                },
+
+                payloadFields: { value: ["full"] },
+
+                payloadMode: { value: "full" },
+
+                multiGrid: { value: false },
+
+                bessControl: { value: false },
+
+                controlExportReactive: { value: false },
+
+                scadaServer: { value: false },
+
+                influxDb: { value: false },
+
+                influxMeasurement: {
+
+                    value: "",
+
+                    validate: function (v) {
+
+                        const influxChecked = $("#node-input-influxDb").length
+                            ? $("#node-input-influxDb").is(":checked")
+                            : !!this.influxDb;
+
+                        return !influxChecked || !!String(v || "").trim();
+                    }
+
+                },
+
+                influxNode: { value: "" },
+                expertMode: { value: false },
+
+                multiGridCustomFields: { value: [] },
+
+                bessControlCustomFields: { value: [] },
+
+                controlExportReactiveCustomFields: { value: [] },
+
+                scadaServerCustomFields: { value: [] },
+
+                influxDbCustomFields: { value: [] },
+
+                multiGridUseSelectedFields: { value: false },
+
+                bessControlUseSelectedFields: { value: false },
+
+                controlExportReactiveUseSelectedFields: { value: false },
+
+                scadaServerUseSelectedFields: { value: false },
+
+                influxDbUseSelectedFields: { value: false },
+
+                meterId: {
+
+                    value: "",
+
+                    validate: function (v) {
+
+                        const isSpecial = (
+
+                            $("#node-input-multiGrid").is(":checked") ||
+
+                            $("#node-input-bessControl").is(":checked") ||
+
+                            $("#node-input-controlExportReactive").is(":checked") ||
+
+                            $("#node-input-scadaServer").is(":checked") ||
+
+                            $("#node-input-influxDb").is(":checked")
+
+                        );
+
+                        return !isSpecial || !!String(v || "").trim();
+
+                    }
+
+                },
+
+                outputs: { value: 1 }
+
+            },
+
+            inputs: 0,
+
+            outputs: 1,
+
+            icon: "bridge.svg",
+
+            label: function () {
+
+                if (this.name && String(this.name).trim()) {
+
+                    return this.name;
+
+                }
+
+                if (this.host && String(this.host).trim()) {
+
+                    return String(this.host).trim();
+
+                }
+
+                return "janitza";
+
+            },
+
+            oneditprepare: function () {
+                const node = this;
+                const influxSelect = $("#node-input-influxNode").empty().append($("<option></option>").val("").text("Selecteaza adt-influxdb"));
+                RED.nodes.eachNode(function (candidate) {
+                    if (candidate.type === "adt-influxdb") influxSelect.append($("<option></option>").val(candidate.id).text(candidate.name || "adt-influxdb"));
+                });
+                influxSelect.val(node.influxNode || "");
+
+                function syncInputs() {
+                    const text = String($("#node-input-timestep").val() || "").trim().toLowerCase();
+                    node.inputs = text === "off" || text === "0" ? 1 : 0;
+                }
+
+                $("#node-input-timestep").off(".janitzaPoll").on("keyup.janitzaPoll change.janitzaPoll", syncInputs);
+                syncInputs();
+
+                const $dialog = $("#dialog-form").closest(".ui-dialog");
+
+                if ($dialog.length) {
+
+                    $("#dialog-form").dialog("option", "width", 700);
+
+                }
+
+
+                let nameManuallyEdited = !!(this.name && this.name.trim());
+
+                const specialMode = getActiveSpecialMode(!!this.multiGrid, !!this.bessControl, !!this.controlExportReactive, !!this.scadaServer, !!this.influxDb);
+
+
+                customModeSelections = {
+
+                    multiGrid: sanitizeCustomModeSelection(this.multiGridCustomFields),
+
+                    bessControl: sanitizeCustomModeSelection(this.bessControlCustomFields),
+
+                    controlExportReactive: sanitizeCustomModeSelection(this.controlExportReactiveCustomFields),
+
+                    scadaServer: sanitizeCustomModeSelection(this.scadaServerCustomFields),
+
+                    influxDb: sanitizeCustomModeSelection(this.influxDbCustomFields)
+
+                };
+
+                customModeEnabledState = {
+
+                    multiGrid: !!this.multiGridUseSelectedFields,
+
+                    bessControl: !!this.bessControlUseSelectedFields,
+
+                    controlExportReactive: !!this.controlExportReactiveUseSelectedFields,
+
+                    scadaServer: !!this.scadaServerUseSelectedFields,
+
+                    influxDb: !!this.influxDbUseSelectedFields
+
+                };
+
+                if (specialMode && this.expertMode) {
+
+                    customModeEnabledState[specialMode] = true;
+
+                }
+
+                specialExpertUnlockedState = {
+
+                    multiGrid: false,
+
+                    bessControl: false,
+
+                    controlExportReactive: false,
+
+                    scadaServer: false,
+
+                    influxDb: false
+
+                };
+
+
+                if (!this.name && this.host) {
+
+                    $("#node-input-name").val(this.host);
+
+                }
+
+
+                payloadSelectionState = sanitizeForMode(
+
+                    this.payloadFields || ["full"],
+
+                    !!this.multiGrid,
+
+                    !!this.bessControl,
+
+                    !!this.controlExportReactive,
+
+                    !!this.scadaServer,
+
+                    !!this.influxDb,
+
+                    { allowEmptySpecial: !!(specialMode && (this.expertMode || customModeEnabledState[specialMode])) }
+
+                );
+
+                extendedFieldsUnlocked = false;
+
+
+                $("#node-input-payloadMode").val(specialMode ? "selected" : (payloadSelectionState.includes("full") ? "full" : (this.payloadMode || "selected")));
+
+                $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+                $("#node-input-expertMode").prop("checked", false);
+
+                renderFieldSelection(payloadSelectionState);
+
+
+                $("#node-input-name").on("input.janitzaName", function () {
+
+                    nameManuallyEdited = true;
+
+                });
+
+
+                $("#node-input-host").on("input.janitzaHostSync change.janitzaHostSync", function () {
+
+                    const newHost = String($(this).val() || "").trim();
+
+                    if (newHost || !$("#node-input-name").val().trim()) {
+
+                        $("#node-input-name").val(newHost);
+
+                    }
+
+                });
+
+
+                $("#node-input-payloadMode").on("change.janitzaPayloadMode", syncPayloadModeUi);
+
+                $("#node-input-expertMode").on("change.janitzaExpert", function () {
+
+                    const special = getActiveSpecialMode(
+
+                        $("#node-input-multiGrid").is(":checked"),
+
+                        $("#node-input-bessControl").is(":checked"),
+
+                        $("#node-input-controlExportReactive").is(":checked"),
+
+                        $("#node-input-scadaServer").is(":checked"),
+
+                        $("#node-input-influxDb").is(":checked")
+
+                    );
+
+                    if (special && !$(this).is(":checked")) {
+
+                        persistPayloadSelection(getDefaultFieldsForMode(special), { allowEmptySpecial: true });
+
+                        renderFieldSelection(payloadSelectionState);
+
+                    }
+
+                    syncPayloadModeUi();
+
+                });
+
+
+                $("#node-janitza-select-all").on("click.janitzaToolbar", function (evt) {
+
+                    evt.preventDefault();
+
+                    if (selectAllLongPressTriggered) {
+
+                        selectAllLongPressTriggered = false;
+
+                        return;
+
+                    }
+
+                    persistPayloadSelection(mergeHiddenExtendedSelections(getAllSelectableFields()), { allowEmptySpecial: true });
+
+                    renderFieldSelection(payloadSelectionState);
+
+                });
+
+
+                $("#node-janitza-clear-all").on("click.janitzaToolbar", function (evt) {
+
+                    evt.preventDefault();
+
+                    persistPayloadSelection(mergeHiddenExtendedSelections([]), { allowEmptySpecial: true });
+
+                    renderFieldSelection(payloadSelectionState);
+
+                });
+
+
+                $("#node-janitza-default-values").on("click.janitzaToolbar", function (evt) {
+
+                    evt.preventDefault();
+
+                    const special = getActiveSpecialMode(
+
+                        $("#node-input-multiGrid").is(":checked"),
+
+                        $("#node-input-bessControl").is(":checked"),
+
+                        $("#node-input-controlExportReactive").is(":checked"),
+
+                        $("#node-input-scadaServer").is(":checked"),
+
+                        $("#node-input-influxDb").is(":checked")
+
+                    );
+
+                    persistPayloadSelection(special ? getDefaultFieldsForMode(special) : ["full"], { allowEmptySpecial: true });
+
+                    if (!special) {
+
+                        $("#node-input-payloadMode").val("full");
+
+                    }
+
+                    renderFieldSelection(payloadSelectionState);
+
+                    syncPayloadModeUi();
+
+                });
+
+
+                ["multiGrid", "bessControl", "controlExportReactive", "scadaServer", "influxDb"].forEach(function (id) {
+
+                    $("#node-input-" + id).on("change.janitzaSpecial", function () {
+
+                        updateSpecialModes(id);
+
+                    });
+
+                });
+
+
+                setupSpecialModeLongPress();
+
+                setupSelectAllLongPress();
+
+                updateSpecialModes(specialMode || "");
+
+                syncPayloadModeUi();
+
+            },
+
+            oneditsave: function () {
+
+                const multiGrid = $("#node-input-multiGrid").is(":checked");
+
+                const bessControl = $("#node-input-bessControl").is(":checked");
+
+                const controlExportReactive = $("#node-input-controlExportReactive").is(":checked");
+
+                const scadaServer = $("#node-input-scadaServer").is(":checked");
+                const influxDb = $("#node-input-influxDb").is(":checked");
+
+                const expertMode = $("#node-input-expertMode").is(":checked");
+
+                const specialMode = getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb);
+
+                const modeCustomEnabled = !!(specialMode && (customModeEnabledState[specialMode] || expertMode));
+
+                let selected = sanitizeForMode(
+
+                    payloadSelectionState,
+
+                    multiGrid,
+
+                    bessControl,
+
+                    controlExportReactive,
+
+                    scadaServer,
+
+                    influxDb,
+
+                    { allowEmptySpecial: !!(specialMode && modeCustomEnabled) }
+
+                );
+
+
+                if (specialMode && expertMode) {
+
+                    customModeEnabledState[specialMode] = true;
+
+                    customModeSelections[specialMode] = sanitizeCustomModeSelection(selected);
+
+                }
+
+
+                if (specialMode && customModeEnabledState[specialMode]) {
+
+                    this.payloadFields = selected.slice();
+
+                } else if (specialMode) {
+
+                    this.payloadFields = getDefaultFieldsForMode(specialMode);
+
+                } else if (selected.includes("full")) {
+
+                    this.payloadFields = ["full"];
+
+                }
+
+                else {
+
+                    this.payloadFields = selected.slice();
+
+                }
+
+
+                this.payloadMode = $("#node-input-payloadMode").val();
+
+                this.multiGrid = multiGrid;
+
+                this.bessControl = bessControl;
+
+                this.controlExportReactive = controlExportReactive;
+
+                this.scadaServer = scadaServer;
+
+                this.influxDb = influxDb;
+                this.influxMeasurement = String($("#node-input-influxMeasurement").val() || "").trim();
+
+                this.expertMode = false;
+
+                this.multiGridCustomFields = customModeSelections.multiGrid.slice();
+
+                this.bessControlCustomFields = customModeSelections.bessControl.slice();
+
+                this.controlExportReactiveCustomFields = customModeSelections.controlExportReactive.slice();
+
+                this.scadaServerCustomFields = customModeSelections.scadaServer.slice();
+
+                this.influxDbCustomFields = customModeSelections.influxDb.slice();
+
+                this.multiGridUseSelectedFields = !!customModeEnabledState.multiGrid;
+
+                this.bessControlUseSelectedFields = !!customModeEnabledState.bessControl;
+
+                this.controlExportReactiveUseSelectedFields = !!customModeEnabledState.controlExportReactive;
+
+                this.scadaServerUseSelectedFields = !!customModeEnabledState.scadaServer;
+
+                this.influxDbUseSelectedFields = !!customModeEnabledState.influxDb;
+                const timestepText = String($("#node-input-timestep").val() || "").trim().toLowerCase();
+                this.inputs = timestepText === "off" || timestepText === "0" ? 1 : 0;
+
+                this.outputs = specialMode || this.payloadFields.includes("full") ? 1 : Math.max(1, this.payloadFields.length);
+
+
+                if (!this.name || !String(this.name).trim()) {
+
+                    this.name = String($("#node-input-host").val() || "").trim();
+
+                    $("#node-input-name").val(this.name);
+
+                }
+
+
+                $("#node-input-payloadFields").val(JSON.stringify(this.payloadFields));
+
+                $("#node-input-outputs").val(this.outputs);
+
+            },
+
+            oneditcancel: function () {
+
+                $("#node-input-name").off(".janitzaName");
+
+                $("#node-input-host").off(".janitzaHostSync");
+
+                $("#node-input-payloadMode").off(".janitzaPayloadMode");
+
+                $("#node-input-expertMode").off(".janitzaExpert");
+                $("#node-input-timestep").off(".janitzaPoll");
+
+                $("#node-janitza-select-all").off(".janitzaToolbar");
+
+                $("#node-janitza-clear-all").off(".janitzaToolbar");
+
+                $("#node-janitza-default-values").off(".janitzaToolbar");
+
+                $("#node-input-multiGrid").off(".janitzaSpecial");
+
+                $("#node-input-bessControl").off(".janitzaSpecial");
+
+                $("#node-input-controlExportReactive").off(".janitzaSpecial");
+
+                $("#node-input-scadaServer").off(".janitzaSpecial");
+
+                $("#node-input-influxDb").off(".janitzaSpecial");
+
+                $("#node-input-multiGrid").off(".janitzaSpecialLongPress");
+
+                $("#node-input-bessControl").off(".janitzaSpecialLongPress");
+
+                $("#node-input-controlExportReactive").off(".janitzaSpecialLongPress");
+
+                $("#node-input-scadaServer").off(".janitzaSpecialLongPress");
+
+                $("#node-input-influxDb").off(".janitzaSpecialLongPress");
+
+                $("#node-janitza-select-all").off(".janitzaExtendedLongPress");
+
+                clearSelectAllLongPressTimer();
+
+            }
+
+        });
+
+    }());
+
+</script>
+
+
+<script type="text/html" data-template-name="janitza">
+    <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="janitza-editor">
+
+        <div class="pr-section">
+
+            <p class="pr-section-title"><i class="fa fa-plug"></i> Janitza</p>
+
+            <p class="pr-section-note">Selecteaza modelul contorului. Pentru moment profilul disponibil este UMG 604 Pro.</p>
+
+            <div class="pr-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="janitza">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-model"><i class="fa fa-microchip"></i> Model</label>
+
+                    <select id="node-input-model">
+
+                        <option value="umg604pro">UMG 604 Pro</option>
+
+                    </select>
+
+                </div>
+
+                <div class="form-row" id="row-meter-id" style="display:none;">
+
+                    <label for="node-input-meterId"><i class="fa fa-id-badge"></i> Meter ID</label>
+
+                    <input type="text" id="node-input-meterId" placeholder="meter1">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-host"><i class="fa fa-globe"></i> Host</label>
+
+                    <input type="text" id="node-input-host" placeholder="192.168.1.100">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-port"><i class="fa fa-ellipsis-h"></i> Port</label>
+
+                    <input type="number" id="node-input-port" min="1" max="65535" placeholder="502">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-unitId"><i class="fa fa-hashtag"></i> Unit ID</label>
+
+                    <input type="number" id="node-input-unitId" min="1" max="247" placeholder="1">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-timestep"><i class="fa fa-refresh"></i> Poll interval</label>
+
+                    <input type="text" id="node-input-timestep" placeholder="1000 sau off">
+
+                </div>
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <p class="pr-section-title"><i class="fa fa-list"></i> Payload</p>
+
+            <p class="pr-section-note">Selecteaza valorile trimise de nod. In modurile speciale se trimite un singur mesaj agregat.</p>
+
+            <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="full">Full object</option>
+
+                    <option value="selected">Selected fields</option>
+
+                </select>
+
+            </div>
+
+            <input type="hidden" id="node-input-payloadFields">
+
+            <input type="hidden" id="node-input-outputs">
+
+            <div class="pr-actions" id="node-janitza-field-tools">
+
+                <button type="button" class="red-ui-button" id="node-janitza-select-all"><i class="fa fa-check-square-o"></i> Select all</button>
+
+                <button type="button" class="red-ui-button" id="node-janitza-clear-all"><i class="fa fa-square-o"></i> Clear</button>
+
+                <button type="button" class="red-ui-button" id="node-janitza-default-values"><i class="fa fa-magic"></i> Defaults</button>
+
+            </div>
+
+            <div class="pr-field-list" id="node-janitza-field-list"></div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <p class="pr-section-title"><i class="fa fa-share-alt"></i> Integrari</p>
+
+            <p class="pr-section-note">Pastreaza acelasi model de iesire ca nodul Carlo Gavazzi pentru fluxurile existente.</p>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-multiGrid"><i class="fa fa-sitemap"></i> Multi-grid</label>
+
+                <input type="checkbox" id="node-input-multiGrid">
+
+                <span class="pr-inline-note">Trimite puterile active intr-un mesaj agregat.</span>
+
+            </div>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-bessControl"><i class="fa fa-link"></i> BESS control</label>
+
+                <input type="checkbox" id="node-input-bessControl">
+
+                <span class="pr-inline-note">Payload compatibil cu controlul bateriei.</span>
+
+            </div>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-controlExportReactive"><i class="fa fa-bolt"></i> Control export/reactive</label>
+
+                <input type="checkbox" id="node-input-controlExportReactive">
+
+                <span class="pr-inline-note">Include putere activa si reactiva.</span>
+
+            </div>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-scadaServer"><i class="fa fa-server"></i> SCADA server</label>
+
+                <input type="checkbox" id="node-input-scadaServer">
+
+                <span class="pr-inline-note">Mapeaza cheile pentru serverul SCADA.</span>
+
+            </div>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-influxDb"><i class="fa fa-database"></i> InfluxDB</label>
+
+                <input type="checkbox" id="node-input-influxDb">
+
+                <span class="pr-inline-note">Grupeaza valorile in <code>msg.influx</code> pentru nodul <code>adt-influxdb</code>.</span>
+
+            </div>
+
+            <div class="form-row" id="row-influx-measurement" style="display:none;">
+
+                <label for="node-input-influxMeasurement"><i class="fa fa-line-chart"></i> Measurement</label>
+
+                <input type="text" id="node-input-influxMeasurement" placeholder="Grid Meter 1">
+
+            </div>
+            <div class="form-row" id="row-influx-node" style="display:none;">
+                <label for="node-input-influxNode"><i class="fa fa-plug"></i> Nod InfluxDB</label>
+                <select id="node-input-influxNode"></select>
+            </div>
+
+            <div class="form-row pr-checkbox-row" id="row-expert-mode" style="display:none;">
+
+                <label for="node-input-expertMode"><i class="fa fa-wrench"></i> Custom fields</label>
+
+                <input type="checkbox" id="node-input-expertMode">
+
+                <span class="pr-inline-note">Permite selectie manuala si in modurile speciale.</span>
+
+            </div>
+
+        </div>
+
+    </div>
+
+</script>
+
+
+<script type="text/html" data-help-name="janitza">
+
+    <p>Citeste valori Modbus TCP dintr-un contor Janitza, in functie de modelul selectat.</p>
+
+    <p>Profilul disponibil acum este <code>UMG 604 Pro</code>, cu functia Modbus 03 pentru registrii <code>19000</code>-<code>19120</code>, format <code>float</code> Big-Endian.</p>
+
+    <p>Energiile raportate in Wh/varh sunt convertite in kWh/kvarh in payload.</p>
+
+    <p>Cand este activ <b>InfluxDB</b>, nodul emite un singur mesaj agregat cu <code>msg.influx.measurement</code>, <code>msg.influx.tags</code>, <code>msg.influx.fields</code> si <code>msg.influx.timestamp</code>, compatibil direct cu nodul <code>adt-influxdb</code>.</p>
+
+    <h3>Referinta completa parametri</h3>
+
+    <ul>
+
+        <li><code>model</code>: profilul Janitza folosit pentru maparea registrelor.</li>
+
+        <li><code>host</code>, <code>port</code>, <code>unitId</code>: conexiunea Modbus TCP.</li>
+
+        <li><code>timestep</code>: intervalul de poll in milisecunde; <code>off</code> sau <code>0</code> opreste poll-ul automat si citeste doar la trigger pe intrare.</li>
+
+        <li><code>meterId</code>: ID emis in <code>msg.topic</code>, <code>msg.meter_id</code> si <code>msg.source_id</code>.</li>
+
+        <li><code>payloadMode</code>: <code>full</code> sau <code>selected</code>.</li>
+
+        <li><code>payloadFields</code>: lista campurilor selectate.</li>
+
+        <li><code>multiGrid</code>, <code>bessControl</code>, <code>controlExportReactive</code>, <code>scadaServer</code>, <code>influxDb</code>: preseturi exclusive pentru integrare.</li>
+
+        <li><code>influxMeasurement</code>: measurement-ul folosit in <code>msg.influx</code>.</li>
+
+        <li><code>multiGridCustomFields</code>, <code>bessControlCustomFields</code>, <code>controlExportReactiveCustomFields</code>, <code>scadaServerCustomFields</code>, <code>influxDbCustomFields</code>: listele custom pentru fiecare preset.</li>
+
+        <li><code>multiGridUseSelectedFields</code>, <code>bessControlUseSelectedFields</code>, <code>controlExportReactiveUseSelectedFields</code>, <code>scadaServerUseSelectedFields</code>, <code>influxDbUseSelectedFields</code>: activeaza listele custom in locul presetului implicit.</li>
+
+        <li><code>outputs</code>: numarul de iesiri calculat de editor.</li>
+
+    </ul>
+
+    <h3>Exemplu control-export/reactive</h3>
+
+    <pre>{
+  "topic": "janitza-main",
+  "payload": {
+    "power_w": -850,
+    "power_l1_w": -200,
+    "power_l2_w": -310,
+    "power_l3_w": -340,
+    "reactive_total_var": 420
+  },
+  "meter_id": "janitza-main"
+}</pre>
+
+</script>
+