myio-js-library 0.1.144 → 0.1.145

package/dist/myio-js-library.umd.js

@@ -15119,7 +15119,13 @@ ${rangeText}`;
     render(initialData) {
       this.originalActiveElement = document.activeElement;
       document.body.appendChild(this.container);
-      this.populateForm(initialData);
+      let formData = { ...initialData };
+      if (initialData.deviceMapInstaneousPower && typeof initialData.deviceMapInstaneousPower === "object") {
+        console.log("[SettingsModalView] Configura\xE7\xE3o salva encontrada (Device Scope). Processando...");
+        const flatLimits = this.parseDeviceSavedLimits(initialData.deviceMapInstaneousPower);
+        formData = { ...formData, ...flatLimits };
+      }
+      this.populateForm(formData);
       this.attachEventListeners();
       this.setupAccessibility();
       this.setupFocusTrap();
@@ -16688,6 +16694,42 @@ ${rangeText}`;
         }
       }
     }
+    /**
+     * Helper: Traduz o JSON RFC-0086 (deviceMapInstaneousPower) 
+     * para os campos planos do formulário (ex: standbyLimitUpConsumption)
+     */
+    parseDeviceSavedLimits(deviceJson) {
+      const extracted = {};
+      try {
+        if (!deviceJson || !deviceJson.limitsByInstantaneoustPowerType) return extracted;
+        const consumptionGroup = deviceJson.limitsByInstantaneoustPowerType.find(
+          (g) => g.telemetryType === "consumption"
+        );
+        const deviceItem = consumptionGroup?.itemsByDeviceType?.[0];
+        if (!deviceItem?.limitsByDeviceStatus) return extracted;
+        const mapPrefix = {
+          "standBy": "standby",
+          "normal": "normal",
+          "alert": "alert",
+          "failure": "failure"
+        };
+        deviceItem.limitsByDeviceStatus.forEach((status) => {
+          const prefix = mapPrefix[status.deviceStatusName];
+          if (prefix && status.limitsValues) {
+            const { baseValue, topValue } = status.limitsValues;
+            if (baseValue !== null && baseValue !== void 0) {
+              extracted[`${prefix}LimitDownConsumption`] = baseValue;
+            }
+            if (topValue !== null && topValue !== void 0) {
+              extracted[`${prefix}LimitUpConsumption`] = topValue;
+            }
+          }
+        });
+      } catch (e) {
+        console.warn("[SettingsModalView] Erro ao processar deviceMapInstaneousPower:", e);
+      }
+      return extracted;
+    }
     attachEventListeners() {
       this.form.addEventListener("submit", (event) => {
         event.preventDefault();
@@ -16959,11 +17001,25 @@ ${rangeText}`;
     }
     async saveServerScopeAttributes(deviceId, attributes) {
       try {
-        const mapInstantaneousPower = this.buildMapInstantaneousPower(attributes);
-        const payload = {
-          mapInstantaneousPower
-        };
-        console.log("[SettingsPersister] RFC-0080: Saving mapInstantaneousPower as JSON:", payload);
+        const payload = { ...attributes };
+        const effectiveDeviceType = this.getEffectiveDeviceType();
+        const deviceJson = this.buildDevicePowerJson(payload, effectiveDeviceType);
+        if (deviceJson) {
+          payload.deviceMapInstaneousPower = deviceJson;
+        }
+        const flatKeysToRemove = [
+          "telemetryType",
+          "standbyLimitDownConsumption",
+          "standbyLimitUpConsumption",
+          "normalLimitDownConsumption",
+          "normalLimitUpConsumption",
+          "alertLimitDownConsumption",
+          "alertLimitUpConsumption",
+          "failureLimitDownConsumption",
+          "failureLimitUpConsumption"
+        ];
+        flatKeysToRemove.forEach((key) => delete payload[key]);
+        console.log("[SettingsPersister] Saving Server Scope Attributes:", payload);
         const res = await fetch(
           `${this.tbBaseUrl}/api/plugins/telemetry/DEVICE/${deviceId}/attributes/SERVER_SCOPE`,
           {
@@ -16980,13 +17036,70 @@ ${rangeText}`;
         }
         return {
           ok: true,
-          updatedKeys: ["mapInstantaneousPower"]
+          updatedKeys: Object.keys(payload)
         };
       } catch (error) {
         console.error("[SettingsPersister] Attributes save failed:", error);
         return { ok: false, error: this.mapError(error) };
       }
     }
