iobroker.zigbee 3.0.5 → 3.1.4

package/lib/statescontroller.js

@@ -5,19 +5,11 @@ const { EventEmitter } = require('events');
 const statesMapping = require('./devices');
 const { getAdId, getZbId } = require('./utils');
 const fs = require('fs');
-const axios = require('axios');
 const localConfig = require('./localConfig');
-//const { deviceAddCustomCluster } = require('zigbee-herdsman-converters/lib/modernExtend');
-//const { setDefaultAutoSelectFamilyAttemptTimeout } = require('net');
-//const { runInThisContext } = require('vm');
-//const { time } = require('console');
-const { exec } = require('child_process');
-const { tmpdir } = require('os');
 const path = require('path');
-const { throwDeprecation } = require('process');
+const axios = require('axios');
 const zigbeeHerdsmanConvertersUtils = require('zigbee-herdsman-converters/lib/utils');
 
-
 class StatesController extends EventEmitter {
     constructor(adapter) {
         super();
@@ -35,6 +27,7 @@ class StatesController extends EventEmitter {
         this.stashedUnknownModels = [];
         this.debugMessages = { nodevice:{ in:[], out: []} };
         this.debugActive = true;
+        this.deviceQueryBlock = [];
     }
 
     info(message, data) {
@@ -81,7 +74,8 @@ class StatesController extends EventEmitter {
     }
 
     async AddModelFromHerdsman(device, model) {
-        // this.warn('addModelFromHerdsman ' + JSON.stringify(model) + ' ' + JSON.stringify(this.localConfig.getOverrideWithKey(model, 'legacy', true)));
+        const namespace = `${this.adapter.name}.admin`;
+
         if (this.localConfig.getOverrideWithTargetAndKey(model, 'legacy', true)) {
             this.debug('Applying legacy definition for ' + model);
             await this.addLegacyDevice(model);
@@ -97,52 +91,56 @@ class StatesController extends EventEmitter {
                 const srcIcon = (modelDesc ? modelDesc.icon : '');
                 const model_modif = model.replace(/\//g, '-');
                 const pathToAdminIcon = `img/${model_modif}.png`;
-
-                const namespace = `${this.adapter.name}.admin`;
+                // source is a web address
                 if (srcIcon.startsWith('http')) {
-                    this.adapter.fileExists(namespace, srcIcon, async(err, result) => {
-                        if (result) {
-                            this.debug(`icon ${modelDesc.icon} found - no copy needed`);
-                            return;
-                        }
-                        try {
-                            this.downloadIconToAdmin(srcIcon, pathToAdminIcon)
-                            modelDesc.icon = pathToAdminIcon;
-                        } catch (e) {
-                            this.warn(`ERROR : icon not found at ${srcIcon}`);
-                        }
-                        return;
-                    });
+                    try {
+                        //if (modelDesc) modelDesc.icon = pathToAdminIcon;
+                        this.downloadIconToAdmin(srcIcon, pathToAdminIcon)
+                    } catch (err) {
+                        this.warn(`ERROR : unable to download ${srcIcon}: ${err && err.message ? err.message : 'no reason given'}`);
+                    }
                     return;
                 }
+                // source is inline basee64
                 const base64Match = srcIcon.match(/data:image\/(.+);base64,/);
                 if (base64Match) {
                     this.warn(`base 64 Icon matched, trying to save it to disk as ${pathToAdminIcon}`);
-                    modelDesc.icon = pathToAdminIcon;
+                    if (modelDesc) modelDesc.icon = pathToAdminIcon;
                     this.adapter.fileExists(namespace, pathToAdminIcon, async (err,result) => {
                         if (result) {
                             this.warn(`no need to save icon to ${pathToAdminIcon}`);
                             return;
                         }
-                        this.warn(`Saving base64 data to ${pathToAdminIcon}`)
-                        const buffer = new Buffer(srcIcon.replace(base64Match[0],''), 'base64');
-                        this.adapter.writeFile(pathToAdminIcon, buffer);
-                        this.warn('write file complete.');
+                        const msg = `Saving base64 Data to ${pathToAdminIcon}`
+                        try {
+                            const buffer = Buffer.from(srcIcon.replace(base64Match[0],''), 'base64');
+                            this.adapter.writeFile(namespace, pathToAdminIcon, buffer, (err) => {
+                                if (err) {
+                                    this.warn(`${msg} -- failed: ${err && err.message ? err.message : 'no reason given'}`);
+                                    return;
+                                }
+                                this.info(`${msg} -- success`);
+                            });
+                        }
+                        catch (err) {
+                            this.warn(`${msg} -- failed: ${err && err.message ? err.message : 'no reason given'}`)
+                        }
                     });
                     return;
                 }
+                // path is absolute
                 if (modelDesc) modelDesc.icon = pathToAdminIcon;
                 this.adapter.fileExists(namespace, pathToAdminIcon, async(err, result) => {
                     if (result) {
-                        this.debug(`icon ${modelDesc.icon} found - no copy needed`);
+                        this.debug(`icon ${modelDesc ? modelDesc.icon : 'unknown icon'} found - no copy needed`);
                         return;
                     }
                     // try 3 options for source file
                     let src = srcIcon; // as given
                     const locations=[];
                     if (!fs.existsSync(src)) {
-                        locations.push(src);
                         src = path.normalize(this.adapter.expandFileName(src));
+                        locations.push(src);
                     } // assumed relative to data folder
                     if (!fs.existsSync(src)) {
                         locations.push(src);
@@ -158,36 +156,46 @@ class StatesController extends EventEmitter {
                     }
                     fs.readFile(src, (err, data) => {
                         if (err) {
-                            this.error('unable to read ' + src + ' : '+ (err.message? err.message:' no message given'))
+                            this.warn(`unable to read ${src}: ${(err.message? err.message:' no message given')}`);
                             return;
                         }
                         if (data) {
                             this.adapter.writeFile(namespace, pathToAdminIcon, data, (err) => {
                                 if (err) {
-                                    this.error('error writing file ' + path + JSON.stringify(err))
+                                    this.error(`error writing file ${path}: ${err.message ? err.message : 'no reason given'}`);
                                     return;
                                 }
                                 this.info('Updated image file ' + pathToAdminIcon);
                             });
+                            return;
                         }
+                        this.error(`fs.readFile failed - neither error nor data is returned!`);
                     });
                 });
             }
         }
     }
 
+    async updateDebugDevices(debugDevices) {
+        if (debugDevices != undefined)
+            this.debugDevices = debugDevices;
+        this.adapter.zbController.callExtensionMethod('setLocalVariable', ['debugDevices', this.debugDevices]);
+
+    }
+
     async getDebugDevices(callback) {
         if (this.debugDevices === undefined) {
             this.debugDevices = [];
             const state = await this.adapter.getStateAsync(`${this.adapter.namespace}.info.debugmessages`);
             if (state) {
                 if (typeof state.val === 'string' && state.val.length > 2) {
-                    this.debugDevices = state.val.split(';');
+                    this.updateDebugDevices(state.val.split(';'));
                 }
                 this.info(`debug devices set to ${JSON.stringify(this.debugDevices)}`);
                 if (callback) callback(this.debugDevices);
             }
         } else {
+            this.updateDebugDevices();
             // this.info(`debug devices was already set to ${JSON.stringify(this.debugDevices)}`);
             callback(this.debugDevices)
         }
@@ -195,15 +203,20 @@ class StatesController extends EventEmitter {
 
     async toggleDeviceDebug(id) {
         const arr = /zigbee.[0-9].([^.]+)/gm.exec(id);
+        if (!arr) {
+            this.warn(`unable to toggle debug for device ${id}: there was no matc (${JSON.stringify(arr)}) `);
+            return this.debugDevices;
+        }
         if (arr[1] === undefined) {
             this.warn(`unable to extract id from state ${id}`);
-            return [];
+            return this.debugDevices;
         }
         const stateKey = arr[1];
         if (this.debugDevices === undefined) this.debugDevices = await this.getDebugDevices()
         const idx = this.debugDevices.indexOf(stateKey);
         if (idx < 0) this.debugDevices.push(stateKey);
         else this.debugDevices.splice(idx, 1);
+        this.updateDebugDevices()
         await this.adapter.setStateAsync(`${this.adapter.namespace}.info.debugmessages`, this.debugDevices.join(';'), true);
         this.info('debug devices set to ' + JSON.stringify(this.debugDevices));
         return this.debugDevices;
@@ -243,22 +256,22 @@ class StatesController extends EventEmitter {
                 } else {
                     this.debugDevices = [];
                 }
+                this.updateDebugDevices();
                 this.info('debug devices set to ' + JSON.stringify(this.debugDevices));
                 return;
             }
 
             const devId = getAdId(this.adapter, id); // iobroker device id
-            let deviceId = getZbId(id); // zigbee device id
+            const deviceId = getZbId(id); // zigbee device id
 
             if (this.checkDebugDevice(id)) {
                 const message = `User state change of state ${id} with value ${state.val} (ack: ${state.ack}) from ${state.from}`;
                 this.emit('device_debug', { ID:debugId, data: { ID: deviceId, flag:'01' }, message:message});
             } else
                 if (this.debugActive) this.debug(`User stateChange ${id} ${JSON.stringify(state)}`);
-            // const stateKey = id.split('.')[3];
             const arr = /zigbee.[0-9].[^.]+.(\S+)/gm.exec(id);
             if (arr[1] === undefined) {
-                //this.warn(`unable to extract id from state ${id}`);
+                this.debug(`unable to extract id from state ${id}`);
                 return;
             }
             const stateKey = arr[1];
@@ -272,15 +285,15 @@ class StatesController extends EventEmitter {
                         if (this.debugActive) this.debug('State Change detected on deactivated Device - ignored');
                         return;
                     }
-                    if (model === 'group') {
-                        const match = deviceId.match(/group_(\d+)/gm);
-                        if (match) {
-                            deviceId = parseInt(match[1]);
-                            this.publishFromState(deviceId, model, stateKey, state, {});
+
+                    if (model && model.id === 'device_query') {
+                        if (this.query_device_block.indexOf(deviceId) > -1 && !state.source.includes('.admin.')) {
+                            this.info(`Device query for '${deviceId}' blocked - device query timeout has not elapsed yet.`);
                             return;
                         }
-
+                        this.emit('device_query', { deviceId, debugId });
                     }
+
                     this.collectOptions(id.split('.')[2], model, true,  options =>
                         this.publishFromState(deviceId, model, stateKey, state, options, debugId));
                 }
@@ -295,7 +308,7 @@ class StatesController extends EventEmitter {
                 callback(result);
                 return;
             }
-            // find model states for options and get it values. No options for groups !!!
+            // find model states for options and get it values.
             const devStates = await this.getDevStates('0x' + devId, model);
             if (devStates == null || devStates == undefined || devStates.states == null || devStates.states == undefined) {
                 callback(result);
@@ -372,7 +385,7 @@ class StatesController extends EventEmitter {
         }
     }
 
-    async triggerComposite(_deviceId, model, stateDesc, interactive) {
+    async triggerComposite(_deviceId, stateDesc, interactive) {
         const deviceId = (_deviceId.replace('0x', ''));
         const idParts = stateDesc.id.split('.').slice(-2);
         const key = `${deviceId}.${idParts[0]}`;
@@ -400,20 +413,26 @@ class StatesController extends EventEmitter {
         }, (stateDesc.compositeTimeout ? stateDesc.compositeTimeout : 100) * factor);
     }
 
-    async publishFromState(deviceId, model, stateKey, state, options, debugId) {
+
+    handleLinkedFunctResult(lfArr, devId, state) {
+        if (this.handleOption(devId, state.stateDesc)) return;
+        lfArr.push(state);
+    }
+
+    async publishFromState(deviceId, model, stateKey, state, options, debugID) {
         if (this.debugActive) this.debug(`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
-        const elevated = this.checkDebugDevice(deviceId);
+        const has_elevated_debug = this.checkDebugDevice(typeof deviceId == 'number' ? `group_${deviceId}` : deviceId);
 
-        if (elevated)  {
+        if (has_elevated_debug)  {
             const message = (`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
-            this.emit('device_debug', { ID:debugId, data: { ID: deviceId, model: model, flag:'02', IO:false }, message:message});
+            this.emit('device_debug', { ID:debugID, data: { ID: deviceId, model: model, flag:'02', IO:false }, message:message});
         }
 
         const devStates = await this.getDevStates(deviceId, model);
         if (!devStates) {
-            if (elevated) {
+            if (has_elevated_debug) {
                 const message = (`no device states for device ${deviceId} type '${model}'`);
-                this.emit('device_debug', { ID:debugId, data: { error: 'NOSTATES' , IO:false }, message:message});
+                this.emit('device_debug', { ID:debugID, data: { error: 'NOSTATES' , IO:false }, message:message});
             }
             return;
         }
@@ -422,33 +441,80 @@ class StatesController extends EventEmitter {
         const stateModel = devStates.stateModel;
         if (!stateDesc) {
             const message = (`No state available for '${model}' with key '${stateKey}'`);
-            if (elevated) this.emit('device_debug', { ID:debugId, data: { states:[{id:state.ID, value:'unknown', payload:'unknown'}], error: 'NOSTKEY' , IO:false }, message:message});
+            if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { states:[{id:state.ID, value:'unknown', payload:'unknown'}], error: 'NOSTKEY' , IO:false }, message:message});
             return;
         }
 
         const value = state.val;
         if (value === undefined || value === '') {
-            if (elevated) {
+            if (has_elevated_debug) {
                 const message = (`no value for device ${deviceId} type '${model}'`);
-                this.emit('device_debug', { ID:debugId, data: { states:[{id:state.ID, value:'--', payload:'error', ep:stateDesc.epname}],error: 'NOVAL' , IO:false }, message:message});
+                this.emit('device_debug', { ID:debugID, data: { states:[{id:state.ID, value:'--', payload:'error', ep:stateDesc.epname}],error: 'NOVAL' , IO:false }, message:message});
+            }
+            return;
+        }
+
+        // send_payload can never be a linked state !;
+        if (stateDesc.id === 'send_payload') {
+            try {
+                const json_value = JSON.parse(value);
+                const payload = {device: deviceId.replace('0x', ''), payload: json_value, model:model, stateModel:stateModel};
+                if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { flag: '04' ,payload:value ,states:[{id:stateDesc.id, value:json_value, payload:'none'}], IO:false }});
+
+                this.emit('send_payload', payload, debugID, has_elevated_debug);
+            } catch (error) {
+                const message = `send_payload: ${value} does not parse as JSON Object : ${error.message}`;
+                if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { error: 'EXSEND' ,states:[{id:stateDesc.id, value:value, payload:error.message}], IO:false }, message:message});
+                else this.error(message);
+                return;
+            }
+            return;
+        }
+
+        if (stateDesc.id === 'device_query') {
+            const interactive = (state.from.includes('.admin'));
+            if (!interactive && this.deviceQueryBlock.includes(deviceId)) {
+                this.warn(`device_query blocked due to excessive triggering - retrigger > 10 seconds after previous trigger has completed.`);
+                return;
             }
+            this.deviceQueryBlock.push[deviceId];
+            const id = deviceId;
+            this.emit('device_query', deviceId, debugID, has_elevated_debug, (devId) =>{
+                setTimeout(() => { const idx = this.deviceQueryBlock.indexOf(id);
+                    if (idx > -1) this.deviceQueryBlock.splice(idx);
+                }, 10000)
+
+            } )
+            return;
+        }
+
+        // composite states can never be linked states;
+        if (stateDesc.compositeState && stateDesc.compositeTimeout) {
+            this.triggerComposite(deviceId, stateDesc, state.from.includes('.admin.'));
             return;
         }
-        let stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0, source:state.from}];
+
+        const stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0, source:state.from}];
+
         if (stateModel && stateModel.linkedStates) {
             stateModel.linkedStates.forEach(linkedFunct => {
                 try {
                     if (typeof linkedFunct === 'function') {
                         const res = linkedFunct(stateDesc, value, options, this.adapter.config.disableQueue);
                         if (res) {
-                            stateList = stateList.concat(res);
+                            if (res.hasOwnProperty('stateDesc')) { // we got a single state back
+                                if (! res.stateDesc.isOption) stateList.push(res);
+                            }
+                            else {
+                                res.forEach((ls) => { if (!ls.stateDesc.isOption) stateList.push(res)} );
+                            }
                         }
                     } else {
                         this.warn(`publish from State - LinkedState is not a function ${JSON.stringify(linkedFunct)}`);
                     }
                 } catch (e) {
                     this.sendError(e);
-                    if (elevated) this.emit('device_debug', { ID:debugId, data: { states:[{id:state.ID, value:state.val, payload:'unknown'}], error: 'EXLINK' , IO:false }});
+                    if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { states:[{id:state.ID, value:state.val, payload:'unknown'}], error: 'EXLINK' , IO:false }});
                     this.error('Exception caught in publishfromstate: ' + (e && e.message ? e.message : 'no error message given'));
                 }
 
@@ -464,7 +530,8 @@ class StatesController extends EventEmitter {
                 readAfterWriteStates = readAfterWriteStates.concat(readAfterWriteStateDesc.id));
         }
 
-        this.emit('changed', deviceId, model, stateModel, stateList, options, debugId);
+        if (stateList.length > 0)
+            this.emit('changed', deviceId, model, stateModel, stateList, options, debugID, has_elevated_debug );
     }
 
     async renameDevice(id, newName) {
@@ -481,13 +548,12 @@ class StatesController extends EventEmitter {
     }
 
     verifyDeviceName(id, model ,name) {
-        const savedId = id.replace(`${this.adapter.namespace}.`, '');
         return this.localConfig.NameForId(id, model, name);
     }
 
 
-    setDeviceActivated(id, active) {
-        this.adapter.extendObject(id, {common: {deactivated: active}});
+    setDeviceActivated(id, inActive) {
+        this.adapter.extendObject(id, {common: {deactivated: inActive, color:inActive ? '#888888' : null, statusStates: inActive ? null : {onlineId:`${id}.available`} }});
     }
 
     storeDeviceName(id, name) {
@@ -503,7 +569,7 @@ class StatesController extends EventEmitter {
             }
 
         } catch (error) {
-            this.adapter.log.info(`Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`);
+            this.adapter.log.warn(`Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`);
         }
     }
 
@@ -576,35 +642,8 @@ class StatesController extends EventEmitter {
                 const stateId = devId + '.' + name;
                 const new_name = obj.common.name;
                 if (common) {
-                    if (common.name !== undefined) {
-                        new_common.name = common.name;
-                    }
-                    if (common.type !== undefined) {
-                        new_common.type = common.type;
-                    }
-                    if (common.unit !== undefined) {
-                        new_common.unit = common.unit;
-                    }
-                    if (common.states !== undefined) {
-                        new_common.states = common.states;
-                    }
-                    if (common.read !== undefined) {
-                        new_common.read = common.read;
-                    }
-                    if (common.write !== undefined) {
-                        new_common.write = common.write;
-                    }
-                    if (common.role !== undefined) {
-                        new_common.role = common.role;
-                    }
-                    if (common.min !== undefined) {
-                        new_common.min = common.min;
-                    }
-                    if (common.max !== undefined) {
-                        new_common.max = common.max;
-                    }
-                    if (common.icon !== undefined) {
-                        new_common.icon = common.icon;
+                    for (const key in common) {
+                        if (common[key] !== undefined) new_common[key] = common[key];
                     }
                 }
                 // check if state exist
@@ -697,7 +736,7 @@ class StatesController extends EventEmitter {
                 if (this.debugActive) this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
             }
         } else {
-            if (this.debugActive) this.debug(`UpdateState: missing device ${devId} ${JSON.stringify(obj)}`);
+            if (this.debugActive) this.debug(`UpdateState: missing device ${devId}`);
         }
     }
 
@@ -746,13 +785,10 @@ class StatesController extends EventEmitter {
     async applyLegacyDevices() {
         const legacyModels = await this.localConfig.getLegacyModels();
         const modelarr1 = [];
-        //this.warn('devices are' + modelarr1.join(','));
         statesMapping.devices.forEach(item => modelarr1.push(item.models));
-        //this.warn('legacy models are ' + JSON.stringify(legacyModels));
         statesMapping.setLegacyDevices(legacyModels);
         const modelarr2 = [];
         statesMapping.devices.forEach(item => modelarr2.push(item.models));
-        //this.warn('devices are' + modelarr2.join(','));
     }
 
     async addLegacyDevice(model) {
@@ -760,15 +796,25 @@ class StatesController extends EventEmitter {
         statesMapping.getByModel();
     }
 
-    async getDefaultGroupIcon(id) {
-        const regexResult = id.match(new RegExp(/group_(\d+)/));
-        if (!regexResult) return '';
-        const groupID = Number(regexResult[1]);
-        const group = await this.adapter.zbController.getGroupMembersFromController(groupID)
-        if (typeof group == 'object')
-            return `img/group_${Math.max(Math.min(group.length, 7), 0)}.png`
-        else
-            return 'img/group_x.png'
+
+    async getDefaultGroupIcon(id, members) {
+        let groupID = 0;
+        if (typeof id == 'string') {
+            const regexResult = id.match(new RegExp(/group_(\d+)/));
+            if (!regexResult) return '';
+            groupID = Number(regexResult[1]);
+        } else if (typeof id == 'number') {
+            groupID = id;
+        }
+        if (groupID <= 0) return;
+        if (typeof members != 'number') {
+            const group = await this.adapter.zbController.getGroupMembersFromController(groupID)
+            if (typeof group == 'object')
+                return `img/group_${Math.max(Math.min(group.length, 7), 0)}.png`
+            else
+                return 'img/group_x.png'
+        }
+        return `img/group_${Math.max(Math.min(members, 7), 0)}.png`
     }
 
     async updateDev(dev_id, dev_name, model, callback) {
@@ -777,7 +823,9 @@ class StatesController extends EventEmitter {
         if (this.debugActive) this.debug(`UpdateDev called with ${dev_id}, ${dev_name}, ${model}, ${__dev_name}`);
         const id = '' + dev_id;
         const modelDesc = statesMapping.findModel(model);
-        const modelIcon = (model == 'group' ? await this.getDefaultGroupIcon(dev_id) : modelDesc && modelDesc.icon ? modelDesc.icon : 'img/unknown.png');
+        const modelIcon = (model == 'group' ?
+            await this.getDefaultGroupIcon(dev_id) :
+            modelDesc && modelDesc.icon ? modelDesc.icon : 'img/unknown.png');
         let icon = this.localConfig.IconForId(dev_id, model, modelIcon);
 
         // download icon if it external and not undefined
@@ -787,6 +835,7 @@ class StatesController extends EventEmitter {
             const model_modif = model.replace(/\//g, '-');
             const pathToAdminIcon = `img/${model_modif}.png`;
 
+
             if (icon.startsWith('http')) {
                 try {
                     this.downloadIconToAdmin(icon, pathToAdminIcon)
@@ -797,66 +846,141 @@ class StatesController extends EventEmitter {
             }
         }
 
-        this.adapter.setObjectNotExists(id, {
-            type: 'device',
-            // actually this is an error, so device.common has no attribute type. It must be in native part
-            common: {
-                name: __dev_name,
-                type: model,
-                icon,
-                modelIcon: modelIcon,
-                color: null,
-                statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
-            },
-            native: {id: dev_id}
-        }, () => {
-            // update type and icon
+        const obj = await this.adapter.getObjectAsync(id);
+
+        const myCommon = {
+            name: __dev_name,
+            type: model,
+            icon,
+            modelIcon: modelIcon,
+            color: (obj && obj.common && obj.common.deactivated) ? `#888888` : null,
+            statusStates: (obj && obj.common && obj.common.deactivated) ? null : {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
+        }
+        if (obj) {
             this.adapter.extendObject(id, {
-                common: {
-                    name: __dev_name,
-                    type: model,
-                    icon,
-                    modelIcon: modelIcon,
-                    color: null,
-                    statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
-                }
+                common: myCommon
             }, callback);
-        });
+        } else {
+            this.adapter.setObjectNotExists(id, {
+                type: 'device',
+                // actually this is an error, so device.common has no attribute type. It must be in native part
+                common: myCommon,
+                native: {id: dev_id}
+            }, callback);
+        }
     }
 
-    async downloadIcon(url, image_path) {
+    async streamToBufferFetch(readableStream) {
+        const reader = readableStream.getReader();
+        const chunks = [];
+        let done, value;
+        try {
+            while (true) {
+                const result = await reader.read();
+                done = result.done;
+                value = result.value;
+                if (done) break;
+                if (value) chunks.push(Buffer.from(value));
+            }
+            return Buffer.concat(chunks);
+        } catch (err) {
+            this.error(`error getting buffer from stream: ${err && err.message ? err.message : 'no reason given'}`);
+            throw err;
+        }
+    }
+
+    async fetchIcon(url, image_path) {
+        const namespace = `${this.adapter.name}.admin`;
         try {
-            if (!fs.existsSync(image_path)) {
-                this.ImagesToDownload.push(url);
-                return new Promise((resolve, reject) => {
-                    this.info(`downloading ${url} to ${image_path}`);
-                    axios({
-                        method: 'get',
-                        url: url,
-                        responseType: 'stream'  // Dies ist wichtig, um den Stream direkt zu erhalten
-                    }).then(response => {
-                        const writer = fs.createWriteStream(image_path);
-                        response.data.pipe(writer);
-                        writer.on('finish', resolve);
-                        writer.on('error', reject);
-                    }).catch(err => {
-                        // reject(err);
-                        this.warn(`ERROR : icon path not found ${image_path}`);
-                    }).finally(() => {
+            return new Promise((resolve, reject) => {
+                fetch(url)
+                    .then(async response => {
+                        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+                        const data = await this.streamToBufferFetch(response.body);
+                        this.adapter.writeFile(namespace, image_path, data, (err) => {
+                            if (err) {
+                                this.error(`error writing ${image_path} to admin: ${err.message ? err.message : 'no message given'}`);
+                                reject(err);
+                                return;
+                            }
+                            this.info(`downloaded ${url} to ${image_path}.`);
+                            resolve();
+                        });
+                    })
+                    .catch(err => {
+                        this.warn(`error downloading icon ${err && err.message ? err.message : 'no message given'}`);
+                        reject(err);
+                    })
+                    .finally(() => {
                         const idx = this.ImagesToDownload.indexOf(url);
                         if (idx > -1) {
                             this.ImagesToDownload.splice(idx, 1);
                         }
+                    });
+            });
+        }
+        catch (error) {
+            this.warn(`error fetching ${url} : ${error && error.message ? error.message : 'no reason given'}`)
+        }
+    }
 
+    async streamToBuffer(readableStream) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            readableStream.on('data', data => {
+                if (typeof data === 'string') {
+                    // Convert string to Buffer assuming UTF-8 encoding
+                    chunks.push(Buffer.from(data, 'utf-8'));
+                } else if (data instanceof Buffer) {
+                    chunks.push(data);
+                } else {
+                    // Convert other data types to JSON and then to a Buffer
+                    const jsonData = JSON.stringify(data);
+                    chunks.push(Buffer.from(jsonData, 'utf-8'));
+                }
+            });
+            readableStream.on('end', () => {
+                resolve(Buffer.concat(chunks));
+            });
+            readableStream.on('error', (err) => {
+                this.error(`error getting buffer from stream: ${err && err.message ? err.message : 'no reason given'}`);
+                reject;
+            });
+        });
+    }
+
+    async downloadIcon(url, image_path) {
+        try {
+            const namespace = `${this.adapter.name}.admin`;
+            this.ImagesToDownload.push(url);
+            return new Promise((resolve, reject) => {
+                this.info(`downloading ${url} to ${image_path}`);
+                axios({
+                    method: 'get',
+                    url: url,
+                    responseType: 'stream'  // Dies ist wichtig, um den Stream direkt zu erhalten
+                }).then(async response => {
+                    const data = await this.streamToBuffer(response.data);
+                    this.adapter.writeFile(namespace, image_path, data, (err) => {
+                        if (err) {
+                            this.error(`error writing ${image_path} to admin: ${err.message ? err.message : 'no message given'}`);
+                            reject;
+                        }
+                        this.info(`downloaded ${url} to ${image_path}.`)
+                        resolve;
                     });
+                }).catch(err => {
+                    this.warn(`error downloading icon ${err && err.message ? err.message : 'no message given'}`);
+                }).finally(() => {
+                    const idx = this.ImagesToDownload.indexOf(url);
+                    if (idx > -1) {
+                        this.ImagesToDownload.splice(idx, 1);
+                    }
                 });
-            }
-            else {
-                this.info(`not downloading ${image_path} - file exists`)
-            }
+            });
         }
         catch (error) {
-            this.error('downloadIcon ', error);
+            this.error('error in downloadIcon:  ', error && error.message ? error.message : 'no message given');
         }
     }
 
@@ -864,37 +988,11 @@ class StatesController extends EventEmitter {
         const namespace = `${this.adapter.name}.admin`;
         this.adapter.fileExists(namespace, target, async (err,result) => {
             if (result) return;
-            const src = `${tmpdir()}/${path.basename(target)}`;
-            //const msg = `downloading ${url} to ${src}`;
             if (this.ImagesToDownload.indexOf(url) ==-1) {
-                await this.downloadIcon(url, src)
-                try {
-                    fs.readFile(src, (err, data) => {
-                        if (err) {
-                            this.error('unable to read ' + src + ' : '+ (err && err.message? err.message:' no message given'))
-                            return;
-                        }
-                        if (data) {
-                            this.adapter.writeFile(namespace, target, data, (err) => {
-                                if (err) {
-                                    this.error('error writing file ' + target + JSON.stringify(err))
-                                    return;
-                                }
-                                this.info(`copied ${src} to ${target}.`)
-                                fs.rm(src, (err) => {
-                                    if (err) this.warn(`error removing ${src} : ${JSON.stringify(err)}`);
-                                });
-                            })
-                        }
-                    })
-                }
-                catch (error) {
-                    this.error('fs.readfile error : ', error);
-                }
+                await this.downloadIcon(url, target);
             }
         });
     }
-
     CleanupRequired(set) {
         try {
             if (typeof set === 'boolean') this.cleanupRequired = set;
@@ -983,8 +1081,10 @@ class StatesController extends EventEmitter {
             const has_elevated_debug = (this.checkDebugDevice(devId) && !payload.hasOwnProperty('msg_from_zigbee'));
 
             const message = `message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`;
-            if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { deviceID: devId, flag:'01', IO:true }, message:message});
-            else if (this.debugActive) this.debug(message);
+            if (has_elevated_debug)
+                this.emit('device_debug', { ID:debugId, data: { deviceID: devId, flag:'03', IO:true }, message:message});
+            else
+                if (this.debugActive) this.debug(message);
             if (!devStates) {
                 const message = `no device states for device ${devId} type '${model}'`;
                 if (has_elevated_debug)this.emit('device_debug', { ID:debugId, data: { error:'NOSTATE',states:[{ id:'--', value:'--', payload:payload}], IO:true }, message:message});
@@ -1015,7 +1115,7 @@ class StatesController extends EventEmitter {
                         let stateID = statedesc.id;
 
                         const message = `value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`;
-                        if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { states:[{id:stateID, value:value, payload:payload }],flag:'02', IO:true }, message});
+                        if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { states:[{id:stateID, value:value, payload:payload }],flag:'04', IO:true }, message});
                         else if (this.debugActive) this.debug(message);
 
                         const common = {
@@ -1065,8 +1165,10 @@ class StatesController extends EventEmitter {
                     else if (this.debugActive) this.debug(message);
                 }
                 const message = `No value published for device ${devId}`;
-                if (!has_published && has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'NOVAL', IO:true }, message:message});
-                else if (this.debugActive) this.debug(message);
+                if (!has_published) {
+                    if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'NOVAL', IO:true }, message:message});
+                    else if (this.debugActive) this.debug(message);
+                }
             }
             else {
                 const message = `ELEVATED IE05 - NOSTATE: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`;
@@ -1079,31 +1181,78 @@ class StatesController extends EventEmitter {
         }
     }
 
-    async processConverters(converters, devId, model, mappedModel, message, meta, debugId) {
-        for (const converter of converters) {
-            const publish = (payload, dID) => {
-                if (typeof payload === 'object') {
-                    this.publishToState(devId, model, payload,dID);
+    postProcessConvertedFromZigbeeMessage(definition, payload, options, device) {
+    // Apply calibration/precision options
+        for (const [key, value] of Object.entries(payload)) {
+            const definitionExposes = Array.isArray(definition.exposes) ? definition.exposes : definition.exposes(device, {});
+            const expose = definitionExposes.find((e) => e.property === key);
+
+            if (!expose) return;
+
+            if (expose &&
+            expose.name in zigbeeHerdsmanConvertersUtils.calibrateAndPrecisionRoundOptionsDefaultPrecision &&
+            value !== '' &&
+            typeof value === 'number') {
+                try {
+                    payload[key] = zigbeeHerdsmanConvertersUtils.calibrateAndPrecisionRoundOptions(value, options, expose.name);
+                } catch (error) {
+                    this.warn(`Failed to apply calibration to '${expose.name}': ${error && error.message ? error.message: 'no reason given'}`);
                 }
-            };
+            }
+        }
+    }
 
-            const options = await new Promise((resolve, reject) => {
-                this.collectOptions(devId, model, false, (options) => {
-                    resolve(options);
-                });
+    async processConverters(converters, devId, model, mappedModel, message, meta, debugId, has_elevated_debug) {
+        let cnt = 0;
+        const publish = (payload, dID) => {
+            if (typeof payload === 'object' && Object.keys(payload).length > 0) {
+                this.publishToState(devId, model, payload,dID);
+            }
+            else if (has_elevated_debug)
+                this.emit('device_debug', {ID:debugId,data: { error:`NOVAL`, IO:true }, message:` payload ${JSON.stringify(payload)} is empty`})
+        };
+        const options = await new Promise((resolve, reject) => {
+            this.collectOptions(devId, model, false, (options) => {
+                resolve(options);
             });
+        });
 
-            const payload = await new Promise((resolve, reject) => {
+        const chain = [];
+        for (const converter of converters) {
+            const idx = cnt++;
+            chain.push(new Promise((resolve) => {
+                if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${cnt}a`, IO:true }, message:`converter ${cnt} : Cluster ${converter.cluster}`})
                 const payloadConv = converter.convert(mappedModel, message, publish, options, meta);
+                const metapost = meta ? {
+                    deviceIEEE: meta.device ? meta.device.ieeeAddr : 'no device',
+                    deviceModelId: meta.device ? meta.device.ModelId : 'no device',
+                    logger: meta.logger ? (meta.logger.constructor ? meta.logger.constructor.name : 'not a class') : 'undefined',
+                    state : meta.state
+                } : 'undefined';
+                if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${idx}b`, IO:true }, message:` data: ${safeJsonStringify(message.data)} options: ${safeJsonStringify(options)} meta:${safeJsonStringify(metapost)} result:${safeJsonStringify(payloadConv)}`})
                 if (typeof payloadConv === 'object') {
                     resolve(payloadConv);
                 }
-            });
+                else resolve({});
+            }));
+        }
+        const candidates = await Promise.all(chain);
+        const payload = {};
 
-            publish(payload, debugId);
+        for (const candidate of candidates) {
+            for (const key in candidate)
+                payload[key] = candidate[key];
         }
-    }
 
+        if (Object.keys(payload).length > 0 && Object.keys(options).length > 0) {
+            const premsg = `candidates: ${JSON.stringify(candidates)} => payload ${JSON.stringify(payload)}`
+            this.postProcessConvertedFromZigbeeMessage(mappedModel, payload, options, null);
+            if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${cnt}d`, IO:true }, message:`${premsg} => processed payload : ${JSON.stringify(payload)}`})
+        }
+        else if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${cnt}c`, IO:true }, message:`candidates: ${JSON.stringify(candidates)} => payload ${JSON.stringify(payload)}`})
+
+        publish(payload, debugId);
+    }
 
     async onZigbeeEvent(type, entity, message) {
         if (this.debugActive) this.debug(`Type ${type} device ${safeJsonStringify(entity)} incoming event: ${safeJsonStringify(message)}`);
@@ -1117,6 +1266,10 @@ class StatesController extends EventEmitter {
 
         const has_elevated_debug = this.checkDebugDevice(devId);
         const debugId = Date.now();
+        if (entity.device.interviewing) {
+            this.warn(`zigbee event for ${device.ieeeAddr} received during interview!`);
+            return;
+        }
 
         // raw message data for logging and msg_from_zigbee
         const msgForState = Object.assign({}, message);
@@ -1185,16 +1338,13 @@ class StatesController extends EventEmitter {
             }
         }
 
-        // publish raw event to "from_zigbee"
-        // some cleanup
-
         this.publishToState(devId, model, {msg_from_zigbee: safeJsonStringify(msgForState)}, -1);
 
         if (!entity.mapped) {
             return;
         }
 
-        let converters = mappedModel.fromZigbee.filter(c => c && c.cluster === cluster && (
+        let converters = [...mappedModel.fromZigbee,...mappedModel.toZigbee].filter(c => c && c.cluster === cluster && (
             Array.isArray(c.type) ? c.type.includes(type) : c.type === type));
 
 
@@ -1203,8 +1353,13 @@ class StatesController extends EventEmitter {
                 Array.isArray(c.type) ? c.type.includes('attributeReport') : c.type === 'attributeReport'));
         }
 
+        if (has_elevated_debug) {
+            const message = `${converters.length} converter${converters.length > 1 ? 's' : ''} available for '${mappedModel.model}' '${devId}' with cluster '${cluster}' and type '${type}'`
+            this.emit('device_debug', { ID:debugId, data: { flag:'02', IO:true }, message:message})
+        }
+
         if (!converters.length) {
-            if (type !== 'readResponse') {
+            if (type !== 'readResponse' && type !== 'commandQueryNextImageRequest') {
                 const message = `No converter available for '${mappedModel.model}' '${devId}' with cluster '${cluster}' and type '${type}'`;
                 if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { error:'NOCONV', IO:true }, message:message});
                 else if (this.debugActive) this.debug(message);
@@ -1214,7 +1369,7 @@ class StatesController extends EventEmitter {
 
         meta.state = { state: '' };   // for tuya
 
-        this.processConverters(converters, devId, model, mappedModel, message, meta, debugId)
+        this.processConverters(converters, devId, model, mappedModel, message, meta, debugId, has_elevated_debug)
             .catch((error) => {
                 //   'Error: Expected one of: 0, 1, got: 'undefined''
                 if (cluster !== '64529') {
@@ -1228,9 +1383,6 @@ class StatesController extends EventEmitter {
     async stop() {
         this.localConfig.retainData();
     }
-
-
-
 }
 
-module.exports = StatesController;
+module.exports = StatesController;