iobroker.zigbee 2.0.4 → 3.0.0

package/lib/statescontroller.js

@@ -1,9 +1,9 @@
 'use strict';
 
-const EventEmitter = require('events').EventEmitter;
+const safeJsonStringify = require('./json');
+const { EventEmitter } = require('events');
 const statesMapping = require('./devices');
-const getAdId = require('./utils').getAdId;
-const getZbId = require('./utils').getZbId;
+const { getAdId, getZbId } = require('./utils');
 const fs = require('fs');
 const axios = require('axios');
 const localConfig = require('./localConfig');
@@ -14,7 +14,8 @@ const localConfig = require('./localConfig');
 const { exec } = require('child_process');
 const { tmpdir } = require('os');
 const path = require('path');
-const { numberWithinRange } = require('zigbee-herdsman-converters/lib/utils');
+const { throwDeprecation } = require('process');
+const zigbeeHerdsmanConvertersUtils = require('zigbee-herdsman-converters/lib/utils');
 
 
 class StatesController extends EventEmitter {
@@ -32,6 +33,8 @@ class StatesController extends EventEmitter {
         this.ImagesToDownload = [];
         this.stashedErrors = {};
         this.stashedUnknownModels = [];
+        this.debugMessages = { nodevice:{ in:[], out: []} };
+        this.debugActive = true;
     }
 
     info(message, data) {
@@ -73,29 +76,118 @@ class StatesController extends EventEmitter {
 
     getStashedErrors() {
         const rv = [];
-        if (Object.keys(this.stashedErrors).length > 0)
-        {
-            rv.push('<p><b>Stashed Messages</b></p>')
-            rv.push(Object.values(this.stashedErrors).join('<br>'));
+        try {
+            if (Object.keys(this.stashedErrors).length > 0)
+            {
+                rv.push('<p><b>Stashed Messages</b></p>')
+                rv.push(Object.values(this.stashedErrors).join('<br>'));
+            }
+            if (this.stashedUnknownModels.length > 0) {
+                rv.push('<p><b>Devices whithout Model definition</b></p>')
+                rv.push()
+            }
         }
-        if (this.stashedUnknownModels.length > 0) {
-            rv.push('<p><b>Devices whithout Model definition</b></p>')
-            rv.push()
+        catch (error) {
+            if (this.debugActive) this.debug(`Error collecting stashed errors: ${error && error.message ? error.message : 'no message available'}`);
         }
         return rv;
     }
 
+    debugMessagesById() {
+        return this.debugMessages;
+    }
+
     async AddModelFromHerdsman(device, model) {
         // this.warn('addModelFromHerdsman ' + JSON.stringify(model) + ' ' + JSON.stringify(this.localConfig.getOverrideWithKey(model, 'legacy', true)));
         if (this.localConfig.getOverrideWithKey(model, 'legacy', true)) {
-            //this.warn('legacy for ' + model);
+            this.debug('Applying legacy definition for ' + model);
             await this.addLegacyDevice(model);
         }
         else {
-            const pre = statesMapping.devices.length;
-            await statesMapping.addExposeToDevices(device, this, model);
-            const post = statesMapping.devices.length;
-            //this.warn('expose for ' + model + ' '+ pre + '->'+post);
+            this.debug('Generating states from exposes for ' + model);
+            const modelDesc = await statesMapping.addExposeToDevices(device, this, model);
+            const srcIcon = modelDesc.icon;
+            // download icon if it external and not undefined
+            if (model === undefined) {
+                const dev_name = this.verifyDeviceName(device.ieeeAddr.substr(2), model, device.modelID);
+                this.warn(`download icon ${dev_name} for undefined Device not available. Check your devices.`);
+            } else {
+                const model_modif = model.replace(/\//g, '-');
+                const pathToAdminIcon = `img/${model_modif}.png`;
+
+                const namespace = `${this.adapter.name}.admin`;
+                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;
+                    });
+                    return;
+                }
+                const base64Match = srcIcon.match(/data:image\/(.+);base64,/);
+                if (base64Match) {
+                    modelDesc.icon = pathToAdminIcon;
+                    this.adapter.fileExists(namespace, pathToAdminIcon, async (err,result) => {
+                        if (result) {
+                            this.debug(`no need to save icon to ${pathToAdminIcon}`);
+                            return;
+                        }
+                        this.debug(`Saving base64 data to ${pathToAdminIcon}`)
+                        const buffer = new Buffer(srcIcon.replace(base64Match[0],''), 'base64');
+                        this.adapter.writeFile(pathToAdminIcon, buffer);
+                    });
+                    return;
+                }
+                modelDesc.icon = pathToAdminIcon;
+                this.adapter.fileExists(namespace, pathToAdminIcon, async(err, result) => {
+                    if (result) {
+                        this.debug(`icon ${modelDesc.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));
+                    } // assumed relative to data folder
+                    if (!fs.existsSync(src)) {
+                        locations.push(src);
+                        src = path.normalize(this.adapter.expandFileName(path.basename(src)));
+                    } // filename relative to data folder
+                    if (!fs.existsSync(src)) {
+                        locations.push(src);
+                        src = path.normalize(this.adapter.expandFileName(path.join('img',path.basename(src))));
+                    } // img/<filename> relative to data folder
+                    if (!fs.existsSync(src)) {
+                        this.warn(`Unable to copy icon from device definition, looked at ${locations.join(', ')} and ${src}`)
+                        return;
+                    }
+                    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, pathToAdminIcon, data, (err) => {
+                                if (err) {
+                                    this.error('error writing file ' + path + JSON.stringify(err))
+                                    return;
+                                }
+                                this.info('Updated image file ' + pathToAdminIcon);
+                            });
+                        }
+                    })
+                })
+            }
         }
     }
 
@@ -152,6 +244,10 @@ class StatesController extends EventEmitter {
         if (!this.adapter.zbController || !this.adapter.zbController.connected()) {
             return;
         }
+        if (id.includes('logLevel')) {
+            if (state) this.adapter.updateDebugLevel(state.val);
+        }
+        const debugId = Date.now();
         if (state && !state.ack) {
             if (id.endsWith('pairingCountdown') || id.endsWith('pairingMessage') || id.endsWith('connection')) {
                 return;
@@ -166,16 +262,18 @@ class StatesController extends EventEmitter {
                 return;
             }
 
-            if (this.checkDebugDevice(id))
-                this.warn(`ELEVATED O01: User state change of state ${id} with value ${state.val} (ack: ${state.ack}) from ${state.from}`);
-
-            this.debug(`User stateChange ${id} ${JSON.stringify(state)}`);
             const devId = getAdId(this.adapter, id); // iobroker device id
             let 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.warn(`unable to extract id from state ${id}`);
                 return;
             }
             const stateKey = arr[1];
@@ -186,7 +284,7 @@ class StatesController extends EventEmitter {
                         return;
                     }
                     if (obj.common.deactivated) {
-                        this.debug('State Change detected on deactivated Device - ignored');
+                        if (this.debugActive) this.debug('State Change detected on deactivated Device - ignored');
                         return;
                     }
                     if (model === 'group') {
@@ -199,7 +297,7 @@ class StatesController extends EventEmitter {
 
                     }
                     this.collectOptions(id.split('.')[2], model, options =>
-                        this.publishFromState(deviceId, model, stateKey, state, options));
+                        this.publishFromState(deviceId, model, stateKey, state, options, debugId));
                 }
             });
         }
@@ -305,29 +403,38 @@ class StatesController extends EventEmitter {
         }, (stateDesc.compositeTimeout ? stateDesc.compositeTimeout : 100) * factor);
     }
 
-    async publishFromState(deviceId, model, stateKey, state, options) {
-        this.debug(`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
+    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);
 
-        if (elevated) this.warn(`ELEVATED O02: Change state '${stateKey}' at device ${deviceId} type '${model}'`);
+        if (elevated)  {
+            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});
+        }
 
         const devStates = await this.getDevStates(deviceId, model);
         if (!devStates) {
-            if (elevated) this.error(`ELEVATED OE1: no device states for device ${deviceId} type '${model}'`);
+            if (elevated) {
+                const message = (`no device states for device ${deviceId} type '${model}'`);
+                this.emit('device_debug', { ID:debugId, data: { error: 'NOSTATES' , IO:false }, message:message});
+            }
             return;
         }
         const commonStates = statesMapping.commonStates.find(statedesc => stateKey === statedesc.id);
         const stateDesc = (commonStates === undefined ? devStates.states.find(statedesc => stateKey === statedesc.id) : commonStates);
         const stateModel = devStates.stateModel;
         if (!stateDesc) {
-            this.error(`No state available for '${model}' with key '${stateKey}'`);
+            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});
             return;
         }
 
         const value = state.val;
         if (value === undefined || value === '') {
-            if (elevated)
-                this.error(`ELEVATED OE2: no value for device ${deviceId} type '${model}'`);
+            if (elevated) {
+                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});
+            }
             return;
         }
         let stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0, source:state.from}];
@@ -344,7 +451,8 @@ class StatesController extends EventEmitter {
                     }
                 } catch (e) {
                     this.sendError(e);
-                    this.error('Exception caught in publishfromstate');
+                    if (elevated) 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'));
                 }
 
             });