+    /**
+     * Constrói o JSON Reduzido (apenas o deviceType atual) para salvar no Device.
+     * Retorna null se nenhum campo de potência estiver presente.
+     */
+    buildDevicePowerJson(formData, deviceType) {
+      const statuses = ["standby", "normal", "alert", "failure"];
+      const hasPowerData = statuses.some(
+        (status) => formData[`${status}LimitDownConsumption`] !== void 0 && formData[`${status}LimitDownConsumption`] !== "" || formData[`${status}LimitUpConsumption`] !== void 0 && formData[`${status}LimitUpConsumption`] !== ""
+      );
+      if (!hasPowerData) return null;
+      const statusMap = {
+        "standby": "standBy",
+        "normal": "normal",
+        "alert": "alert",
+        "failure": "failure"
+      };
+      const limitsList = [];
+      statuses.forEach((statusKey) => {
+        const down = formData[`${statusKey}LimitDownConsumption`];
+        const up = formData[`${statusKey}LimitUpConsumption`];
+        if (down !== void 0 && down !== "" || up !== void 0 && up !== "") {
+          limitsList.push({
+            deviceStatusName: statusMap[statusKey],
+            limitsValues: {
+              // Converte para Number ou null
+              baseValue: down !== "" && down !== void 0 ? Number(down) : null,
+              topValue: up !== "" && up !== void 0 ? Number(up) : null
+            }
+          });
+        }
+      });
+      if (limitsList.length === 0) return null;
+      return {
+        version: "1.0.0",
+        limitsByInstantaneoustPowerType: [
+          {
+            telemetryType: "consumption",
+            itemsByDeviceType: [
+              {
+                deviceType,
+                // Gera um nome descritivo interno
+                name: `deviceMapInstaneousPower${this.formatDeviceTypeName(deviceType)}`,
+                description: "Override manual configurado via Dashboard",
+                limitsByDeviceStatus: limitsList
+              }
+            ]
+          }
+        ]
+      };
+    }
+    /**
+     * Helper para formatar o nome do tipo (PascalCase) para uso no campo "name" do JSON
+     */
+    formatDeviceTypeName(deviceType) {
+      if (!deviceType) return "";
+      return deviceType.charAt(0).toUpperCase() + deviceType.slice(1).toLowerCase();
+    }
     /**
      * RFC-0086: Build mapInstantaneousPower JSON structure from form data
      * IMPORTANT: When saving to a DEVICE, only include entries for the specific deviceType
@@ -17043,25 +17156,6 @@ ${rangeText}`;
       console.log(`[SettingsPersister] RFC-0086: Built mapInstantaneousPower for deviceType=${effectiveDeviceType}:`, result);
       return result;
     }
-    /**
-     * Format device type name for display (e.g., ELEVADOR -> Elevador)
-     */
-    formatDeviceTypeName(deviceType) {
-      const map = {
-        "ELEVADOR": "Elevator",
-        "ESCADA_ROLANTE": "Escalator",
-        "MOTOR": "Motor",
-        "BOMBA": "Pump",
-        "3F_MEDIDOR": "3FMedidor",
-        "CHILLER": "Chiller",
-        "FANCOIL": "Fancoil",
-        "AR_CONDICIONADO": "AirConditioner",
-        "HVAC": "HVAC",
-        "HIDROMETRO": "Hidrometro",
-        "TERMOSTATO": "Termostato"
-      };
-      return map[deviceType] || deviceType;
-    }
     sanitizeLabel(label) {
       return label.trim().slice(0, 255).replace(/[\x00-\x1F\x7F]/g, "");
     }
@@ -17198,18 +17292,16 @@ ${rangeText}`;
       }
       const attributesArray = await response.json();
       const attributes = {};
-      const settingsNamespace = "myio.settings.energy.";
       for (const attr of attributesArray) {
         if (attr.key && attr.value !== void 0 && attr.value !== null && attr.value !== "") {
-          if (attr.key.startsWith(settingsNamespace)) {
-            const key = attr.key.replace(settingsNamespace, "");
-            if (key !== "__version") {
-              attributes[key] = attr.value;
-            }
-          } else if (attr.key === "floor") {
+          if (attr.key === "floor") {
             attributes.floor = attr.value;
           } else if (attr.key === "identifier") {
             attributes.identifier = attr.value;
+          } else if (attr.key === "mapInstantaneousPower") {
+            attributes.mapInstantaneousPower = attr.value;
+          } else if (attr.key === "deviceMapInstaneousPower") {
+            attributes.deviceMapInstaneousPower = attr.value;
           }
         }
       }
@@ -17231,23 +17323,12 @@ ${rangeText}`;
       }
       return merged;
     }
-    /**
-     * Utility method to validate and sanitize fetched data
-     */
     static sanitizeFetchedData(data) {
       const sanitized = {};
       const stringFields = [
         "label",
         "floor",
-        "identifier",
-        "alertLimitDownConsumption",
-        "alertLimitUpConsumption",
-        "failureLimitDownConsumption",
-        "failureLimitUpConsumption",
-        "normalLimitDownConsumption",
-        "normalLimitUpConsumption",
-        "standbyLimitDownConsumption",
-        "standbyLimitUpConsumption"
+        "identifier"
       ];
       for (const field of stringFields) {
         if (data[field] && typeof data[field] === "string") {
@@ -17263,6 +17344,12 @@ ${rangeText}`;
           }
         }
       }
+      const objectFields = ["mapInstantaneousPower", "deviceMapInstaneousPower"];
+      for (const field of objectFields) {
+        if (data[field] && typeof data[field] === "object") {
+          sanitized[field] = data[field];
+        }
+      }
       return sanitized;
     }
   };
@@ -17312,8 +17399,9 @@ ${rangeText}`;
         // Pass connection info for display
         onSave: this.handleSave.bind(this),
         onClose: this.handleClose.bind(this),
-        mapInstantaneousPower: params.mapInstantaneousPower
-        // RFC-0077: Pass instantaneous power map for Power Limits feature
+        mapInstantaneousPower: params.mapInstantaneousPower,
+        // RFC-0077: Pass instantaneous power map for Power Limits feature,
+        deviceMapInstaneousPower: params.deviceMapInstaneousPower
       });
     }
     async show() {