iobroker.zigbee 3.2.5 → 3.3.1-alpha.0

package/lib/statescontroller.js

@@ -2,8 +2,7 @@
 
 const safeJsonStringify = require('./json');
 const { EventEmitter } = require('events');
-const statesMapping = require('./devices');
-const { getAdId, getZbId, zbIdorIeeetoAdId } = require('./utils');
+const modelDefinitions = require('./models');
 const fs = require('fs');
 const localConfig = require('./localConfig');
 const path = require('path');
@@ -27,7 +26,12 @@ class StatesController extends EventEmitter {
         this.debugMessages = { nodevice:{ in:[], out: []} };
         this.debugActive = true;
         this.deviceQueryBlock = [];
+        this.stashedErrors = { knownUnknownModels : new Set() }
         this.clearStashedErrors();
+        this.commonStates = {};
+        for (const s of modelDefinitions.commonStates) {
+            this.commonStates[s.prop || s.id] = s;
+        }
     }
 
     info(message, data) {
@@ -55,119 +59,129 @@ class StatesController extends EventEmitter {
     }
 
     clearStashedErrors() {
-        this.stashedErrors = {
-            errors:{},
-            unknownModels: {},
-            hasData:false
-        };
+        this.stashedErrors.errors = {};
+        this.stashedErrors.unknownModels = {},
+        this.stashedErrors.knownUnknownModels.clear();
+        this.stashedErrors.hasData = false;
         return this.stashedErrors;
     }
 
+    resetKnownUnknownModels() {
+        this.stashedErrors.unknownModels = {};
+        this.stashedErrors.knownUnknownModels.clear();
+    }
+
     debugMessagesById() {
         return this.debugMessages;
     }
 
+    async clearModelDefinitions() {
+        await modelDefinitions.clearModelDefinitions();
+    }
+
     async AddModelFromHerdsman(device, model) {
         const namespace = `${this.adapter.name}.admin`;
+        const isLegacy = Boolean(this.localConfig.getModelOption(model, 'legacy'));
+        if (model === undefined) {
+            const dev_name = this.verifyDeviceName(utils.zbIdorIeeetoAdId(this.adapter, device.ieeeAddr, false), model, device.modelID);
+            this.warn(`icon ${dev_name} for undefined Device not available. Check your devices.`);
+            return undefined;
+        }
 
-        if (this.localConfig.getOverrideWithTargetAndKey(model, 'options.legacy', true)) {
-            this.debug('Applying legacy definition for ' + model);
-            await this.addLegacyDevice(model);
+        const existingModelDesc = modelDefinitions.findModel(model, device.ieeeAddr, isLegacy);
+        const modelDesc = existingModelDesc ? existingModelDesc : await modelDefinitions.addExposeToDevices(device, model, this);
+        if (isLegacy) {
+            this.warn(`Trying to applying legacy definition for ${model} - ${modelDesc ? 'success.' : 'failed - no matching legacy model found'}`);
+            return;
         }
-        else {
-            this.debug('Generating states from exposes for ' + model);
-            // download icon if it external and not undefined
-            if (model === undefined) {
-                const dev_name = this.verifyDeviceName(utils.zbIdorIeeetoAdId(this.adapter, device.ieeeAddr, false), model, device.modelID);
-                this.warn(`icon ${dev_name} for undefined Device not available. Check your devices.`);
-            } else {
-                const modelDesc = await statesMapping.addExposeToDevices(device, this, model);
-                const srcIcon = (modelDesc ? modelDesc.icon : '');
-                const model_modif = model.replace(/\//g, '-');
-                const pathToAdminIcon = `img/${model_modif}.png`;
-                // source is a web address
-                if (srcIcon.startsWith('http')) {
-                    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'}`);
-                    }
+        if (!modelDesc || modelDesc == {}) return;
+
+        const srcIcon = (modelDesc && modelDesc.icon ? modelDesc.icon : '');
+        const model_modif = model.replace(/\//g, '-');
+        const pathToAdminIcon = `img/${model_modif}.png`;
+        // source is a web address
+        if (srcIcon.startsWith('http')) {
+            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 basee64F
+        const base64Match = srcIcon.match(/data:image\/(.+);base64,/);
+        if (base64Match) {
+            this.warn(`base 64 Icon matched, trying to save it to disk as ${pathToAdminIcon}`);
+            if (modelDesc) modelDesc.icon = pathToAdminIcon;
+            this.adapter.fileExists(namespace, pathToAdminIcon, async (err,result) => {
+                if (result) {
+                    this.info(`no need to save icon to ${pathToAdminIcon}`);
                     return;
                 }
-                // source is inline basee64F
-                const base64Match = srcIcon.match(/data:image\/(.+);base64,/);
-                if (base64Match) {
-                    this.warn(`base 64 Icon matched, trying to save it to disk as ${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}`);
+                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?.message || 'no reason given'}`);
                             return;
                         }
-                        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.debug(`${msg} -- success`);
-                            });
-                        }
-                        catch (err) {
-                            this.warn(`${msg} -- failed: ${err && err.message ? err.message : 'no reason given'}`)
-                        }
+                        this.debug(`${msg} -- success`);
                     });
+                }
+                catch (err) {
+                    this.warn(`${msg} -- failed: ${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 || 'unknown icon'} found - no copy needed`);
+                return;
+            }
+            // try 3 options for source file
+            let src = srcIcon; // as given
+            const locations=[];
+            if (!fs.existsSync(src)) {
+                src = path.normalize(this.adapter.expandFileName(src));
+                locations.push(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.warn(`unable to read ${src}: ${(err.message? err.message:' no message given')}`);
                     return;
                 }
-                // path is absolute
-                if (modelDesc) modelDesc.icon = pathToAdminIcon;
-                this.adapter.fileExists(namespace, pathToAdminIcon, async(err, result) => {
-                    if (result) {
-                        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)) {
-                        src = path.normalize(this.adapter.expandFileName(src));
-                        locations.push(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 (data) {
+                    this.adapter.writeFile(namespace, pathToAdminIcon, data, (err) => {
                         if (err) {
-                            this.warn(`unable to read ${src}: ${(err.message? err.message:' no message given')}`);
+                            this.error(`error writing file ${path}: ${err.message ? err.message : 'no reason given'}`);
                             return;
                         }
-                        if (data) {
-                            this.adapter.writeFile(namespace, pathToAdminIcon, data, (err) => {
-                                if (err) {
-                                    this.error(`error writing file ${path}: ${err.message ? err.message : 'no reason given'}`);
-                                    return;
-                                }
-                                this.debug('Updated image file ' + pathToAdminIcon);
-                            });
-                            return;
-                        }
-                        this.error(`fs.readFile failed - neither error nor data is returned!`);
+                        this.debug('Updated image file ' + pathToAdminIcon);
                     });
-                });
-            }
-        }
+                    return;
+                }
+                this.error(`fs.readFile failed - neither error nor data is returned!`);
+            });
+        });
+        return modelDesc;
+
     }
 
     async updateDebugDevices(debugDevices) {
@@ -255,8 +269,8 @@ class StatesController extends EventEmitter {
                 return;
             }
 
-            const devId = getAdId(this.adapter, id); // iobroker device id
-            const deviceId = getZbId(id); // zigbee device id
+            const devId = utils.getAdId(this.adapter, id); // iobroker device id
+            const deviceId = utils.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}`;
@@ -347,18 +361,20 @@ class StatesController extends EventEmitter {
 
     async getDevStates(deviceId, model) {
         try {
-            let states;
+            let states = [];
             let stateModel;
+            // if i know the model is unknown, dont keep searching.
+            if (this.stashedErrors.knownUnknownModels.has(model)) return { states: modelDefinitions.commonStates };
             if (model === 'group') {
-                states = statesMapping.groupStates;
+                states = modelDefinitions.groupStates;
             } else {
-                stateModel = statesMapping.findModel(model);
+                stateModel = modelDefinitions.findModel(model, utils.adIdtoZbIdorIeee(this.adapter,deviceId), this.localConfig.getModelOption(model, 'legacy', false));
                 if (!stateModel) {
                     // try to get the model from the exposes
                     this.stashUnknownModel(`getDevStates:${deviceId}`,`Model "${model}" not found for Device ${deviceId}`);
-                    states = statesMapping.commonStates;
+                    states = modelDefinitions.commonStates;
                 } else {
-                    states = stateModel.states;
+                    states = modelDefinitions.commonStates.concat([...stateModel.states]);
                 }
                 if (typeof states === 'function' && !states.prototype) {
                     const entity = await this.adapter.zbController.resolveEntity(deviceId);
@@ -379,9 +395,15 @@ class StatesController extends EventEmitter {
             if (!this.stashedErrors.errors.hasOwnProperty(key))
             {
                 if (error) this.error(msg); else this.warn(msg);
-                this.stashedErrors.errors[key] = { message:msg, ts:[Date.now()], error:error };
+                this.stashedErrors.errors[key] = { message:msg, ts:[Date.now()], count: 1, error:error };
+            }
+            else {
+                if (this.stashedErrors.errors[key].ts.length < 2)
+                    this.stashedErrors.errors[key].ts.push(Date.now());
+                else
+                    this.stashedErrors.errors[key].ts[1]=Date.now();
+                this.stashedErrors.errors[key].count++;
             }
-            else this.stashedErrors.errors[key].ts.push(Date.now());
             this.stashedErrors.hasData = true;
             this.adapter.setState('info.lasterror', JSON.stringify({ error: key, data:this.stashedErrors.errors[key]}), true)
         }
@@ -391,14 +413,20 @@ class StatesController extends EventEmitter {
     stashUnknownModel(model, msg) {
         try {
             if (!this.stashedErrors.unknownModels.hasOwnProperty(model)) {
-                this.stashedErrors.unknownModels[model] = { message:msg, ts:[Date.now()], error:true };
+                this.stashedErrors.unknownModels[model] = { message:msg, ts:[Date.now()], count: 1, error:true };
                 this.error(`Unknown ${model}: ${msg}`)
             }
-            else this.stashedErrors.unknownModels[model].ts.push(Date.now());
+            else {
+                if (this.stashedErrors.unknownModels[model].count == 1) this.stashedErrors.unknownModels[model].ts.push(Date.now());
+                else
+                    this.stashedErrors.unknownModels[model].ts[1] = Date.now();
+                this.stashedErrors.unknownModels[model].count++;
+            }
             this.stashedErrors.hasData = true;
             this.adapter.setState('info.lasterror', JSON.stringify({ model: model, data:this.stashedErrors.unknownModels[model]}), true)
+            return this.stashedErrors.unknownModels[model].count;
         }
-        catch { /* */ }
+        catch { return -1 }
     }
 
     async triggerComposite(_deviceId, stateDesc, interactive) {
@@ -468,11 +496,11 @@ class StatesController extends EventEmitter {
     }
 
     async publishFromStates(deviceId, model, stateIDs, options, debugID) {
-        const adId = zbIdorIeeetoAdId(this.adapter, deviceId, true);
+        const adId = utils.zbIdorIeeetoAdId(this.adapter, deviceId, true);
         for (const stateID of Object.keys(stateIDs).sort((a,b) => {if (a=='device_query' || a=='state') return (b=='device_query' ? -1 : 1); else return a.localeCompare(b)})) {
             const state = await this.adapter.getStateAsync(`${adId}.${stateID}`);
-            if (stateIDs[stateID]!= null) state.val = stateIDs[stateID];
             if (state && state.hasOwnProperty('val')) {
+                if (stateIDs[stateID]!= null) state.val = stateIDs[stateID];
                 await this.publishFromState(deviceId, model, stateID, state, options, debugID)
             }
         }
@@ -496,8 +524,7 @@ class StatesController extends EventEmitter {
             }
             return;
         }
-        const commonStates = statesMapping.commonStates.find(statedesc => stateKey === statedesc.id);
-        const stateDesc = (commonStates === undefined ? devStates.states.find(statedesc => stateKey === statedesc.id) : commonStates);
+        const stateDesc = devStates.states.find(statedesc => stateKey === statedesc.id);
         const stateModel = devStates.stateModel;
         if (!stateDesc) {
             const message = (`No state available for '${model}' with key '${stateKey}'`);
@@ -616,6 +643,12 @@ class StatesController extends EventEmitter {
         this.adapter.extendObject(id, {common: {deactivated: inActive, color:inActive ? '#888888' : null, statusStates: inActive ? null : {onlineId:`${id}.available`} }});
     }
 
+    async getDeviceActivated(id) {
+
+        const obj = await this.adapter.getObject(id);
+        return (obj?.common?.deactivated === false);
+    }
+
     storeDeviceName(id, name) {
         return this.localConfig.updateDeviceName(id, name);
     }
@@ -625,9 +658,10 @@ class StatesController extends EventEmitter {
         const options = { recursive:true };
         try {
             await this.adapter.delObjectAsync(devId,options);
+            return {status:true};
         } catch (error) {
             this.adapter.log.warn(`Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`);
-            return `Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`;
+            return { status:false, message: `Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`};
         }
     }
 
@@ -647,7 +681,7 @@ class StatesController extends EventEmitter {
 
     async deleteOrphanedDeviceStates(ieeeAddr, model, force, callback, markOnly) {
         const devStates = await this.getDevStates(ieeeAddr, model);
-        const commonStates = statesMapping.commonStates;
+        const commonStates = modelDefinitions.commonStates || [];
         const devId = utils.zbIdorIeeetoAdId(this.adapter, ieeeAddr, false);
         const messages = [];
         this.adapter.getStatesOf(devId, (err, states) => {
@@ -706,101 +740,93 @@ class StatesController extends EventEmitter {
         setTimeout(() => this.updateState(dev_id, name, outValue, common), timeout);
     }
 
-    async updateState(devId, name, value, common) {
-        const obj = await this.adapter.getObjectAsync(devId)
-        if (obj) {
-            if (!obj.common.deactivated) {
-                const new_common = {name: name, color:null};
-                const stateId = devId + '.' + name;
-                const new_name = obj.common.name;
-                if (common) {
-                    for (const key in common) {
-                        if (common[key] !== undefined) new_common[key] = common[key];
-                    }
+    async updateState(devId, name, value, common, force) {
+        const new_common = {name: name, color:null};
+        const stateId = devId + '.' + name;
+        if (common) {
+            for (const key in common) {
+                if (common[key] !== undefined) new_common[key] = common[key];
+            }
+        }
+        // check if state exist
+        const stobj = await this.adapter.getObjectAsync(stateId);
+        let hasChanges = Boolean(force); // if force is set we always update the state.
+        if (stobj) {
+            // update state - not change name and role (user can it changed)
+            if (!force) {
+                if (stobj.common.name) {
+                    delete new_common.name;
                 }
-                // check if state exist
-                const stobj = await this.adapter.getObjectAsync(stateId);
-                let hasChanges = false;
-                if (stobj) {
-                    // update state - not change name and role (user can it changed)
-                    if (stobj.common.name) {
-                        delete new_common.name;
-                    } else {
-                        new_common.name = `${new_name} ${new_common.name}`;
-                    }
-                    // force allow change of level.color roles.
-                    if (name.includes('color')) {
-                        console.warn(`allowing role change for ${name}`)
-                    } else delete new_common.role;
-
-                    // check whether any common property is different
-                    if (stobj.common) {
-                        for (const property in new_common) {
-                            if (stobj.common.hasOwnProperty(property)) {
-                                if (stobj.common[property] === new_common[property]) {
-                                    delete new_common[property];
-                                } else {
-                                    hasChanges = true;
-                                }
+            }
+            // always force allow change of level.color roles.
+            if ((name.includes('color') || force) && (stobj.common.role != new_common.role)) {
+                console.info(`${force ? 'forc' : 'allow'}ing role change for ${name}`)
+            } else delete new_common.role;
+
+            // check whether any common property is different
+            if (!force) {
+                if (stobj.common) {
+                    for (const property in new_common) {
+                        if (stobj.common.hasOwnProperty(property)) {
+                            if (stobj.common[property] === new_common[property]) {
+                                delete new_common[property];
+                            } else {
+                                hasChanges = true;
                             }
                         }
                     }
-                } else {
-                    const matches = stateId.match((/\./g));
-                    if (matches && matches.length>1) {
-                        const channels = stateId.split('.');
-                        const SubChannels = [channels.shift()];
-                        channels.pop();
-                        for (const channel of channels) {
-                            SubChannels.push(channel);
-                            const id = SubChannels.join('.');
-                            await this.adapter.extendObjectAsync(id, {type: 'channel', common: { name:channel}, native:{}})
-                        }
-                    }
-                    hasChanges = true;
                 }
+                else hasChanges = true; // we dont have common => we need common
+            }
+        } else {
+            const matches = stateId.match((/\./g));
+            if (matches && matches.length>1) {
+                const channels = stateId.split('.');
+                const SubChannels = [channels.shift()];
+                channels.pop();
+                for (const channel of channels) {
+                    SubChannels.push(channel);
+                    const id = SubChannels.join('.');
+                    await this.adapter.extendObjectAsync(id, {type: 'channel', common: { name:channel}, native:{}})
+                }
+            }
+            hasChanges = true;
+        }
 
-                // only change object when any common property has changed
-                // first check value
-                if (value !== undefined) {
-                    const type = stobj ? stobj.common.type : new_common.type;
-                    if (type === 'number') {
-                        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')
-                                nval = minval;
-                            else
-                                nval = 0;
-                        }
-                        if (typeof minval == 'number' && nval < minval) {
-                            hasChanges = true;
-                            new_common.color = '#FF0000'
-                            value = minval
-                            this.stashErrors(`${stateId}.min`,`State value for ${stateId} has value "${nval}" less than min "${minval}".`, false );
-                        }
-                        if (typeof maxval == 'number' && nval > maxval) {
-                            hasChanges = true;
-                            hasChanges = true;
-                            new_common.color = '#FF0000'
-                            value = maxval;
-                            this.stashErrors(`${stateId}.max`,`State value for ${stateId} has value "${nval}" greater than max "${maxval}".`, false );
-                        }
-                    }
+        // first check value
+        if (value !== undefined) {
+            const type = stobj ? stobj.common.type : new_common.type;
+            if (type === 'number') {
+                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')
+                        nval = minval;
+                    else
+                        nval = 0;
                 }
-                //
-                if (hasChanges) {
-                    this.adapter.extendObject(stateId, {type: 'state', common: new_common, native: {}}, () =>
-                        value !== undefined && this.setState_typed(stateId, value, true, stobj ? stobj.common.type : new_common.type));
-                } else if (value !== undefined) {
-                    this.setState_typed(stateId, value, true, stobj.common.type);
+                if (typeof minval == 'number' && nval < minval) {
+                    hasChanges = true;
+                    new_common.color = '#FF0000'
+                    value = minval
+                    this.stashErrors(`${stateId}.min`,`State value for ${stateId} has value "${nval}" less than min "${minval}".`, false );
+                }
+                if (typeof maxval == 'number' && nval > maxval) {
+                    hasChanges = true;
+                    new_common.color = '#FF0000'
+                    value = maxval;
+                    this.stashErrors(`${stateId}.max`,`State value for ${stateId} has value "${nval}" greater than max "${maxval}".`, false );
                 }
-            } else {
-                if (this.debugActive) this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
             }
-        } else {
-            if (this.debugActive) this.debug(`UpdateState: missing device ${devId}`);
+        }
+        //
+        // only change object when any common property has changed
+        if (hasChanges) {
+            this.adapter.extendObject(stateId, {type: 'state', common: new_common, native: {}}, () =>
+                value !== undefined && this.setState_typed(stateId, value, true, stobj ? stobj.common.type : new_common.type));
+        } else if (value !== undefined) {
+            this.setState_typed(stateId, value, true, stobj.common.type);
         }
     }
 
@@ -851,21 +877,10 @@ class StatesController extends EventEmitter {
         this.adapter.setState(id, value, ack, callback);
     }
 
-    async applyLegacyDevices() {
-        const legacyModels = await this.localConfig.getLegacyModels();
-        const modelarr1 = [];
-        statesMapping.devices.forEach(item => modelarr1.push(item.models));
-        statesMapping.setLegacyDevices(legacyModels);
-        const modelarr2 = [];
-        statesMapping.devices.forEach(item => modelarr2.push(item.models));
-    }
-
     async addLegacyDevice(model) {
-        statesMapping.setLegacyDevices([model]);
-        statesMapping.getByModel();
+        return await modelDefinitions.findModel(model, undefined, undefined, true);
     }
 
-
     async getDefaultGroupIcon(id, members) {
         let groupID = Number(id);
         if (typeof id == 'string' && isNaN(groupID)) {
@@ -891,7 +906,10 @@ class StatesController extends EventEmitter {
         const __dev_name = this.verifyDeviceName(dev_id, model, (dev_name ? dev_name : model));
         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 objId = model=='group' ? `group_${dev_id}` : dev_id;
+        const obj = await this.adapter.getObjectAsync( objId);
+        this.adapter.zbController.setDeviceEnable(dev_id, (obj?.common?.disabled == true));
+        const modelDesc = await modelDefinitions.findModel(model, `0x${dev_id}`, this.localConfig.getModelOption(model, 'legacy'));
         const modelIcon = (model == 'group' ?
             await this.getDefaultGroupIcon(dev_id) :
             modelDesc && modelDesc.icon ? modelDesc.icon : 'img/unknown.png');
@@ -914,9 +932,6 @@ class StatesController extends EventEmitter {
                 }
             }
         }
-        const objId = model=='group' ? `group_${dev_id}` : dev_id;
-
-        const obj = await this.adapter.getObjectAsync( objId);
 
         const myCommon = {
             name: __dev_name,
@@ -1073,7 +1088,7 @@ class StatesController extends EventEmitter {
         }
     }
 
-    async syncDevStates(dev, model) {
+    async syncDevStates(dev, model, force) {
         if (this.debugActive) this.debug('synchronizing device states for ' + dev.ieeeAddr + ' (' + model + ')');
         const devId = utils.zbIdorIeeetoAdId(this.adapter, dev.ieeeAddr, false);
         // devId - iobroker device id
@@ -1081,7 +1096,7 @@ class StatesController extends EventEmitter {
         if (!devStates) {
             return;
         }
-        const states = statesMapping.commonStates.concat(devStates.states);
+        const states = devStates.states;
 
         for (const stateInd in states) {
             if (!states.hasOwnProperty(stateInd)) {
@@ -1094,10 +1109,11 @@ class StatesController extends EventEmitter {
                 return;
             }
             // Filter out non routers or devices that are battery driven for the availability flag
-            if (statedesc.id === 'available') {
-                if (!(dev.type === 'Router') || dev.powerSource === 'Battery') {
+            if (statedesc.id === 'available' && dev.type != 'Router' && dev.type != 'EndDevice') {
+                /* if (!(dev.type === 'Router') || dev.powerSource === 'Battery') {
                     continue;
-                }
+                } */
+                continue;
             }
             // lazy states
             if (statedesc.lazy) {
@@ -1116,22 +1132,11 @@ class StatesController extends EventEmitter {
                 max: statedesc.max,
                 states: statedesc.states,
             };
-            this.updateState(devId, statedesc.id, undefined, common);
+            this.updateState(devId, statedesc.id, undefined, common, force);
         }
         this.deleteOrphanedDeviceStates(dev.ieeeAddr, model, false, undefined, true);
     }
 
-    async getExposes() {
-        await this.localConfig.init();
-        await this.applyLegacyDevices();
-        try {
-            statesMapping.fillStatesWithExposes(this);
-        }
-        catch (error) {
-            this.error(`Error applying exposes: ${error && error.message ? error.message : 'no error message'} ${error && error.stack ? error.stack : ''}`);
-        }
-    }
-
     async elevatedMessage(device, message, isError) {
         if (isError) this.error(message); else this.warn(message);
         // emit data here for debug tab later
@@ -1143,6 +1148,76 @@ class StatesController extends EventEmitter {
         this.emit('debugmessage', {id: id, message:message});
     }
 
+    async publishToDefinedState(devId, model, statedesc, payload, debugId) {
+        const has_elevated_debug = (this.checkDebugDevice(devId) && !payload.hasOwnProperty('msg_from_zigbee'));
+        let value = undefined;
+        let mode = 'prop/id'
+        if (statedesc.getter) {
+            value = statedesc.getter(payload);
+            mode = 'getter'
+        } else {
+            value = payload[statedesc.prop];
+            if (value === undefined || value === null) value = payload[statedesc.id];
+        }
+
+        let stateID = statedesc.id;
+
+        // checking value
+        if (value === undefined || value === null) {
+            const message = `value '${JSON.stringify(value)}' from device ${devId} via ${mode} for '${statedesc.name} (ID ${statedesc.id} ${statedesc.prop ? 'with property '+statedesc.prop : ''})`;
+            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);
+            return false;
+        }
+
+
+        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:'04', 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 }});
+
+        } else {
+            if (statedesc.prepublish) {
+                this.collectOptions(devId, model, false, 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 }});
+            }
+        }
+        return true;
+
+    }
+
     async publishToState(devId, model, payload, debugId) {
         try {
             if (!debugId) debugId = Date.now();
@@ -1165,70 +1240,12 @@ class StatesController extends EventEmitter {
             let has_published = false;
             if (devStates.states !== undefined) {
                 try {
-                    const states = statesMapping.commonStates.concat(
-                        devStates.states.filter(statedesc => payload.hasOwnProperty(statedesc.prop || statedesc.id))
+                    const states = 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;
-                        }
-
-                        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:'04', 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 }});
-
-                        } else {
-                            if (statedesc.prepublish) {
-                                this.collectOptions(devId, model, false, 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;
+                        has_published |= await this.publishToDefinedState(devId, model, statedesc, payload, debugId);
                     }
                 } catch (e) {
                     const message = `unable to enumerate states of ${devId} for payload ${JSON.stringify(payload)}, ${(e ? e.name : 'undefined')} (${(e ? e.message : '')}).`;
@@ -1348,7 +1365,7 @@ 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!`);
+            this.debug(`zigbee event for ${device.ieeeAddr} received during interview!`);
             return;
         }
 
@@ -1407,19 +1424,17 @@ class StatesController extends EventEmitter {
 
         // always publish link_quality and battery
         if (message.linkquality) { // send battery with
-            this.publishToState(devId, model, {linkquality: message.linkquality}, debugId);
+            this.publishToDefinedState(devId, model, this.commonStates.linkquality, {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);
+                this.publishToState(devId, model, {voltage: _voltage, battery: battProz}, debugId);
             }
             if (isMessure) {
-                this.publishToState(devId, model, {temperature: _temperature}, debugId);
-                this.publishToState(devId, model, {humidity: _humidity}), debugId;
+                this.publishToState(devId, model, {temperature: _temperature, humidity: _humidity}, debugId);
             }
         }
 
-        this.publishToState(devId, model, {msg_from_zigbee: safeJsonStringify(msgForState)}, -1);
+        this.publishToDefinedState(devId, model, this.commonStates.msg_from_zigbee, {msg_from_zigbee: safeJsonStringify(msgForState)}, -1);
 
         if (!entity.mapped) {
             return;