@@ -359,7 +467,7 @@ class StatesController extends EventEmitter {
                 readAfterWriteStates = readAfterWriteStates.concat(readAfterWriteStateDesc.id));
         }
 
-        this.emit('changed', deviceId, model, stateModel, stateList, options);
+        this.emit('changed', deviceId, model, stateModel, stateList, options, debugId);
     }
 
     async renameDevice(id, newName) {
@@ -371,7 +479,7 @@ class StatesController extends EventEmitter {
             objName = (obj.common.type == 'group' ? stateId.replace('_',' ') : obj.common.type);
         }
         this.localConfig.updateDeviceName(stateId, newName);
-        this.debug('rename device: newname ~' + newName + '~ objName ~' + objName + '~')
+        if (this.debugActive) this.debug('rename device: newname ~' + newName + '~ objName ~' + objName + '~')
         this.adapter.extendObject(id, {common: {name: objName}});
     }
 
@@ -413,7 +521,7 @@ class StatesController extends EventEmitter {
                     let statename = state._id;
                     const arr = /zigbee.[0-9].[^.]+.(\S+)/gm.exec(statename);
                     if (arr[1] === undefined) {
-                        this.warn(`unable to extract id from state ${statename}`);
+                        if (this.debugActive) this.debug(`unable to extract id from state ${statename}`);
                         const idx = statename.lastIndexOf('.');
                         if (idx > -1) {
                             statename = statename.slice(idx + 1);
@@ -447,8 +555,10 @@ class StatesController extends EventEmitter {
                             }
                         }
                     } else {
-                        this.debug(`keeping connecte state ${JSON.stringify(statename)} of  ${devId} `);
-                        messages.push(`keeping connecte state ${JSON.stringify(statename)} of  ${devId} `);
+                        if (!markOnly) {
+                            if (this.debugActive) this.debug(`keeping connected state ${JSON.stringify(statename)} of  ${devId} `);
+                            messages.push(`keeping connecte state ${JSON.stringify(statename)} of  ${devId} `);
+                        }
                     }
                 });
             }
