iobroker.airzone 1.0.4 → 2.0.3

package/LocalApi/AirzoneLocalApi.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const AsyncRequest = require('../Utils/asyncRequest');
+const System = require('./System')
+
+// Allow to connect to Airzone local API
+
+let log;
+let adapter;
+class AirzoneLocalApi {
+    constructor(a, local_ip)
+    {
+        adapter = a;
+        log = a.log;        
+        this.local_ip = local_ip;
+    }
+
+    async init(system_id) {
+        
+        this.system = new System(adapter, this, system_id);
+        await this.system.init();
+    }
+    
+    async update() {
+        if(this.system == undefined)
+            return;
+
+        await this.system.update();
+    }
+
+    logInfo(msg) {
+        log.info(msg);
+    }
+
+    logError(msg) {
+        log.error(msg);
+    }
+
+    async getZoneState() {
+        if(this.system == undefined)
+            return undefined;
+        
+        var url = "http://"+this.local_ip+":3000/api/v1/hvac";
+        var systemId = this.system.id;
+        var data = '{\"systemID\":'+systemId+', \"ZoneID\":0}';
+        var response = await AsyncRequest.jsonPostRequest(url, data);
+
+        var errors = response["errors"];
+        if(errors)
+        {
+            this.logError("Failed to get zone state: (statusCode: "+response["statusCode"]+") - "+response["errors"]);
+            return undefined;
+        }
+        var body = response["body"];
+        var zones = JSON.parse(body)["data"];
+        
+        return zones;
+    }
+
+    async sendUpdate(zoneid, key, value) 
+    {
+        if(this.system == undefined)
+            return false;
+
+        try
+        {
+            var url = "http://"+this.local_ip+":3000/api/v1/hvac";
+            var systemId = this.system.id;
+            var data = '{\"systemID\":'+systemId+', \"ZoneID\":'+zoneid+', \"'+key+'\":'+value+'}';
+            var response = await AsyncRequest.jsonPutRequest(url, data);
+            var errors = response["errors"];
+            if(errors)
+            {
+                this.logError("Failed to update '"+key+"' with value '"+value+"': (statusCode: "+response["statusCode"]+") - "+response["errors"]);
+                return undefined;
+            }
+            var body = response["body"];
+            var responseData = JSON.parse(body)["data"];
+            return responseData.hasOwnProperty(key);
+        }
+        catch (e) {
+            this.logError('error during sendUpdate '+e+'\r\n'+e.stack);
+        }
+        return false;
+    }
+}
+module.exports = AirzoneLocalApi;

package/LocalApi/Constants.js

@@ -0,0 +1,14 @@
+module.exports = Object.freeze({
+    MODES_CONVERTER : {
+        "1": {"name": "Stop"},
+        "2": {"name": "Cooling"},
+        "3": {"name": "Heating"},
+        "4": {"name": "Fan"},
+        "5": {"name": "Dry"}
+    },
+
+    UNIT_CONVERTER : {
+        "0": {"name": "Celsius", "unit": "°C"},
+        "1": {"name": "Fahrenheit", "unit": "°F"}
+    },
+});

package/LocalApi/System.js

