iobroker.airzone 2.0.3 → 3.0.0

package/LocalApi/Zone.js

@@ -1,10 +1,12 @@
+'use strict';
+
 const Constants = require('./Constants');
 
 class Zone {
     constructor(adapter, localApi)
     {
         this.adapter = adapter;
-        this.localApi = localApi;                       
+        this.localApi = localApi;
     }
 
     /**
@@ -14,8 +16,9 @@ class Zone {
         this.id = parseInt(zoneData['zoneID']);
         this.name = zoneData.hasOwnProperty('name') ? zoneData['name'] : '';
         this.min_temp = zoneData['minTemp'];
-        this.max_temp = zoneData['maxTemp']; 
-        
+        this.max_temp = zoneData['maxTemp'];
+        this.isMaster = zoneData['master'] === 1;
+
         this.path = path+'.Zone'+this.id;
         await this.adapter.setObjectNotExistsAsync(this.path, {
             type: 'device',
@@ -28,25 +31,62 @@ class Zone {
             native: {},
         });
 
-        var unitRaw = zoneData['units']; 
-        var unitName = Constants.UNIT_CONVERTER[unitRaw]["name"];
-        var unitUnit = Constants.UNIT_CONVERTER[unitRaw]["unit"];
+        const unitRaw = zoneData['units'];
+        const unitName = Constants.UNIT_CONVERTER[unitRaw]?.['name'] || 'Unknown';
+        const unitUnit = Constants.UNIT_CONVERTER[unitRaw]?.['unit'] || '°C';
 
         await this.adapter.createPropertyAndInit(this.path, 'id', 'number', true, false, this.id, 'number');
-        await this.adapter.createPropertyAndInit(this.path, 'name', 'string', true, false, this.name, 'text');
+        // Name is writable so user can set custom zone names (API may not return names)
+        await this.adapter.createPropertyAndInit(this.path, 'name', 'string', true, true, this.name || `Zone ${this.id}`, 'text');
         await this.adapter.createPropertyAndInit(this.path, 'min_temp', 'number', true, false, this.min_temp, 'value.min');
         await this.adapter.createPropertyAndInit(this.path, 'max_temp', 'number', true, false, this.max_temp, 'value.max');
-        await this.adapter.createPropertyAndInit(this.path, 'unitRaw', 'string', true, false, unitRaw, 'number');
+        await this.adapter.createPropertyAndInit(this.path, 'unitRaw', 'number', true, false, unitRaw, 'value');
         await this.adapter.createPropertyAndInit(this.path, 'unitName', 'string', true, false, unitName, 'text');
         await this.adapter.createPropertyAndInit(this.path, 'unit', 'string', true, false, unitUnit, 'text');
-        await this.adapter.createProperty(this.path, 'is_on', 'boolean', true, false, 'switch.power');
+        await this.adapter.createPropertyAndInit(this.path, 'master', 'boolean', true, false, this.isMaster, 'indicator');
+        await this.adapter.createProperty(this.path, 'is_on', 'boolean', true, true, 'switch.power');
         await this.adapter.createUnitProperty(this.path, 'current_temperature', 'number', 0, 100, unitUnit, true, false, 'value.temperature');
         await this.adapter.createUnitProperty(this.path, 'current_humidity', 'number', 0, 100, '%', true, false, 'value.humidity');
         await this.adapter.createUnitProperty(this.path, 'target_temperature', 'number', this.min_temp, this.max_temp, unitUnit, true, true, 'value.temperature');
-        
+
+        // Mode property
+        await this.adapter.createProperty(this.path, 'mode', 'number', true, true, 'level.mode.hvac');
+        await this.adapter.createProperty(this.path, 'modeName', 'string', true, false, 'text');
+
+        // Double setpoint support (if available)
+        if (zoneData.hasOwnProperty('setpoint_air_cool')) {
+            await this.adapter.createUnitProperty(this.path, 'setpoint_cool', 'number', this.min_temp, this.max_temp, unitUnit, true, true, 'value.temperature');
+            await this.adapter.createUnitProperty(this.path, 'setpoint_heat', 'number', this.min_temp, this.max_temp, unitUnit, true, true, 'value.temperature');
+            this.adapter.subscribeState(this.path+'.setpoint_cool', this, this.reactToSetpointCoolChange);
+            this.adapter.subscribeState(this.path+'.setpoint_heat', this, this.reactToSetpointHeatChange);
+        }
+
+        // Fan speed (if available)
+        if (zoneData.hasOwnProperty('speed')) {
+            await this.adapter.createProperty(this.path, 'fan_speed', 'number', true, true, 'level');
+            await this.adapter.createProperty(this.path, 'fan_speed_name', 'string', true, false, 'text');
+            this.adapter.subscribeState(this.path+'.fan_speed', this, this.reactToFanSpeedChange);
+        }
+
+        // Sleep timer (if available)
+        if (zoneData.hasOwnProperty('sleep')) {
+            await this.adapter.createProperty(this.path, 'sleep_timer', 'number', true, true, 'level.timer');
+            this.adapter.subscribeState(this.path+'.sleep_timer', this, this.reactToSleepTimerChange);
+        }
+
+        // Air quality (if available)
+        if (zoneData.hasOwnProperty('air_quality')) {
+            await this.adapter.createProperty(this.path, 'air_quality', 'number', true, false, 'value');
+            await this.adapter.createProperty(this.path, 'air_quality_name', 'string', true, false, 'text');
+        }
+
+        // Error indicators
+        await this.adapter.createProperty(this.path, 'errors', 'string', true, false, 'text');
+
         // Register callbacks to react on value changes
         this.adapter.subscribeState(this.path+'.target_temperature', this, this.reactToTargetTemperatureChange);
         this.adapter.subscribeState(this.path+'.is_on', this, this.reactToIsOnChange);
+        this.adapter.subscribeState(this.path+'.mode', this, this.reactToModeChange);
 
         await this.updateData(zoneData);
     }
@@ -55,7 +95,12 @@ class Zone {
      * Synchronized the zone data from airzone into the iobroker data points
      */
     async updateData(zoneData)
-    { 
+    {
+        // Only update name if API returns one (don't overwrite user-set names)
+        if (zoneData['name']) {
+            await this.adapter.updatePropertyValue(this.path, 'name', zoneData['name']);
+        }
+
         this.current_temperature = zoneData['roomTemp'];
         await this.adapter.updatePropertyValue(this.path, 'current_temperature', this.current_temperature);
 
@@ -65,15 +110,61 @@ class Zone {
         this.target_temperature = zoneData['setpoint'];
         await this.adapter.updatePropertyValue(this.path, 'target_temperature', this.target_temperature);
 
-        this.is_on = zoneData['on'] == '1';
+        this.is_on = zoneData['on'] === 1;
         await this.adapter.updatePropertyValue(this.path, 'is_on', this.is_on);
-    }    
+
+        // Update mode
+        const mode = zoneData['mode'];
+        if (mode !== undefined) {
+            await this.adapter.updatePropertyValue(this.path, 'mode', mode);
+            const modeName = Constants.MODES_CONVERTER[String(mode)]?.['name'] || 'Unknown';
+            await this.adapter.updatePropertyValue(this.path, 'modeName', modeName);
+        }
+
+        // Update double setpoint values (if available)
+        if (zoneData.hasOwnProperty('setpoint_air_cool')) {
+            await this.adapter.updatePropertyValue(this.path, 'setpoint_cool', zoneData['setpoint_air_cool']);
+        }
+        if (zoneData.hasOwnProperty('setpoint_air_heat')) {
+            await this.adapter.updatePropertyValue(this.path, 'setpoint_heat', zoneData['setpoint_air_heat']);
+        }
+
+        // Update fan speed (if available)
+        if (zoneData.hasOwnProperty('speed')) {
+            const speed = zoneData['speed'];
+            await this.adapter.updatePropertyValue(this.path, 'fan_speed', speed);
+            const speedName = Constants.FAN_SPEED_CONVERTER[String(speed)]?.['name'] || 'Unknown';
+            await this.adapter.updatePropertyValue(this.path, 'fan_speed_name', speedName);
+        }
+
+        // Update sleep timer (if available)
+        if (zoneData.hasOwnProperty('sleep')) {
+            await this.adapter.updatePropertyValue(this.path, 'sleep_timer', zoneData['sleep']);
+        }
+
+        // Update air quality (if available)
+        if (zoneData.hasOwnProperty('air_quality')) {
+            const quality = zoneData['air_quality'];
+            await this.adapter.updatePropertyValue(this.path, 'air_quality', quality);
+            const qualityName = Constants.IAQ_SCORE_CONVERTER[String(quality)]?.['name'] || 'Unknown';
+            await this.adapter.updatePropertyValue(this.path, 'air_quality_name', qualityName);
+        }
+
+        // Update errors (if present)
+        if (zoneData.hasOwnProperty('errors')) {
+            const errors = zoneData['errors'];
+            const errorStr = Array.isArray(errors) ? errors.join(', ') : String(errors);
+            await this.adapter.updatePropertyValue(this.path, 'errors', errorStr);
+        } else {
+            await this.adapter.updatePropertyValue(this.path, 'errors', '');
+        }
+    }
 
     /**
      * Is called when the state of target_temperature was changed
      */
     async reactToTargetTemperatureChange(self, id, state) {
-        var temperature = state.val;
+        let temperature = state.val;
         if(self.min_temp != undefined && temperature < self.min_temp)
             temperature = self.min_temp;
         if(self.max_temp != undefined && temperature > self.max_temp)
@@ -85,18 +176,73 @@ class Zone {
     /**
      * Is called when the state of is_on was changed
      */
-    async reactToIsOnChange(self, id, state) {        
+    async reactToIsOnChange(self, id, state) {
         if(state.val)
             await self.turn_on();
         else
             await self.turn_off();
     }
 
+    /**
+     * Is called when the mode was changed
+     */
+    async reactToModeChange(self, id, state) {
+        await self.sendEvent('mode', state.val);
+    }
+
+    /**
+     * Is called when the cooling setpoint was changed
+     */
+    async reactToSetpointCoolChange(self, id, state) {
+        let temperature = state.val;
+        if(self.min_temp != undefined && temperature < self.min_temp)
+            temperature = self.min_temp;
+        if(self.max_temp != undefined && temperature > self.max_temp)
+            temperature = self.max_temp;
+        await self.sendEvent('setpoint_air_cool', temperature);
+    }
+
+    /**
+     * Is called when the heating setpoint was changed
+     */
+    async reactToSetpointHeatChange(self, id, state) {
+        let temperature = state.val;
+        if(self.min_temp != undefined && temperature < self.min_temp)
+            temperature = self.min_temp;
+        if(self.max_temp != undefined && temperature > self.max_temp)
+            temperature = self.max_temp;
+        await self.sendEvent('setpoint_air_heat', temperature);
+    }
+
+    /**
+     * Is called when the fan speed was changed
+     */
+    async reactToFanSpeedChange(self, id, state) {
+        const speed = Math.max(0, Math.min(7, Math.round(state.val)));
+        await self.sendEvent('speed', speed);
+    }
+
+    /**
+     * Is called when the sleep timer was changed
+     */
+    async reactToSleepTimerChange(self, id, state) {
+        // Sleep timer values: 0 = off, 30, 60, 90 minutes
+        const validValues = [0, 30, 60, 90];
+        let value = state.val;
+        if (!validValues.includes(value)) {
+            // Find the closest valid value
+            value = validValues.reduce((prev, curr) =>
+                Math.abs(curr - value) < Math.abs(prev - value) ? curr : prev
+            );
+        }
+        await self.sendEvent('sleep', value);
+    }
+
     /**
      * Send event to the airzone cloud
      */
     async sendEvent(option, value) {
-        await this.localApi.sendUpdate(this.id, option, value)        
+        await this.localApi.sendUpdate(this.id, option, value);
     }
 
     /**
@@ -109,7 +255,7 @@ class Zone {
     /**
      * Turn zone off
      */
-     async turn_off() {
+    async turn_off() {
         await this.sendEvent('on', 0);
     }
 }

package/README.md

@@ -11,6 +11,23 @@ Control and monitor airzone devices with ioBroker.
 [![Build Status](https://travis-ci.com/SilentPhoenix11/ioBroker.airzone.svg?branch=master)](https://travis-ci.com/github/SilentPhoenix11/ioBroker.airzone)
 
 ## Changelog
+### 3.0.0
+* (SilentPhoenix11) **BREAKING**: Requires Node.js >= 18 and js-controller >= 5.0.0
+* (SilentPhoenix11) Migrated from deprecated `request` to `axios` HTTP client
+* (SilentPhoenix11) Updated to @iobroker/adapter-core 3.x
+* (SilentPhoenix11) Added `info.connection` state for connection status
+* (SilentPhoenix11) Added support for fan speed control (`fanSpeed`, `fanSpeedRaw`)
+* (SilentPhoenix11) Added sleep timer support (`sleepTime`)
+* (SilentPhoenix11) Added double setpoint support (`setpointCool`, `setpointHeat`)
+* (SilentPhoenix11) Added zone mode control (`mode`, `modeRaw`)
+* (SilentPhoenix11) Added zone error tracking (`errors`)
+* (SilentPhoenix11) Zone names are now editable
+* (SilentPhoenix11) Added IAQ sensor support (CO2, PM2.5, PM10, TVOC)
+* (SilentPhoenix11) Added API version and webserver info endpoints
+* (SilentPhoenix11) Fixed HTTP parser issue with Airzone devices (non-standard LF line endings)
+* (SilentPhoenix11) Uses adapter timers instead of global setTimeout
+* (SilentPhoenix11) Migrated to ESLint 9 flat config
+
 ### 2.0.3
 * (SilentPhoenix11) Small fixes
 

package/Utils/asyncRequest.js

@@ -1,94 +1,137 @@
-const util = require('util');
-const request = require("request");
-const asyncRequest = util.promisify(request);
+'use strict';
+
+const axios = require('axios');
+
+// Create axios instance with default config for Airzone API
+const axiosInstance = axios.create({
+    timeout: 10000,
+    headers: {
+        'Content-Type': 'application/json'
+    }
+});
 
 class AsyncRequest {
 
+    /**
+     * Perform a POST request to the Airzone API
+     * @param {string} url - The URL to send the request to
+     * @param {object} data - The data to send (will be serialized to JSON)
+     * @returns {Promise<object>} - Response object with statusCode and body/errors
+     */
     static async jsonPostRequest(url, data) {
-        
-        const response = await asyncRequest({
-            method: 'POST',
-            uri: url,
-            headers: {
-                'Content-Type': 'application/json'
-            },            
-            body: data
-        });
+        try {
+            // Parse data if it's a string
+            const requestData = typeof data === 'string' ? JSON.parse(data) : data;
 
-        var result;
-        
-        if(response.error)
-        {
-            result = JSON.stringify({statusCode:response.statusCode,errors:error});
-        }
-        else
-        {
-            var body = response.body;
-            var errorMsg = JSON.parse(body)["errors"];
-            if(errorMsg)
-                result = JSON.stringify({statusCode:response.statusCode,errors:errorMsg});
-            else
-                result = JSON.stringify({statusCode:response.statusCode,body:response.body});
-        }        
+            const response = await axiosInstance.post(url, requestData);
+
+            // Check for API-level errors in response
+            if (response.data && response.data.errors) {
+                return {
+                    statusCode: response.status,
+                    errors: response.data.errors
+                };
+            }
 
-        return JSON.parse(result);        
+            return {
+                statusCode: response.status,
+                body: JSON.stringify(response.data)
+            };
+        } catch (error) {
+            if (error.response) {
+                // Server responded with error status
+                const errorData = error.response.data;
+                return {
+                    statusCode: error.response.status,
+                    errors: errorData?.errors || errorData?.message || error.message
+                };
+            }
+            // Network error or timeout
+            return {
+                statusCode: 0,
+                errors: error.message
+            };
+        }
     }
 
+    /**
+     * Perform a PUT request to the Airzone API
+     * @param {string} url - The URL to send the request to
+     * @param {object} data - The data to send (will be serialized to JSON)
+     * @returns {Promise<object>} - Response object with statusCode and body/errors
+     */
     static async jsonPutRequest(url, data) {
-        
-        const response = await asyncRequest({
-            method: 'PUT',
-            uri: url,
-            headers: {
-                'Content-Type': 'application/json'
-            },            
-            body: data
-        });
+        try {
+            // Parse data if it's a string
+            const requestData = typeof data === 'string' ? JSON.parse(data) : data;
 
-        var result;
-        
-        if(response.error)
-        {
-            result = JSON.stringify({statusCode:response.statusCode,errors:error});
-        }
-        else
-        {
-            var body = response.body;
-            var errorMsg = JSON.parse(body)["errors"];
-            if(errorMsg)
-                result = JSON.stringify({statusCode:response.statusCode,errors:errorMsg});
-            else
-                result = JSON.stringify({statusCode:response.statusCode,body:response.body});
-        }        
+            const response = await axiosInstance.put(url, requestData);
 
-        return JSON.parse(result);        
-    }
+            // Check for API-level errors in response
+            if (response.data && response.data.errors) {
+                return {
+                    statusCode: response.status,
+                    errors: response.data.errors
+                };
+            }
 
+            return {
+                statusCode: response.status,
+                body: JSON.stringify(response.data)
+            };
+        } catch (error) {
+            if (error.response) {
+                // Server responded with error status
+                const errorData = error.response.data;
+                return {
+                    statusCode: error.response.status,
+                    errors: errorData?.errors || errorData?.message || error.message
+                };
+            }
+            // Network error or timeout
+            return {
+                statusCode: 0,
+                errors: error.message
+            };
+        }
+    }
 
+    /**
+     * Perform a GET request to the Airzone API
+     * @param {string} url - The URL to send the request to
+     * @returns {Promise<object>} - Response object with statusCode and body/errors
+     */
     static async jsonGetRequest(url) {
-        
-        const response = await asyncRequest({
-            method: 'GET',
-            uri: url
-        });
+        try {
+            const response = await axiosInstance.get(url);
 
-        var result;
-        
-        if(response.error)
-        {
-            result = JSON.stringify({statusCode:response.statusCode,errors:error});
-        }
-        else
-        {
-            var body = response.body;
-            var errorMsg = JSON.parse(body)["errors"];
-            if(errorMsg)
-                result = JSON.stringify({statusCode:response.statusCode,errors:errorMsg});
-            else
-                result = JSON.stringify({statusCode:response.statusCode,body:response.body});
-        }        
+            // Check for API-level errors in response
+            if (response.data && response.data.errors) {
+                return {
+                    statusCode: response.status,
+                    errors: response.data.errors
+                };
+            }
 
-        return JSON.parse(result);        
+            return {
+                statusCode: response.status,
+                body: JSON.stringify(response.data)
+            };
+        } catch (error) {
+            if (error.response) {
+                // Server responded with error status
+                const errorData = error.response.data;
+                return {
+                    statusCode: error.response.status,
+                    errors: errorData?.errors || errorData?.message || error.message
+                };
+            }
+            // Network error or timeout
+            return {
+                statusCode: 0,
+                errors: error.message
+            };
+        }
     }
 }
 

package/eslint.config.js

@@ -0,0 +1,30 @@
+const js = require('@eslint/js');
+const globals = require('globals');
+
+module.exports = [
+    js.configs.recommended,
+    {
+        languageOptions: {
+            ecmaVersion: 2022,
+            sourceType: 'commonjs',
+            globals: {
+                ...globals.node,
+                ...globals.mocha
+            }
+        },
+        rules: {
+            'indent': ['error', 4, { 'SwitchCase': 1 }],
+            'no-console': 'off',
+            'no-var': 'error',
+            'prefer-const': 'error',
+            'no-trailing-spaces': 'error',
+            'quotes': ['error', 'single', { 'avoidEscape': true, 'allowTemplateLiterals': true }],
+            'semi': ['error', 'always'],
+            'no-prototype-builtins': 'off',
+            'no-unused-vars': ['error', { 'argsIgnorePattern': '^_', 'varsIgnorePattern': '^_', 'caughtErrorsIgnorePattern': '^_' }]
+        }
+    },
+    {
+        ignores: ['node_modules/**', '.git/**', 'gulpfile.js', 'admin/words.js']
+    }
+];

package/io-package.json

@@ -1,8 +1,20 @@
 {
    "common":{
       "name":"airzone",
-      "version":"2.0.3",
+      "version":"3.0.0",
       "news":{
+         "3.0.0":{
+            "en": "Migrated from request to axios, Node.js 18+, added info.connection, extended API support",
+            "de": "Migration von request zu axios, Node.js 18+, info.connection hinzugefügt, erweiterte API-Unterstützung",
+            "ru": "Переход с request на axios, Node.js 18+, добавлен info.connection, расширенная поддержка API",
+            "pt": "Migração de request para axios, Node.js 18+, info.connection adicionado, suporte estendido à API",
+            "nl": "Migratie van request naar axios, Node.js 18+, info.connection toegevoegd, uitgebreide API-ondersteuning",
+            "fr": "Migration de request vers axios, Node.js 18+, info.connection ajouté, support API étendu",
+            "it": "Migrazione da request ad axios, Node.js 18+, aggiunto info.connection, supporto API esteso",
+            "es": "Migración de request a axios, Node.js 18+, info.connection añadido, soporte API extendido",
+            "pl": "Migracja z request do axios, Node.js 18+, dodano info.connection, rozszerzona obsługa API",
+            "zh-cn": "从request迁移到axios，Node.js 18+，添加info.connection，扩展API支持"
+         },
          "1.0.0":{
             "en": "initial release",
             "de": "Erstveröffentlichung",
@@ -156,13 +168,14 @@
       "loglevel":"info",
       "mode":"daemon",
       "type":"climate-control",
-	   "compact":true,
+      "compact":false,
       "connectionType":"local",
-	   "dataSource":"poll",      
-      "materialize":true,      
+      "dataSource":"poll",      
+      "materialize":true,
+      "nodeProcessParams": ["--insecure-http-parser"],
       "dependencies":[
          {
-            "js-controller":">=2.0.0"
+            "js-controller":">=5.0.0"
          }
       ]
    },
@@ -174,5 +187,27 @@
    "encryptedNative": [],
    "protectedNative": [],
    "objects":[],
-   "instanceObjects":[]
+   "instanceObjects":[
+      {
+         "_id": "info",
+         "type": "channel",
+         "common": {
+            "name": "Information"
+         },
+         "native": {}
+      },
+      {
+         "_id": "info.connection",
+         "type": "state",
+         "common": {
+            "role": "indicator.connected",
+            "name": "Device or service connected",
+            "type": "boolean",
+            "read": true,
+            "write": false,
+            "def": false
+         },
+         "native": {}
+      }
+   ]
 }