@@ -544,8 +654,8 @@ class StatesController extends EventEmitter {
                 if (value !== undefined) {
                     const type = stobj ? stobj.common.type : new_common.type;
                     if (type === 'number') {
-                        const minval = (stobj ? stobj.common.min: new_common.min) || -Number.MAX_VALUE;
-                        const maxval = (stobj ? stobj.common.max: new_common.max) || Number.MAX_VALUE;
+                        const minval = (stobj ? stobj.common.min : new_common.min);
+                        const maxval = (stobj ? stobj.common.max : new_common.max);
                         let nval = (typeof value == 'number' ? value : parseFloat(value));
                         if (isNaN(nval)) {
                             if (minval !== undefined && typeof minval === 'number')
@@ -553,24 +663,24 @@ class StatesController extends EventEmitter {
                             else
                                 nval = 0;
                         }
-                        if (nval < minval) {
+                        if (typeof minval == 'number' && nval < minval) {
                             hasChanges = true;
                             new_common.color = '#FF0000'
                             value = minval
                             if (!this.stashedErrors.hasOwnProperty(`${stateId}.min`))
                             {
-                                this.error(`State value for ${stateId} has value "${nval}" less than min "${minval}". - this eror is recorded and not repeated`);
+                                this.warn(`State value for ${stateId} has value "${nval}" less than min "${minval}". - this eror is recorded and not repeated`);
                                 this.stashedErrors[`${stateId}.min`] = `State value for ${stateId} has value "${nval}." less than min "${minval}"`;
                             }
                         }
-                        if (nval > maxval) {
+                        if (typeof maxval == 'number' && nval > maxval) {
                             hasChanges = true;
                             hasChanges = true;
                             new_common.color = '#FF0000'
                             value = maxval;
                             if (!this.stashedErrors.hasOwnProperty(`${stateId}.max`))
                             {
-                                this.error(`State value for ${stateId} has value "${nval}" more than max "${maxval}". - this eror is recorded and not repeated`);
+                                this.warn(`State value for ${stateId} has value "${nval}" more than max "${maxval}". - this eror is recorded and not repeated`);
                                 this.stashedErrors[`${stateId}.max`] = `State value for ${stateId} has value "${nval}" more than max "${maxval}".`;
                             }
                         }
@@ -584,10 +694,10 @@ class StatesController extends EventEmitter {
                     this.setState_typed(stateId, value, true, stobj.common.type);
                 }
             } else {
-                this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
+                if (this.debugActive) this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
             }
         } else {
-            this.debug(`UpdateState: missing device ${devId} ${JSON.stringify(obj)}`);
+            if (this.debugActive) this.debug(`UpdateState: missing device ${devId} ${JSON.stringify(obj)}`);
         }
     }
 
@@ -595,7 +705,7 @@ class StatesController extends EventEmitter {
         // never set a null or undefined value
         if (value === null || value === undefined) return;
         if (!type) {
-            this.debug('SetState_typed called without type');
+            if (this.debugActive) this.debug('SetState_typed called without type');
             // identify datatype, recursively call this function with set datatype
             this.adapter.getObject(id, (err, obj) => {
                 if (obj && obj.common) {
@@ -607,7 +717,7 @@ class StatesController extends EventEmitter {
             return;
         }
         if (typeof value !== type) {
-            this.debug(`SetState_typed : converting ${JSON.stringify(value)} for ${id} from ${typeof value} to ${type}`);
+            if (this.debugActive) this.debug(`SetState_typed : converting ${JSON.stringify(value)} for ${id} from ${typeof value} to ${type}`);
             switch (type) {
                 case 'number':
                     value = parseFloat(value);
@@ -664,7 +774,7 @@ class StatesController extends EventEmitter {
     async updateDev(dev_id, dev_name, model, callback) {
 
         const __dev_name = this.verifyDeviceName(dev_id, model, (dev_name ? dev_name : model));
-        this.debug(`UpdateDev called with ${dev_id}, ${dev_name}, ${model}, ${__dev_name}`);
+        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');
@@ -755,7 +865,7 @@ class StatesController extends EventEmitter {
         this.adapter.fileExists(namespace, target, async (err,result) => {
             if (result) return;
             const src = `${tmpdir()}/${path.basename(target)}`;
-            const msg = `downloading ${url} to ${src}`;
+            //const msg = `downloading ${url} to ${src}`;
             if (this.ImagesToDownload.indexOf(url) ==-1) {
                 await this.downloadIcon(url, src)
                 try {
@@ -773,7 +883,6 @@ class StatesController extends EventEmitter {
                                 this.info(`copied ${src} to ${target}.`)
                                 fs.rm(src, (err) => {
                                     if (err) this.warn(`error removing ${src} : ${JSON.stringify(err)}`);
-                                    else this.info(`removed ${src}`)
                                 });
                             })
                         }
@@ -787,12 +896,17 @@ class StatesController extends EventEmitter {
     }
 
     CleanupRequired(set) {
-        if (typeof set === 'boolean') this.cleanupRequired = set;
-        return this.cleanupRequired;
+        try {
+            if (typeof set === 'boolean') this.cleanupRequired = set;
+            return this.cleanupRequired;
+        }
+        catch (error) {
+            if (this.debugActive) this.debug(`Error setting cleanup required: ${error && error.message ? error.message : 'no message available'}`);
+        }
     }
 
     async syncDevStates(dev, model) {
-        this.debug('synchronizing device states for ' + dev.ieeeAddr + ' (' + model + ')');
+        if (this.debugActive) this.debug('synchronizing device states for ' + dev.ieeeAddr + ' (' + model + ')');
         const devId = dev.ieeeAddr.substr(2);
         // devId - iobroker device id
         const devStates = await this.getDevStates(dev.ieeeAddr, model);
@@ -861,102 +975,257 @@ class StatesController extends EventEmitter {
         this.emit('debugmessage', {id: id, message:message});
     }
 
-    async publishToState(devId, model, payload) {
-        const devStates = await this.getDevStates(`0x${devId}`, model);
+    async publishToState(devId, model, payload, debugId) {
+        try {
+            if (!debugId) debugId = Date.now();
+            const devStates = await this.getDevStates(`0x${devId}`, model);
+
+            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 (!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});
+                else if (this.debugActive) this.debug(message);
+                return;
+            }
+            // find states for payload
+            let has_published = false;
+            if (devStates.states !== undefined) {
+                try {
+                    const states = statesMapping.commonStates.concat(
+                        devStates.states.filter(statedesc => payload.hasOwnProperty(statedesc.prop || statedesc.id))
+                    );
+
+                    for (const stateInd in states) {
+                        const statedesc = states[stateInd];
+                        let value;
+                        if (statedesc.getter) {
+                            value = statedesc.getter(payload);
+                        } else {
+                            value = payload[statedesc.prop || statedesc.id];
+                        }
+                        // checking value
+                        if (value === undefined || value === null) {
+                            continue;
+                        }
 
-        const has_elevated_debug = (this.checkDebugDevice(devId) && !payload.hasOwnProperty('msg_from_zigbee'));
+                        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});
+                        else if (this.debugActive) this.debug(message);
+
+                        const common = {
+                            name: statedesc.name,
+                            type: statedesc.type,
+                            unit: statedesc.unit,
+                            read: statedesc.read,
+                            write: statedesc.write,
+                            icon: statedesc.icon,
+                            role: statedesc.role,
+                            min: statedesc.min,
+                            max: statedesc.max,
+                        };
+
+                        if (typeof value === 'object' && value.hasOwnProperty('stateid')) {
+                            stateID = `${stateID}.${value.stateid}`;
+                            if (value.hasOwnProperty('unit')) {
+                                common.unit = value.unit;
+                            }
+                            common.name = value.name ? value.name : value.stateid;
+                            common.role = value.role ? `value.${value.role}` : 'number';
+                            value = value.value;
+                        }
 
+                        // if needs to return value to back after timeout
+                        if (statedesc.isEvent) {
+                            this.updateStateWithTimeout(devId, statedesc.id, value, common, 300, (typeof value == typeof (!value) ? !value : ''));
+                            if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { flag:'SUCCESS', IO:true }});
 
-        if (has_elevated_debug)
-        {
-            this.elevatedMessage(devId, `ELEVATED I01: message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`, false);
+                        } else {
+                            if (statedesc.prepublish) {
+                                this.collectOptions(devId, model, options =>
+                                    statedesc.prepublish(devId, value, newvalue => {
+                                        this.updateState(devId, stateID, newvalue, common) }, options)
+                                );
+                                if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { flag:'SUCCESS', IO:true }});
+                            } else {
+                                this.updateState(devId, stateID, value, common, debugId);
+                                if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { flag:'SUCCESS', IO:true }});
+                            }
+                        }
+                        has_published = true;
+                    }
+                } catch (e) {
+                    const message = `unable to enumerate states of ${devId} for payload ${JSON.stringify(payload)}, ${(e ? e.name : 'undefined')} (${(e ? e.message : '')}).`;
+                    if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'ESTATE', IO:true }, message:message});
+                    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);
+            }
+            else {
+                const message = `ELEVATED IE05 - NOSTATE: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`;
+                if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'NOSTATE', IO:true }, message});
+                else if (this.debugActive) this.debug(message);
+            }
         }
-        if (!devStates) {
-            if (has_elevated_debug)
-                this.elevatedMessage(devId, `ELEVATED IE02: no device states for device ${devId} type '${model}'`, true)
-            return;
+        catch (error) {
+            this.error('Something went horribly wrong: ' + (error && error.message ? error.message : 'no reason given'));
         }
-        // find states for payload
-        let has_published = false;
+    }
 
-        if (devStates.states !== undefined) {
-            try {
-                const states = statesMapping.commonStates.concat(
-                    devStates.states.filter(statedesc => payload.hasOwnProperty(statedesc.prop || statedesc.id))
-                );
-
-                for (const stateInd in states) {
-                    const statedesc = states[stateInd];
-                    let value;
-                    if (statedesc.getter) {
-                        value = statedesc.getter(payload);
-                    } else {
-                        value = payload[statedesc.prop || statedesc.id];
-                    }
-                    // checking value
-                    if (value === undefined || value === null) {
-                        continue;
-                    }
+    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);
+                }
+            };
+
+            const options = await new Promise((resolve, reject) => {
+                this.collectOptions(devId, model, (options) => {
+                    resolve(options);
+                });
+            });
 
-                    let stateID = statedesc.id;
+            const payload = await new Promise((resolve, reject) => {
+                const payloadConv = converter.convert(mappedModel, message, publish, options, meta);
+                if (typeof payloadConv === 'object') {
+                    resolve(payloadConv);
+                }
+            });
 
-                    if (has_elevated_debug) {
-                        this.elevatedMessage(devId, `ELEVATED I02: value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`, false);
-                    }
+            publish(payload, debugId);
+        }
+    }
 
-                    const common = {
-                        name: statedesc.name,
-                        type: statedesc.type,
-                        unit: statedesc.unit,
-                        read: statedesc.read,
-                        write: statedesc.write,
-                        icon: statedesc.icon,
-                        role: statedesc.role,
-                        min: statedesc.min,
-                        max: statedesc.max,
-                    };
-
-                    if (typeof value === 'object' && value.hasOwnProperty('stateid')) {
-                        stateID = `${stateID}.${value.stateid}`;
-                        if (value.hasOwnProperty('unit')) {
-                            common.unit = value.unit;
-                        }
-                        common.name = value.name ? value.name : value.stateid;
-                        common.role = value.role ? `value.${value.role}` : 'number';
-                        value = value.value;
-                    }
 
-                    // if needs to return value to back after timeout
-                    if (statedesc.isEvent) {
-                        this.updateStateWithTimeout(devId, statedesc.id, value, common, 300, (typeof value == typeof (!value) ? !value : ''));
-                    } else {
-                        if (statedesc.prepublish) {
-                            this.collectOptions(devId, model, options =>
-                                statedesc.prepublish(devId, value, newvalue =>
-                                    this.updateState(devId, stateID, newvalue, common), options)
-                            );
-                        } else {
-                            this.updateState(devId, stateID, value, common);
+    async onZigbeeEvent(type, entity, message) {
+        if (this.debugActive) this.debug(`Type ${type} device ${safeJsonStringify(entity)} incoming event: ${safeJsonStringify(message)}`);
+
+        const device = entity.device;
+        const mappedModel = entity.mapped;
+        const model = entity.mapped ? entity.mapped.model : entity.device.modelID;
+        const cluster = message.cluster;
+        const devId = device.ieeeAddr.substr(2);
+        const meta = {device};
+
+        const has_elevated_debug = this.checkDebugDevice(devId);
+        const debugId = Date.now();
+
+        // raw message data for logging and msg_from_zigbee
+        const msgForState = Object.assign({}, message);
+        delete msgForState['device'];
+        delete msgForState['endpoint'];
+        msgForState['endpoint_id'] = message.endpoint.ID;
+
+        if (has_elevated_debug) {
+            const message = `Zigbee Event of Type ${type} from device ${device.ieeeAddr}, incoming event: ${safeJsonStringify(msgForState)}`;
+            this.emit('device_debug', { ID:debugId, data: { ID: device.ieeeAddr, payload:safeJsonStringify(msgForState), flag:'01', IO:true }, message:message});
+
+        }
+        // this assigment give possibility to use iobroker logger in code of the converters, via meta.logger
+        meta.logger = this;
+
+        await this.adapter.checkIfModelUpdate(entity);
+
+        let _voltage = 0;
+        let _temperature = 0;
+        let _humidity = 0;
+
+        let isMessure = false;
+        let isBattKey = false;
+
+        if (mappedModel && mappedModel.meta && mappedModel.meta.battery) {
+            const isVoltage = mappedModel.meta.battery.hasOwnProperty('voltageToPercentage');
+
+            if (isVoltage) {
+                const keys = Object.keys(message.data);
+
+                for (const key of keys) {
+                    const value = message.data[key];
+
+                    if (value && value[1]) {
+                        if (key == 65282 && value[1][1]) {
+                            _voltage = value[1][1].elmVal;
+                            isBattKey = true;
+                            break;
+                        }
+                        if (key == 65281) {
+                            _voltage = value[1];
+                            isBattKey = true;
+                            _temperature = value[100];
+                            _temperature = _temperature /100;
+                            _humidity = value[101];
+                            _humidity = _humidity / 100;
+                            isMessure = true;
+                            break;
                         }
                     }
-                    has_published = true;
                 }
-            } catch (e) {
-                this.debug(`No states in device ${devId} : payload ${JSON.stringify(payload)}`);
-                if (has_elevated_debug)
-                    this.elevatedMessage(devId, `ELEVATED IE03: error when enumerating states of ${devId} for payload ${JSON.stringify(payload)}, ${(e ? e.name : 'undefined')} (${(e ? e.message : '')}).`, true);
             }
-            if (!has_published && has_elevated_debug) {
-                this.elevatedMessage(devId, `ELEVATED IE04: No value published for device ${devId}`, true);
+        }
 
+        // always publish link_quality and battery
+        if (message.linkquality) { // send battery with
+            this.publishToState(devId, model, {linkquality: message.linkquality}, debugId);
+            if (isBattKey) {
+                this.publishToState(devId, model, {voltage: _voltage}, debugId);
+                const  battProz = zigbeeHerdsmanConvertersUtils.batteryVoltageToPercentage(_voltage,entity.mapped.meta.battery.voltageToPercentage);
+                this.publishToState(devId, model, {battery: battProz}, debugId);
+            }
+            if (isMessure) {
+                this.publishToState(devId, model, {temperature: _temperature}, debugId);
+                this.publishToState(devId, model, {humidity: _humidity}), debugId;
             }
         }
-        else {
-            if (has_elevated_debug)
-                this.elevatedMessage(devId, `ELEVATED IE05: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`, true);
+
+        // 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 && (
+            Array.isArray(c.type) ? c.type.includes(type) : c.type === type));
+
+
+        if (!converters.length && type === 'readResponse') {
+            converters = mappedModel.fromZigbee.filter(c => c.cluster === cluster && (
+                Array.isArray(c.type) ? c.type.includes('attributeReport') : c.type === 'attributeReport'));
         }
+
+        if (!converters.length) {
+            if (type !== 'readResponse') {
+                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);
+            }
+            return;
+        }
+
+        meta.state = { state: '' };   // for tuya
+
+        this.processConverters(converters, devId, model, mappedModel, message, meta, debugId)
+            .catch((error) => {
+                //   'Error: Expected one of: 0, 1, got: 'undefined''
+                if (cluster !== '64529') {
+                    if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { error:'EPROC', IO:true }});
+                    this.error(`Error while processing converters DEVICE_ID: '${devId}' cluster '${cluster}' type '${type}'`);
+                }
+            });
     }
 
+
+
 }
 
 module.exports = StatesController;