@@ -0,0 +1,150 @@
+const Zone = require('./Zone')
+const AsyncRequest = require('../Utils/asyncRequest');
+const Constants = require('./Constants');
+
+class System {
+    constructor(adapter, localApi, id)
+    {
+        this.adapter = adapter;
+        this.localApi = localApi;                   
+        this.id = id;
+    }
+
+    /**
+     * Initialize the system with the data from the airzone local api
+     */
+    async init() {
+        this.path = "System"+this.id;
+        await this.adapter.setObjectNotExistsAsync(this.path, {
+            type: 'device',
+            common: {
+                name: this.path,
+                type: 'object',
+                read: true,
+                write: false,
+            },
+            native: {},
+        });
+
+        await this.adapter.createProperty(this.path, 'mode_raw', 'number', true, true, 'state');
+        await this.adapter.createProperty(this.path, 'mode', 'string', true, false, 'text');
+
+        this.adapter.subscribeState(this.path+'.mode_raw', this, this.reactToModeRawChange);
+        
+        var masterZone = await this.load_zones(this.path);
+        if(masterZone == undefined)
+            return false;
+
+        await this.updateData(masterZone);
+
+        return true;
+    }
+
+    /**
+     * Synchronized the system data from airzone into the iobroker data points
+     */
+    async updateData(masterZoneData)
+    {                               
+        if(masterZoneData == undefined)
+        {
+            this.localApi.logError("Missing master Zone");
+            return;
+        }            
+
+        this.mode_raw = masterZoneData["mode"];
+        await this.adapter.updatePropertyValue(this.path, 'mode_raw', this.mode_raw);
+        this.mode = Constants.MODES_CONVERTER[this.mode_raw]["name"];
+        await this.adapter.updatePropertyValue(this.path, 'mode', this.mode);
+    }
+   
+    /**
+     * Synchronized the system data from airzone into the iobroker data points and call update for all sub zones
+     */
+    async update() {            
+        var masterZoneData = await this.update_zones();        
+
+        await this.updateData(masterZoneData);
+    }
+
+    /**
+     * Load and initialize the zones of this system from airzone local api
+     */
+    async load_zones(path) {
+
+        var zones_relations = await this.localApi.getZoneState();
+        if(zones_relations == undefined)
+            return undefined;
+
+        var masterZoneData = undefined;
+        this.zones = [];
+        for (let index = 0; index < zones_relations.length; index++) {
+            var zoneData = zones_relations[index];
+            var zone = new Zone(this.adapter, this.localApi);
+            await zone.init(path, zoneData)
+            this.zones[index] = zone;          
+            
+            if(zoneData.hasOwnProperty("mode"))
+            {
+                masterZoneData = zoneData;
+                this.masterZoneId =  this.zones[index].id;
+            }
+        }
+        
+        return masterZoneData;
+    }
+
+    /**
+     * Update zones with the current zone data from airzone local api
+     */
+    async update_zones() {
+                       
+        var zones_relations = await this.localApi.getZoneState();
+        if(zones_relations == undefined)
+            return undefined;
+
+        if(this.zones == undefined)
+            return undefined;
+
+        var masterZoneData = undefined;
+
+        for (let index = 0; index < zones_relations.length; index++) {
+            var zoneData = zones_relations[index];
+            var zId = zoneData["zoneID"];
+            
+            if(zoneData.hasOwnProperty("mode"))
+                masterZoneData = zoneData;
+
+            for(let i = 0;i<this.zones.length;i++) {
+                if(this.zones[i].id == zId) {
+                    await this.zones[i].updateData(zoneData);
+                    break;
+                }
+            }                        
+        }        
+
+        return masterZoneData;
+    }
+    
+    /**
+     * Is called when the state of mode was changed
+     */
+    async reactToModeRawChange(self, id, state) {
+        
+        if(state.val == 0)
+        {
+            self.zones.forEach(zone => {
+                zone.turn_off();
+            });
+        }
+        
+        self.sendEvent('mode', state.val);
+    }
+
+    /**
+     * Send event to the airzone local api
+     */
+    async sendEvent(option, value) {
+        await this.localApi.sendUpdate(this.masterZoneId, option, value)        
+    }    
+}
+module.exports = System;

package/{Cloud → LocalApi}/Zone.js

