iobroker.acinfinity 0.7.1 → 0.7.2

package/lib/handlers/portModeHandler.js

@@ -3,15 +3,15 @@
  * Verarbeitet Änderungen an den Port-Modi und deren Einstellungen
  */
 
-"use strict";
+'use strict';
 
 const {
     MODE_OPTIONS,
     SETTINGS_MODE_OPTIONS,
     SCHEDULE_DISABLED_VALUE,
     SCHEDULE_MIDNIGHT_VALUE,
-    SCHEDULE_EOD_VALUE
-} = require("../constants");
+    SCHEDULE_EOD_VALUE,
+} = require('../constants');
 
 class PortModeHandler {
     constructor(stateManager) {
@@ -26,7 +26,7 @@ class PortModeHandler {
 
     setClient(client) {
         this.client = client;
-        this.adapter.log.debug("API-Client erfolgreich an PortModeHandler übergeben");
+        this.adapter.log.debug('API-Client erfolgreich an PortModeHandler übergeben');
     }
 
     /**
@@ -34,7 +34,7 @@ class PortModeHandler {
      */
     async handlePortModeChange(deviceId, portId, path, value) {
         if (path.length < 1) {
-            this.adapter.log.warn(`Ungültiger Pfad für Port-Modus: ${path.join(".")}`);
+            this.adapter.log.warn(`Ungültiger Pfad für Port-Modus: ${path.join('.')}`);
             return;
         }
 
@@ -42,7 +42,7 @@ class PortModeHandler {
 
         try {
             if (!this.client) {
-                throw new Error("API-Client nicht gesetzt.");
+                throw new Error('API-Client nicht gesetzt.');
             }
 
             const normalizedDeviceId = String(deviceId);
@@ -81,12 +81,11 @@ class PortModeHandler {
      */
     async getCurrentSpeeds(deviceId, portId) {
         const onSpeedState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.onSpeed`);
-        const onSpeed = (onSpeedState && typeof onSpeedState.val === "number" && onSpeedState.val > 0)
-            ? onSpeedState.val : 3;
+        const onSpeed =
+            onSpeedState && typeof onSpeedState.val === 'number' && onSpeedState.val > 0 ? onSpeedState.val : 3;
 
         const offSpeedState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.offSpeed`);
-        const offSpeed = (offSpeedState && typeof offSpeedState.val === "number")
-            ? offSpeedState.val : 0;
+        const offSpeed = offSpeedState && typeof offSpeedState.val === 'number' ? offSpeedState.val : 0;
 
         return { onSpeed, offSpeed };
     }
@@ -96,7 +95,7 @@ class PortModeHandler {
      */
     async getCurrentAtType(deviceId, portId) {
         const modeState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.active`);
-        const modeName = modeState ? modeState.val : "On";
+        const modeName = modeState ? modeState.val : 'On';
         const modeIndex = MODE_OPTIONS.indexOf(modeName);
         return modeIndex >= 0 ? modeIndex + 1 : 2; // fallback: On (2)
     }
@@ -114,20 +113,20 @@ class PortModeHandler {
         }
 
         switch (settingType) {
-            case "active":
+            case 'active':
                 await this.handleActiveModeChange(deviceId, portId, value);
                 break;
 
-            case "onSpeed":
+            case 'onSpeed':
                 await this.handleOnSpeedChange(deviceId, portId, value);
                 break;
 
-            case "offSpeed":
+            case 'offSpeed':
                 await this.handleOffSpeedChange(deviceId, portId, value);
                 break;
 
             default:
-                if (["timer", "cycle", "schedule", "auto", "vpd"].includes(settingType) && path.length > 1) {
+                if (['timer', 'cycle', 'schedule', 'auto', 'vpd'].includes(settingType) && path.length > 1) {
                     await this.handleNestedPortSettingsChange(deviceId, portId, settingType, path.slice(1), value);
                 } else {
                     this.adapter.log.warn(`Unbekannter Port-Modus-Einstellungstyp: ${settingType}`);
@@ -148,7 +147,7 @@ class PortModeHandler {
         const modeIndex = MODE_OPTIONS.indexOf(modeName);
 
         if (modeIndex < 0) {
-            this.adapter.log.warn(`Ungültiger Modus-Wert: "${modeName}". Gültige Werte: ${MODE_OPTIONS.join(", ")}`);
+            this.adapter.log.warn(`Ungültiger Modus-Wert: "${modeName}". Gültige Werte: ${MODE_OPTIONS.join(', ')}`);
             return;
         }
 
@@ -158,15 +157,17 @@ class PortModeHandler {
         // Optimistic UI update
         await this.stateManager.updateUIState(`devices.${deviceId}.ports.${portId}.mode.active`, modeName);
 
-        this.adapter.log.info(`Modus-Wechsel: Gerät=${deviceId}, Port=${portId}, Modus="${modeName}" (atType=${atType})`);
+        this.adapter.log.info(
+            `Modus-Wechsel: Gerät=${deviceId}, Port=${portId}, Modus="${modeName}" (atType=${atType})`,
+        );
 
         try {
             const success = await this.client.setDeviceMode(deviceId, portId, atType, onSpeed, offSpeed);
             if (success) {
-                await this.adapter.setStateAsync(
-                    `devices.${deviceId}.ports.${portId}.mode.active`,
-                    { val: modeName, ack: true }
-                );
+                await this.adapter.setStateAsync(`devices.${deviceId}.ports.${portId}.mode.active`, {
+                    val: modeName,
+                    ack: true,
+                });
             }
         } catch (error) {
             this.adapter.log.error(`Fehler beim Modus-Wechsel: ${error.message}`);
@@ -194,10 +195,10 @@ class PortModeHandler {
         try {
             const success = await this.client.setDeviceMode(deviceId, portId, atType, speedValue, offSpeed);
             if (success) {
-                await this.adapter.setStateAsync(
-                    `devices.${deviceId}.ports.${portId}.mode.onSpeed`,
-                    { val: speedValue, ack: true }
-                );
+                await this.adapter.setStateAsync(`devices.${deviceId}.ports.${portId}.mode.onSpeed`, {
+                    val: speedValue,
+                    ack: true,
+                });
             }
         } catch (error) {
             this.adapter.log.error(`Fehler beim onSpeed-Wechsel: ${error.message}`);
@@ -225,10 +226,10 @@ class PortModeHandler {
         try {
             const success = await this.client.setDeviceMode(deviceId, portId, atType, onSpeed, speedValue);
             if (success) {
-                await this.adapter.setStateAsync(
-                    `devices.${deviceId}.ports.${portId}.mode.offSpeed`,
-                    { val: speedValue, ack: true }
-                );
+                await this.adapter.setStateAsync(`devices.${deviceId}.ports.${portId}.mode.offSpeed`, {
+                    val: speedValue,
+                    ack: true,
+                });
             }
         } catch (error) {
             this.adapter.log.error(`Fehler beim offSpeed-Wechsel: ${error.message}`);
@@ -260,19 +261,19 @@ class PortModeHandler {
         this.adapter.log.debug(`Verarbeite ${category}.${setting} = ${value}`);
 
         switch (category) {
-            case "timer":
+            case 'timer':
                 this.applyTimerSetting(currentSettings, setting, value);
                 break;
-            case "cycle":
+            case 'cycle':
                 this.applyCycleSetting(currentSettings, setting, value);
                 break;
-            case "schedule":
+            case 'schedule':
                 this.applyScheduleSetting(currentSettings, setting, value);
                 break;
-            case "auto":
+            case 'auto':
                 this.applyAutoSetting(currentSettings, setting, value);
                 break;
-            case "vpd":
+            case 'vpd':
                 this.applyVpdSetting(currentSettings, setting, value);
                 break;
             default:
@@ -281,11 +282,7 @@ class PortModeHandler {
         }
 
         try {
-            await this.client.updateDeviceModeSettings(
-                deviceId,
-                portId,
-                Object.entries(currentSettings)
-            );
+            await this.client.updateDeviceModeSettings(deviceId, portId, Object.entries(currentSettings));
             this.adapter.log.debug(`${category}.${setting} erfolgreich gesetzt`);
         } catch (apiError) {
             this.adapter.log.error(`API-Fehler bei ${category}.${setting}: ${apiError.message}`);
@@ -296,10 +293,10 @@ class PortModeHandler {
 
     applyTimerSetting(settings, setting, value) {
         switch (setting) {
-            case "toOnMinutes":
+            case 'toOnMinutes':
                 settings.acitveTimerOn = parseInt(value) * 60;
                 break;
-            case "toOffMinutes":
+            case 'toOffMinutes':
                 settings.acitveTimerOff = parseInt(value) * 60;
                 break;
             default:
@@ -311,10 +308,10 @@ class PortModeHandler {
 
     applyCycleSetting(settings, setting, value) {
         switch (setting) {
-            case "onMinutes":
+            case 'onMinutes':
                 settings.activeCycleOn = parseInt(value) * 60;
                 break;
-            case "offMinutes":
+            case 'offMinutes':
                 settings.activeCycleOff = parseInt(value) * 60;
                 break;
             default:
@@ -326,14 +323,14 @@ class PortModeHandler {
 
     applyScheduleSetting(settings, setting, value) {
         switch (setting) {
-            case "startEnabled":
+            case 'startEnabled':
                 settings.schedStartTime = value ? SCHEDULE_MIDNIGHT_VALUE : SCHEDULE_DISABLED_VALUE;
                 break;
-            case "endEnabled":
+            case 'endEnabled':
                 settings.schedEndtTime = value ? SCHEDULE_EOD_VALUE : SCHEDULE_DISABLED_VALUE;
                 break;
-            case "startTime": {
-                const parts = String(value).split(":");
+            case 'startTime': {
+                const parts = String(value).split(':');
                 if (parts.length === 2) {
                     settings.schedStartTime = parseInt(parts[0]) * 60 + parseInt(parts[1]);
                 } else {
@@ -341,8 +338,8 @@ class PortModeHandler {
                 }
                 break;
             }
-            case "endTime": {
-                const parts = String(value).split(":");
+            case 'endTime': {
+                const parts = String(value).split(':');
                 if (parts.length === 2) {
                     settings.schedEndtTime = parseInt(parts[0]) * 60 + parseInt(parts[1]);
                 } else {
@@ -359,54 +356,56 @@ class PortModeHandler {
 
     applyAutoSetting(settings, setting, value) {
         switch (setting) {
-            case "settingsMode": {
+            case 'settingsMode': {
                 const idx = SETTINGS_MODE_OPTIONS.indexOf(value);
-                if (idx >= 0) settings.settingMode = idx;
+                if (idx >= 0) {
+                    settings.settingMode = idx;
+                }
                 break;
             }
-            case "tempHighEnabled":
+            case 'tempHighEnabled':
                 settings.activeHt = value ? 1 : 0;
                 break;
-            case "tempHighTrigger": {
+            case 'tempHighTrigger': {
                 const c = parseInt(value);
                 settings.devHt = c;
                 settings.devHtf = Math.round(c * 1.8 + 32);
                 break;
             }
-            case "tempLowEnabled":
+            case 'tempLowEnabled':
                 settings.activeLt = value ? 1 : 0;
                 break;
-            case "tempLowTrigger": {
+            case 'tempLowTrigger': {
                 const c = parseInt(value);
                 settings.devLt = c;
                 settings.devLtf = Math.round(c * 1.8 + 32);
                 break;
             }
-            case "humidityHighEnabled":
+            case 'humidityHighEnabled':
                 settings.activeHh = value ? 1 : 0;
                 break;
-            case "humidityHighTrigger":
+            case 'humidityHighTrigger':
                 settings.devHh = parseInt(value);
                 break;
-            case "humidityLowEnabled":
+            case 'humidityLowEnabled':
                 settings.activeLh = value ? 1 : 0;
                 break;
-            case "humidityLowTrigger":
+            case 'humidityLowTrigger':
                 settings.devLh = parseInt(value);
                 break;
-            case "targetTempEnabled":
+            case 'targetTempEnabled':
                 settings.targetTSwitch = value ? 1 : 0;
                 break;
-            case "targetTemp": {
+            case 'targetTemp': {
                 const c = parseInt(value);
                 settings.targetTemp = c;
                 settings.targetTempF = Math.round(c * 1.8 + 32);
                 break;
             }
-            case "targetHumidityEnabled":
+            case 'targetHumidityEnabled':
                 settings.targetHumiSwitch = value ? 1 : 0;
                 break;
-            case "targetHumidity":
+            case 'targetHumidity':
                 settings.targetHumi = parseInt(value);
                 break;
             default:
@@ -418,27 +417,29 @@ class PortModeHandler {
 
     applyVpdSetting(settings, setting, value) {
         switch (setting) {
-            case "settingsMode": {
+            case 'settingsMode': {
                 const idx = SETTINGS_MODE_OPTIONS.indexOf(value);
-                if (idx >= 0) settings.vpdSettingMode = idx;
+                if (idx >= 0) {
+                    settings.vpdSettingMode = idx;
+                }
                 break;
             }
-            case "highEnabled":
+            case 'highEnabled':
                 settings.activeHtVpd = value ? 1 : 0;
                 break;
-            case "highTrigger":
+            case 'highTrigger':
                 settings.activeHtVpdNums = Math.round(parseFloat(value) * 10);
                 break;
-            case "lowEnabled":
+            case 'lowEnabled':
                 settings.activeLtVpd = value ? 1 : 0;
                 break;
-            case "lowTrigger":
+            case 'lowTrigger':
                 settings.activeLtVpdNums = Math.round(parseFloat(value) * 10);
                 break;
-            case "targetEnabled":
+            case 'targetEnabled':
                 settings.targetVpdSwitch = value ? 1 : 0;
                 break;
-            case "target":
+            case 'target':
                 settings.targetVpd = Math.round(parseFloat(value) * 10);
                 break;
             default:

package/lib/handlers/portSettingsHandler.js

@@ -3,17 +3,14 @@
  * Verarbeitet Änderungen an den erweiterten Port-Einstellungen
  */
 
-"use strict";
+'use strict';
 
-const { 
-    ADVANCED_SETTINGS_KEY, 
-    DEVICE_LOAD_TYPE_OPTIONS,
-    DYNAMIC_RESPONSE_OPTIONS 
-} = require("../constants");
+const { ADVANCED_SETTINGS_KEY, DEVICE_LOAD_TYPE_OPTIONS, DYNAMIC_RESPONSE_OPTIONS } = require('../constants');
 
 class PortSettingsHandler {
     /**
      * Erstellt einen neuen PortSettingsHandler
+     *
      * @param {object} stateManager - Referenz zum StateManager
      */
     constructor(stateManager) {
@@ -24,15 +21,17 @@ class PortSettingsHandler {
 
     /**
      * Setzt den API-Client für diesen Handler
+     *
      * @param {object} client - AC Infinity API-Client
      */
     setClient(client) {
         this.client = client;
-        this.adapter.log.debug("API-Client erfolgreich an PortSettingsHandler übergeben");
+        this.adapter.log.debug('API-Client erfolgreich an PortSettingsHandler übergeben');
     }
 
     /**
      * Verarbeitet Änderungen an erweiterten Port-Einstellungen
+     *
      * @param {string} deviceId - Geräte-ID
      * @param {number} portId - Port-ID
      * @param {Array} path - Pfadkomponenten
@@ -40,41 +39,45 @@ class PortSettingsHandler {
      */
     async handlePortAdvancedSettingsChange(deviceId, portId, path, value) {
         if (path.length < 1) {
-            this.adapter.log.warn(`Ungültiger Pfad für erweiterte Port-Einstellungen: ${path.join(".")}`);
+            this.adapter.log.warn(`Ungültiger Pfad für erweiterte Port-Einstellungen: ${path.join('.')}`);
             return;
         }
-        
+
         const setting = path[0];
         const statePath = `devices.${deviceId}.ports.${portId}.settings.${setting}`;
-        
+
         // UI sofort aktualisieren, um Flackern zu vermeiden
         await this.stateManager.updateUIState(statePath, value);
-        
+
         try {
             // Prüfen, ob der Client gesetzt ist
             if (!this.client) {
-                throw new Error("API-Client nicht gesetzt. Kann Port-Einstellungen nicht aktualisieren.");
+                throw new Error('API-Client nicht gesetzt. Kann Port-Einstellungen nicht aktualisieren.');
             }
 
             // Hole den Port-Namen für den Aktualisierungsaufruf
             let portName = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.info.name`);
             portName = portName && portName.val ? portName.val : `Port ${portId}`;
-            
+
             // Aktuelle Temperatureinheit abrufen
             const tempUnitState = await this.adapter.getStateAsync(`devices.${deviceId}.settings.temperatureUnit`);
-            const isUnitC = tempUnitState && tempUnitState.val === "C";
-            
-            this.adapter.log.debug(`Verarbeite Port-Einstellungsänderung: deviceId=${deviceId}, portId=${portId}, setting=${setting}, value=${value}`);
-            
+            const isUnitC = tempUnitState && tempUnitState.val === 'C';
+
+            this.adapter.log.debug(
+                `Verarbeite Port-Einstellungsänderung: deviceId=${deviceId}, portId=${portId}, setting=${setting}, value=${value}`,
+            );
+
             try {
                 switch (setting) {
-                    case "deviceType": {
+                    case 'deviceType': {
                         // value is the numeric load type ID (ioBroker sends the key of the states map)
                         const loadTypeId = parseInt(value);
                         if (!isNaN(loadTypeId) && DEVICE_LOAD_TYPE_OPTIONS[loadTypeId] !== undefined) {
-                            this.adapter.log.debug(`Sende Gerätetyp an API: deviceId=${deviceId}, portId=${portId}, loadTypeId=${loadTypeId} (${DEVICE_LOAD_TYPE_OPTIONS[loadTypeId]})`);
+                            this.adapter.log.debug(
+                                `Sende Gerätetyp an API: deviceId=${deviceId}, portId=${portId}, loadTypeId=${loadTypeId} (${DEVICE_LOAD_TYPE_OPTIONS[loadTypeId]})`,
+                            );
                             await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                                [ADVANCED_SETTINGS_KEY.DEVICE_LOAD_TYPE, loadTypeId]
+                                [ADVANCED_SETTINGS_KEY.DEVICE_LOAD_TYPE, loadTypeId],
                             ]);
                             this.adapter.log.debug(`API-Antwort für Gerätetyp erfolgreich`);
                         } else {
@@ -82,13 +85,15 @@ class PortSettingsHandler {
                         }
                         break;
                     }
-                        
-                    case "dynamicResponse": {
+
+                    case 'dynamicResponse': {
                         const responseTypeIndex = DYNAMIC_RESPONSE_OPTIONS.indexOf(value);
                         if (responseTypeIndex >= 0) {
-                            this.adapter.log.debug(`Sende dynamischen Antworttyp an API: deviceId=${deviceId}, portId=${portId}, type=${value}, index=${responseTypeIndex}`);
+                            this.adapter.log.debug(
+                                `Sende dynamischen Antworttyp an API: deviceId=${deviceId}, portId=${portId}, type=${value}, index=${responseTypeIndex}`,
+                            );
                             await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                                [ADVANCED_SETTINGS_KEY.DYNAMIC_RESPONSE_TYPE, responseTypeIndex]
+                                [ADVANCED_SETTINGS_KEY.DYNAMIC_RESPONSE_TYPE, responseTypeIndex],
                             ]);
                             this.adapter.log.debug(`API-Antwort für dynamischen Antworttyp erfolgreich`);
                         } else {
@@ -96,114 +101,136 @@ class PortSettingsHandler {
                         }
                         break;
                     }
-                        
-                    case "dynamicTransitionTemp": {
+
+                    case 'dynamicTransitionTemp': {
                         const transitionTempValue = parseInt(value);
-                        this.adapter.log.debug(`Sende dynamische Übergangstemperatur an API: deviceId=${deviceId}, portId=${portId}, temp=${transitionTempValue}, isUnitC=${isUnitC}`);
-                        
+                        this.adapter.log.debug(
+                            `Sende dynamische Übergangstemperatur an API: deviceId=${deviceId}, portId=${portId}, temp=${transitionTempValue}, isUnitC=${isUnitC}`,
+                        );
+
                         if (isUnitC) {
                             await this.client.updateAdvancedSettings(deviceId, portId, portName, [
                                 [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_TEMP, transitionTempValue],
-                                [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_TEMP_F, transitionTempValue * 2]
+                                [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_TEMP_F, transitionTempValue * 2],
                             ]);
                         } else {
                             await this.client.updateAdvancedSettings(deviceId, portId, portName, [
                                 [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_TEMP, Math.floor(transitionTempValue / 2)],
-                                [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_TEMP_F, transitionTempValue]
+                                [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_TEMP_F, transitionTempValue],
                             ]);
                         }
-                        
+
                         this.adapter.log.debug(`API-Antwort für dynamische Übergangstemperatur erfolgreich`);
                         break;
                     }
-                        
-                    case "dynamicBufferTemp": {
+
+                    case 'dynamicBufferTemp': {
                         const bufferTempValue = parseInt(value);
-                        this.adapter.log.debug(`Sende dynamische Puffertemperatur an API: deviceId=${deviceId}, portId=${portId}, temp=${bufferTempValue}, isUnitC=${isUnitC}`);
-                        
+                        this.adapter.log.debug(
+                            `Sende dynamische Puffertemperatur an API: deviceId=${deviceId}, portId=${portId}, temp=${bufferTempValue}, isUnitC=${isUnitC}`,
+                        );
+
                         if (isUnitC) {
                             await this.client.updateAdvancedSettings(deviceId, portId, portName, [
                                 [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_TEMP, bufferTempValue],
-                                [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_TEMP_F, bufferTempValue * 2]
+                                [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_TEMP_F, bufferTempValue * 2],
                             ]);
                         } else {
                             await this.client.updateAdvancedSettings(deviceId, portId, portName, [
                                 [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_TEMP, Math.floor(bufferTempValue / 2)],
-                                [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_TEMP_F, bufferTempValue]
+                                [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_TEMP_F, bufferTempValue],
                             ]);
                         }
-                        
+
                         this.adapter.log.debug(`API-Antwort für dynamische Puffertemperatur erfolgreich`);
                         break;
                     }
-                        
+
                     // Weitere Fälle für andere Einstellungen...
-                    case "dynamicTransitionHumidity": {
-                        this.adapter.log.debug(`Sende dynamische Übergangsfeuchtigkeit an API: deviceId=${deviceId}, portId=${portId}, humidity=${parseInt(value)}`);
+                    case 'dynamicTransitionHumidity': {
+                        this.adapter.log.debug(
+                            `Sende dynamische Übergangsfeuchtigkeit an API: deviceId=${deviceId}, portId=${portId}, humidity=${parseInt(value)}`,
+                        );
                         await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                            [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_HUMIDITY, parseInt(value)]
+                            [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_HUMIDITY, parseInt(value)],
                         ]);
                         this.adapter.log.debug(`API-Antwort für dynamische Übergangsfeuchtigkeit erfolgreich`);
                         break;
                     }
-                        
-                    case "dynamicBufferHumidity": {
-                        this.adapter.log.debug(`Sende dynamische Pufferfeuchtigkeit an API: deviceId=${deviceId}, portId=${portId}, humidity=${parseInt(value)}`);
+
+                    case 'dynamicBufferHumidity': {
+                        this.adapter.log.debug(
+                            `Sende dynamische Pufferfeuchtigkeit an API: deviceId=${deviceId}, portId=${portId}, humidity=${parseInt(value)}`,
+                        );
                         await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                            [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_HUMIDITY, parseInt(value)]
+                            [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_HUMIDITY, parseInt(value)],
                         ]);
                         this.adapter.log.debug(`API-Antwort für dynamische Pufferfeuchtigkeit erfolgreich`);
                         break;
                     }
-                        
-                    case "dynamicTransitionVPD": {
+
+                    case 'dynamicTransitionVPD': {
                         const transitionVpdValue = Math.round(parseFloat(value) * 10);
-                        this.adapter.log.debug(`Sende dynamisches Übergangs-VPD an API: deviceId=${deviceId}, portId=${portId}, vpd=${value}, scaledValue=${transitionVpdValue}`);
+                        this.adapter.log.debug(
+                            `Sende dynamisches Übergangs-VPD an API: deviceId=${deviceId}, portId=${portId}, vpd=${value}, scaledValue=${transitionVpdValue}`,
+                        );
                         await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                            [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_VPD, transitionVpdValue]
+                            [ADVANCED_SETTINGS_KEY.DYNAMIC_TRANSITION_VPD, transitionVpdValue],
                         ]);
                         this.adapter.log.debug(`API-Antwort für dynamisches Übergangs-VPD erfolgreich`);
                         break;
                     }
-                        
-                    case "dynamicBufferVPD": {
+
+                    case 'dynamicBufferVPD': {
                         const bufferVpdValue = Math.round(parseFloat(value) * 10);
-                        this.adapter.log.debug(`Sende dynamisches Puffer-VPD an API: deviceId=${deviceId}, portId=${portId}, vpd=${value}, scaledValue=${bufferVpdValue}`);
+                        this.adapter.log.debug(
+                            `Sende dynamisches Puffer-VPD an API: deviceId=${deviceId}, portId=${portId}, vpd=${value}, scaledValue=${bufferVpdValue}`,
+                        );
                         await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                            [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_VPD, bufferVpdValue]
+                            [ADVANCED_SETTINGS_KEY.DYNAMIC_BUFFER_VPD, bufferVpdValue],
                         ]);
                         this.adapter.log.debug(`API-Antwort für dynamisches Puffer-VPD erfolgreich`);
                         break;
                     }
-                        
-                    case "sunriseTimerEnabled": {
-                        this.adapter.log.debug(`Sende Sonnenaufgang/Sonnenuntergang-Timer-Aktivierung an API: deviceId=${deviceId}, portId=${portId}, enabled=${value}`);
+
+                    case 'sunriseTimerEnabled': {
+                        this.adapter.log.debug(
+                            `Sende Sonnenaufgang/Sonnenuntergang-Timer-Aktivierung an API: deviceId=${deviceId}, portId=${portId}, enabled=${value}`,
+                        );
                         await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                            [ADVANCED_SETTINGS_KEY.SUNRISE_TIMER_ENABLED, value ? 1 : 0]
+                            [ADVANCED_SETTINGS_KEY.SUNRISE_TIMER_ENABLED, value ? 1 : 0],
                         ]);
-                        this.adapter.log.debug(`API-Antwort für Sonnenaufgang/Sonnenuntergang-Timer-Aktivierung erfolgreich`);
+                        this.adapter.log.debug(
+                            `API-Antwort für Sonnenaufgang/Sonnenuntergang-Timer-Aktivierung erfolgreich`,
+                        );
                         break;
                     }
-                        
-                    case "sunriseTimerMinutes": {
-                        this.adapter.log.debug(`Sende Sonnenaufgang/Sonnenuntergang-Timer-Minuten an API: deviceId=${deviceId}, portId=${portId}, minutes=${parseInt(value)}`);
+
+                    case 'sunriseTimerMinutes': {
+                        this.adapter.log.debug(
+                            `Sende Sonnenaufgang/Sonnenuntergang-Timer-Minuten an API: deviceId=${deviceId}, portId=${portId}, minutes=${parseInt(value)}`,
+                        );
                         await this.client.updateAdvancedSettings(deviceId, portId, portName, [
-                            [ADVANCED_SETTINGS_KEY.SUNRISE_TIMER_DURATION, parseInt(value)]
+                            [ADVANCED_SETTINGS_KEY.SUNRISE_TIMER_DURATION, parseInt(value)],
                         ]);
-                        this.adapter.log.debug(`API-Antwort für Sonnenaufgang/Sonnenuntergang-Timer-Minuten erfolgreich`);
+                        this.adapter.log.debug(
+                            `API-Antwort für Sonnenaufgang/Sonnenuntergang-Timer-Minuten erfolgreich`,
+                        );
                         break;
                     }
-                        
+
                     default:
                         this.adapter.log.warn(`Unbekannte erweiterte Port-Einstellung: ${setting}`);
                 }
             } catch (error) {
-                this.adapter.log.error(`API-Fehler beim Aktualisieren der Port-Einstellung ${setting}: ${error.message}`);
+                this.adapter.log.error(
+                    `API-Fehler beim Aktualisieren der Port-Einstellung ${setting}: ${error.message}`,
+                );
                 if (error.response) {
                     this.adapter.log.error(`API-Antwort: ${JSON.stringify(error.response.data || {})}`);
                 }
             }
-            
+
             // Aktualisierung der Daten auslösen, um die Zustände zu aktualisieren
             await this.stateManager.refreshWithThrottle();
         } catch (error) {
@@ -212,4 +239,4 @@ class PortSettingsHandler {
     }
 }
 
-module.exports = PortSettingsHandler;
+module.exports = PortSettingsHandler;