@@ -1,31 +1,26 @@
 const Constants = require('./Constants');
 
 class Zone {
-    constructor(adapter, airzone)
+    constructor(adapter, localApi)
     {
         this.adapter = adapter;
-        this.airzone = airzone;                       
+        this.localApi = localApi;                       
     }
 
     /**
-     * Initialize the zone with the data from the airzone cloud
+     * Initialize the zone with the data from the airzone local api
      */
     async init(path, zoneData) {
-        this.id = zoneData['id'];
-        this.name = zoneData['name'];
-
-        this.device_id = zoneData['device_id'];
-        this.system_number = zoneData['system_number'];
-        this.zone_number = zoneData['zone_number'];
-
-        this.min_temp = zoneData['lower_conf_limit'];
-        this.max_temp = zoneData['upper_conf_limit']; 
+        this.id = parseInt(zoneData['zoneID']);
+        this.name = zoneData.hasOwnProperty('name') ? zoneData['name'] : '';
+        this.min_temp = zoneData['minTemp'];
+        this.max_temp = zoneData['maxTemp']; 
         
-        this.path = path+'.'+this.name;
+        this.path = path+'.Zone'+this.id;
         await this.adapter.setObjectNotExistsAsync(this.path, {
             type: 'device',
             common: {
-                name: 'Zone_'+this.name,
+                name: 'Zone_'+this.id,
                 type: 'object',
                 read: true,
                 write: false,
@@ -33,18 +28,22 @@ class Zone {
             native: {},
         });
 
-        await this.adapter.createPropertyAndInit(this.path, 'id', 'string', true, false, this.id, 'text');
+        var unitRaw = zoneData['units']; 
+        var unitName = Constants.UNIT_CONVERTER[unitRaw]["name"];
+        var unitUnit = Constants.UNIT_CONVERTER[unitRaw]["unit"];
+
+        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');
         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.createUnitProperty(this.path, 'current_temperature', 'number', 0, 100, '°C', 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, '°C', true, true, 'state');
+        await this.adapter.createPropertyAndInit(this.path, 'unitRaw', 'string', true, false, unitRaw, 'number');
+        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.createProperty(this.path, 'mode_raw', 'number', true, false, 'value');
-        await this.adapter.createProperty(this.path, 'mode', 'string', true, false, 'text');
-        await this.adapter.createProperty(this.path, 'mode_description', 'string', true, false, 'text');
-
+        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');
+        
         // 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);
@@ -57,25 +56,16 @@ class Zone {
      */
     async updateData(zoneData)
     { 
-        this.current_temperature = zoneData['temp'];
+        this.current_temperature = zoneData['roomTemp'];
         await this.adapter.updatePropertyValue(this.path, 'current_temperature', this.current_temperature);
 
         this.current_humidity = zoneData['humidity'];
         await this.adapter.updatePropertyValue(this.path, 'current_humidity', this.current_humidity);
 
-        this.target_temperature = zoneData['consign'];
+        this.target_temperature = zoneData['setpoint'];
         await this.adapter.updatePropertyValue(this.path, 'target_temperature', this.target_temperature);
-                                       
-        this.mode_raw = zoneData['mode'];
-        await this.adapter.updatePropertyValue(this.path, 'mode_raw', this.mode_raw);
-
-        this.mode = Constants.MODES_CONVERTER[this.mode_raw]['name'];
-        await this.adapter.updatePropertyValue(this.path, 'mode', this.mode);
 
-        this.mode_description = Constants.MODES_CONVERTER[this.mode_raw]['description'];        
-        await this.adapter.updatePropertyValue(this.path, 'mode_description', this.mode_description);
-
-        this.is_on = zoneData['state'] == '1' && this.mode_raw > 0;
+        this.is_on = zoneData['on'] == '1';
         await this.adapter.updatePropertyValue(this.path, 'is_on', this.is_on);
     }    
 
@@ -89,16 +79,13 @@ class Zone {
         if(self.max_temp != undefined && temperature > self.max_temp)
             temperature = self.max_temp;
 
-        await self.sendEvent('consign', temperature);
+        await self.sendEvent('setpoint', temperature);
     }
 
     /**
      * Is called when the state of is_on was changed
      */
     async reactToIsOnChange(self, id, state) {        
-        if(self.mode_raw < 1)
-            return;
-
         if(state.val)
             await self.turn_on();
         else
@@ -109,31 +96,21 @@ class Zone {
      * Send event to the airzone cloud
      */
     async sendEvent(option, value) {
-        var payload = {
-            'event': {
-                'cgi': 'modzona',
-                'device_id': this.device_id,
-                'system_number': this.system_number,
-                'zone_number': this.zone_number,
-                'option': option,
-                'value': value,
-            }
-        };
-        await this.airzone.sendEvent(payload);
+        await this.localApi.sendUpdate(this.id, option, value)        
     }
 
     /**
      * Turn zone on
      */
     async turn_on() {
-        await this.sendEvent('state', 1);
+        await this.sendEvent('on', 1);
     }
 
     /**
      * Turn zone off
      */
      async turn_off() {
-        await this.sendEvent('state', 0);
+        await this.sendEvent('on', 0);
     }
 }
 module.exports = Zone;

package/README.md

@@ -7,15 +7,22 @@ Control and monitor airzone devices with ioBroker.
 [![Downloads](https://img.shields.io/npm/dm/iobroker.airzone.svg)](https://www.npmjs.com/package/iobroker.airzone)
 [![Stable](http://iobroker.live/badges/airzone-stable.svg)](http://iobroker.live/badges/airzone-stable.svg)
 [![installed](http://iobroker.live/badges/airzone-installed.svg)](http://iobroker.live/badges/airzone-installed.svg)
-[![Dependency Status](https://img.shields.io/david/SilentPhoenix11/iobroker.airzone.svg)](https://david-dm.org/SilentPhoenix11/iobroker.airzone)
 [![Known Vulnerabilities](https://snyk.io/test/github/SilentPhoenix11/ioBroker.airzone/badge.svg)](https://snyk.io/test/github/SilentPhoenix11/ioBroker.airzone)
 [![Build Status](https://travis-ci.com/SilentPhoenix11/ioBroker.airzone.svg?branch=master)](https://travis-ci.com/github/SilentPhoenix11/ioBroker.airzone)
 
-[![NPM](https://nodei.co/npm/iobroker.airzone.png?downloads=true)](https://nodei.co/npm/iobroker.airzone/)
+## Changelog
+### 2.0.3
+* (SilentPhoenix11) Small fixes
 
-**Tests:** 
+### 2.0.2
+* (SilentPhoenix11) Small fixes
+
+### 2.0.1
+* (SilentPhoenix11) Small fixes
+
+### 2.0.0
+* (SilentPhoenix11) Using the local API instead of cloud web service.
 
-## Changelog
 ### 1.0.4
 * (SilentPhoenix11) Small fixes
 

package/Utils/asyncRequest.js

@@ -34,6 +34,37 @@ class AsyncRequest {
         return JSON.parse(result);        
     }
 
+    static async jsonPutRequest(url, data) {
+        
+        const response = await asyncRequest({
+            method: 'PUT',
+            uri: url,
+            headers: {
+                'Content-Type': 'application/json'
+            },            
+            body: 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});
+        }        
+
+        return JSON.parse(result);        
+    }
+
+
     static async jsonGetRequest(url) {
         
         const response = await asyncRequest({

package/admin/index_m.html

@@ -67,34 +67,30 @@
 
         <div class="row">
             <div class="col s12 m4 l2">
-                <img src="Airzone.png" class="logo" style="width: 150px;">
+                <img src="Airzone.png" class="logo" style="width: 198px;">
             </div>            
         </div>
 
         <div class="row">
-			<div class="col s6 input-field">
-                <input placeholder="mail@me.com" type="text" class="value" id="username"/>
-                <label for="username" class="translate">Username</label>
-            </div>
-			
-			<div class="col s6 input-field">
-                <input type="password" class="value" id="password" />
-                <label for="password" class="translate">Password</label>
-            </div>
+			<div class="input-field col s12 m4 l3">
+                <input placeholder="192.168.178.1" type="text" minlength="7" maxlength="15" size="15" pattern="^((\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.){3}(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$" class="value validate" id="local_ip">
+                <label data-error="invalid format" data-success="ok" for="local_ip" class="translate">Local IP</label>
+            </div>		
         </div>
-        <div class="row">		
-			<div class="col s6 input-field">
-                <input placeholder="https://airzonecloud.com" type="text" class="value" id="base_url" />
-                <label for="base_url" class="translate">Base url</label><span class="helper-text translate">(default is https://airzonecloud.com)</span>
+        <div class="row">
+            <div class="input-field col s12 m4 l3">
+                <input placeholder="1" type="number" class="value validate" id="system_id" min="1"/>
+                <label data-error="numbers only" data-success="ok" class="translate active" for="system_id" class="translate">System Id</label>
+                <span class="helper-text translate">(default is 1)</span>
             </div>
-
+        </div>
+        <div class="row">
             <div class="input-field col s12 m4 l3">
-                <input placeholder="30" name="synchronization" type="number" id="sync_time" class="value validate" />
-                <label data-error="numbers only" data-success="ok" class="translate active" for="sync_time" class="translate">Sync time</label><span class="helper-text translate">s (default is 30 s, minimum is 15 s)</span>
+                <input placeholder="5" type="number" id="sync_time" class="value validate" min="1"/>
+                <label data-error="numbers only" data-success="ok" class="translate active" for="sync_time" class="translate">Sync time</label>
+                <span class="helper-text translate">(default is 5 s, minimum is 1 s)</span>
             </div>
-			
         </div>
-
     </div>
 
 </body>

package/admin/words.js

@@ -3,53 +3,41 @@
 
 systemDictionary = {
     "Adapter settings for airzone cloud": {
-        "en": "Adapter settings for airzone cloud",
-        "de": "Adaptereinstellungen für die Luftzonenwolke",
-        "ru": "Настройки адаптера для облака airzone",
-        "pt": "Configurações do adaptador para nuvem airzone",
-        "nl": "Adapterinstellingen voor Airzone Cloud",
-        "fr": "Paramètres de l'adaptateur pour le cloud airzone",
-        "it": "Impostazioni dell'adattatore per airzone cloud",
-        "es": "Configuración del adaptador para airzone cloud",
-        "pl": "Ustawienia adaptera dla chmury airzone",
-        "zh-cn": "Airzone Cloud的适配器设置"
+        "en": "Adapter settings for airzone local api",
+        "de": "Adaptereinstellungen für airzone local api",
+        "ru": "Настройки адаптера для airzone local api",
+        "pt": "Ajustes do adaptador para api local de zona aérea",
+        "nl": "Adapter instellingen voor airzone local api",
+        "fr": "Paramètres de l'adaptateur pour l'api local d'airzone",
+        "it": "Impostazioni dell'adattatore per airzone local api",
+        "es": "Configuración del adaptador para la api local de airzone",
+        "pl": "Ustawienia adaptera dla airzone local api",
+        "zh-cn": "Airzone本地api的适配器设置"
       },
-      "username": {
-        "en": "username",
-        "de": "Benutzername",
-        "ru": "имя пользователя",
-        "pt": "nome do usuário",
-        "nl": "gebruikersnaam",
-        "fr": "Nom d'utilisateur",
-        "it": "nome utente",
-        "es": "nombre de usuario",
-        "pl": "Nazwa Użytkownika",
-        "zh-cn": "用户名"
-    },
-    "password": {
-        "en": "password",
-        "de": "Passwort",
-        "ru": "пароль",
-        "pt": "senha",
-        "nl": "wachtwoord",
-        "fr": "le mot de passe",
-        "it": "parola d'ordine",
-        "es": "contraseña",
-        "pl": "hasło",
-        "zh-cn": "密码"
-    },
-    "base_url": {
-        "en": "Base url",
-        "de": "Basis-URL",
-        "ru": "Базовый URL",
-        "pt": "Url de base",
-        "nl": "Basis-URL",
-        "fr": "URL de base",
-        "it": "URL di base",
-        "es": "URL base",
-        "pl": "Podstawowy adres URL",
-        "zh-cn": "基本网址"
-    },
+      "local_ip": {
+        "en": "Local IP address",
+        "de": "Lokale IP-Adresse",
+        "ru": "Локальный IP-адрес",
+        "pt": "Endereço IP local",
+        "nl": "Lokaal IP-adres",
+        "fr": "Adresse IP locale",
+        "it": "Indirizzo IP locale",
+        "es": "Dirección IP local",
+        "pl": "Lokalny adres IP",
+        "zh-cn": "本地IP地址"
+    },  
+    "system_id": {
+        "en": "Unique ID of the airzone system.",
+        "de": "Eindeutige ID des airzone systems.",
+        "ru": "Уникальный идентификатор системы воздушной зоны.",
+        "pt": "Identificação única do sistema de zonas aéreas.",
+        "nl": "Unieke ID van het airzone-systeem.",
+        "fr": "ID unique du système airzone.",
+        "it": "ID unico del sistema airzone.",
+        "es": "ID único del sistema de zonas aéreas.",
+        "pl": "Unikalny identyfikator systemu stref powietrza.",
+        "zh-cn": "气区系统的唯一ID。"
+    },    
     "sync_time": {
         "en": "Sync time",
         "de": "Synchronisierungszeit",