iobroker.zigbee 2.0.0 → 2.0.1

package/lib/statescontroller.js

@@ -6,8 +6,15 @@ const getAdId = require('./utils').getAdId;
 const getZbId = require('./utils').getZbId;
 const fs = require('fs');
 const axios = require('axios');
-
-let savedDeviceNamesDB = {};
+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 { numberWithinRange } = require('zigbee-herdsman-converters/lib/utils');
 
 
 class StatesController extends EventEmitter {
@@ -17,18 +24,13 @@ class StatesController extends EventEmitter {
         this.adapter.on('stateChange', this.onStateChange.bind(this));
         this.query_device_block = [];
         this.debugDevices = undefined;
-        const fn = adapter.expandFileName('dev_names.json');
-        this.dev_names_fn = fn.replace('.', '_');
         this.retTimeoutHandle = null;
-        fs.readFile(this.dev_names_fn, (err, data) => {
-            if (!err) {
-                try {
-                    savedDeviceNamesDB = JSON.parse(data);
-                } catch {
-                    savedDeviceNamesDB = {};
-                }
-            }
-        });
+        this.localConfig = new localConfig(adapter);
+        this.compositeData = {};
+        this.cleanupRequired = false;
+        this.timeoutHandleUpload = null;
+        this.ImagesToDownload = [];
+        this.stashedErrors = {};
     }
 
     info(message, data) {
@@ -51,30 +53,59 @@ class StatesController extends EventEmitter {
         this.adapter.sendError(error, message);
     }
 
-    retainDeviceNames() {
-        clearTimeout(this.retTimeoutHandle);
-        this.retTimeoutHanlde = setTimeout(() => {
-            fs.writeFile(this.dev_names_fn, JSON.stringify(savedDeviceNamesDB, null, 2), error => {
-                if (error) {
-                    this.error(`error saving device names: ${(error && error.message ? error.message : 'no error message')} ${(error && error.stack ? error.stack : 'no call stack')}`);
-                } else {
-                    this.debug('saved device names');
-                }
-            });
-        }, 5000);
+    TriggerUpload(delay) {
+        if (this.timeoutHandleUpload) return;
+        this.warn('triggering upload')
+        this.timeoutHandleUpload = this.adapter.setTimeout(() => {
+            try {
+                this.warn('executing upload')
+                exec('iobroker upload zigbee', (error, stdout, stderr) => {
+                    if (error) this.error('exec error: ' + JSON.stringify(error));
+                    this.warn('upload done');
+                });
+            }
+            catch (error) {
+                this.error('error on upload exec');
+            }
+        }, delay);
+    }
+
+    getStashedErrors() {
+        if (!this.stashedErrors) return [];
+        return Object.values(this.stashedErrors);
     }
 
-    getDebugDevices() {
-        this.debugDevices = [];
-        this.adapter.getState(`${this.adapter.namespace}.info.debugmessages`, (err, state) => {
+    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.info(`debug devices set to ${JSON.stringify(this.debugDevices)}`);
+                if (callback) callback(this.debugDevices);
             }
-        });
+        } else {
+            // this.info(`debug devices was already set to ${JSON.stringify(this.debugDevices)}`);
+            callback(this.debugDevices)
+        }
+    }
 
+    async toggleDeviceDebug(id) {
+        const arr = /zigbee.[0-9].([^.]+)/gm.exec(id);
+        if (arr[1] === undefined) {
+            this.warn(`unable to extract id from state ${id}`);
+            return [];
+        }
+        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);
+        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;
     }
 
     checkDebugDevice(dev) {
@@ -82,9 +113,12 @@ class StatesController extends EventEmitter {
         if (this.debugDevices === undefined) {
             this.getDebugDevices();
         }
-        for (const addressPart of this.debugDevices) {
-            if (typeof dev === 'string' && dev.includes(addressPart)) {
-                return true;
+        else
+        {
+            for (const addressPart of this.debugDevices) {
+                if (typeof dev === 'string' && dev.includes(addressPart)) {
+                    return true;
+                }
             }
         }
         return false;
@@ -101,10 +135,10 @@ class StatesController extends EventEmitter {
             if (id.endsWith('debugmessages')) {
                 if (typeof state.val === 'string' && state.val.length > 2) {
                     this.debugDevices = state.val.split(';');
-
                 } else {
                     this.debugDevices = [];
                 }
+                this.info('debug devices set to ' + JSON.stringify(this.debugDevices));
                 return;
             }
 
@@ -132,7 +166,13 @@ class StatesController extends EventEmitter {
                         return;
                     }
                     if (model === 'group') {
-                        deviceId = parseInt(deviceId.replace('0xgroup_', ''));
+                        const match = deviceId.match(/group_(\d+)/gm);
+                        if (match) {
+                            deviceId = parseInt(match[1]);
+                            this.publishFromState(deviceId, model, stateKey, state, {});
+                            return;
+                        }
+
                     }
                     this.collectOptions(id.split('.')[2], model, options =>
                         this.publishFromState(deviceId, model, stateKey, state, options));
@@ -143,7 +183,7 @@ class StatesController extends EventEmitter {
 
     async collectOptions(devId, model, callback) {
         const result = {};
-        // find model states for options and get it values
+        // find model states for options and get it values. No options for groups !!!
         const devStates = await this.getDevStates('0x' + devId, model);
         if (devStates == null || devStates == undefined || devStates.states == null || devStates.states == undefined) {
             callback(result);
@@ -207,6 +247,34 @@ class StatesController extends EventEmitter {
         }
     }
 
+    async triggerComposite(_deviceId, model, stateDesc, interactive) {
+        const deviceId = (_deviceId.replace('0x', ''));
+        const idParts = stateDesc.id.split('.').slice(-2);
+        const key = `${deviceId}.${idParts[0]}`;
+        const handle = this.compositeData[key]
+        const factor = (interactive ? 10 : 1);
+        if (handle) this.adapter.clearTimeout(handle);
+        this.compositeData[key] = this.adapter.setTimeout(async () => {
+            delete this.compositeData[key];
+            const parts = stateDesc.id.split('.');
+            parts.pop();
+
+            this.adapter.getStatesOf(deviceId, parts.join('.'),async (err,states) => {
+                if (!err && states) {
+                    const components = {};
+                    for (const stateobj of states) {
+                        const ckey = stateobj._id.split('.').pop();
+                        const state = await this.adapter.getState(stateobj._id);
+                        if (state && state.val != undefined) {
+                            components[ckey] = state.val;
+                        }
+                    }
+                    this.adapter.setState(`${deviceId}.${stateDesc.compositeState}`, JSON.stringify(components));
+                }
+            })
+        }, (stateDesc.compositeTimeout ? stateDesc.compositeTimeout : 100) * factor);
+    }
+
     async publishFromState(deviceId, model, stateKey, state, options) {
         this.debug(`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
         const elevated = this.checkDebugDevice(deviceId);
@@ -232,7 +300,7 @@ class StatesController extends EventEmitter {
                 this.error(`ELEVATED OE2: no value for device ${deviceId} type '${model}'`);
             return;
         }
-        let stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0}];
+        let stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0, source:state.from}];
         if (stateModel && stateModel.linkedStates) {
             stateModel.linkedStates.forEach(linkedFunct => {
                 try {
@@ -264,55 +332,51 @@ class StatesController extends EventEmitter {
         this.emit('changed', deviceId, model, stateModel, stateList, options);
     }
 
-    renameDevice(id, newName) {
-        this.storeDeviceName(id, newName);
-        this.adapter.extendObject(id, {common: {name: newName}});
+    async renameDevice(id, newName) {
+        const stateId = id.replace(`${this.adapter.namespace}.`, '')
+        const obj = await this.adapter.getObjectAsync(id);
+        if (newName == null || newName == undefined) newName = '';
+        let objName = newName;
+        if (newName.length < 1 || newName == obj.common.type) {
+            objName = (obj.common.type == 'group' ? stateId.replace('_',' ') : obj.common.type);
+        }
+        this.localConfig.updateDeviceName(stateId, newName);
+        this.debug('rename device: newname ~' + newName + '~ objName ~' + objName + '~')
+        this.adapter.extendObject(id, {common: {name: objName}});
     }
 
-    setDeviceActivated(id, active) {
-        this.adapter.extendObject(id, {common: {deactivated: active}});
+    verifyDeviceName(id, model ,name) {
+        const savedId = id.replace(`${this.adapter.namespace}.`, '');
+        return this.localConfig.NameForId(id, model, name);
     }
 
-    async rebuildRetainDeviceNames() {
-        savedDeviceNamesDB = {};
-        const devList = await this.adapter.getAdapterObjectsAsync();
 
-        for (const key in devList) {
-            if (devList[key].type == 'device') {
-                savedDeviceNamesDB[devList[key]._id.replace(`${this.adapter.namespace}.`, '')] = devList[key].common.name;
-            }
-        }
-        this.retainDeviceNames();
+    setDeviceActivated(id, active) {
+        this.adapter.extendObject(id, {common: {deactivated: active}});
     }
 
     storeDeviceName(id, name) {
-        savedDeviceNamesDB[id.replace(`${this.adapter.namespace}.`, '')] = name;
-        this.retainDeviceNames();
+        return this.localConfig.updateDeviceName(id, name);
     }
 
-    verifyDeviceName(id, name) {
-        const savedId = id.replace(`${this.adapter.namespace}.`, '');
-        if (!savedDeviceNamesDB.hasOwnProperty(savedId)) {
-            savedDeviceNamesDB[savedId] = name;
-            this.retainDeviceNames();
-        }
-        return savedDeviceNamesDB[savedId];
-    }
 
     async deleteObj(devId) {
         const options = { recursive:true };
         try {
-            this.adapter.delObject(devId,options), (err) => { }
+            this.adapter.delObject(devId,options), (err) => {
+                this.adapter.log.info(`Cannot delete Object ${devId}: ${err}`);
+            }
 
-        } catch (err) {
-            this.adapter.log.info(`Cannot delete Group ${devId}: ${err}`);
+        } catch (error) {
+            this.adapter.log.info(`Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`);
         }
     }
 
-    async deleteOrphanedDeviceStates(ieeeAddr, model, force, callback) {
+    async deleteOrphanedDeviceStates(ieeeAddr, model, force, callback, markOnly) {
         const devStates = await this.getDevStates(ieeeAddr, model);
         const commonStates = statesMapping.commonStates;
         const devId = ieeeAddr.substr(2);
+        const messages = [];
         this.adapter.getStatesOf(devId, (err, states) => {
             if (!err && states) {
                 states.forEach((state) => {
@@ -330,17 +394,35 @@ class StatesController extends EventEmitter {
                     if (commonStates.find(statedesc => statename === statedesc.id) === undefined &&
                         devStates.states.find(statedesc => statename === statedesc.id) === undefined
                     ) {
-                        if (state.common.hasOwnProperty('custom') && !force) {
-                            this.info(`keeping disconnected state ${JSON.stringify(statename)} of  ${devId} `);
+                        this.cleanupRequired |= markOnly;
+                        if (state.common.hasOwnProperty('custom') && !force && !markOnly) {
+                            messages.push(`keeping disconnected state ${JSON.stringify(statename)} of ${devId} `)
+                            this.info(`keeping disconnected state ${JSON.stringify(statename)} of ${devId} `);
+                            this.cleanupRequired == true;
                         } else {
-                            this.info(`deleting disconnected state ${JSON.stringify(statename)} of  ${devId} `);
-                            this.adapter.deleteState(devId, null, state._id);
+                            if (markOnly) {
+                                this.adapter.extendObjectAsync(devId.concat('.',statename), {common: {color:'#E67E22'}})
+
+                            }
+                            else
+                            {
+                                try {
+                                    this.info(`deleting disconnected state ${JSON.stringify(statename)} of ${devId} `);
+                                    messages.push(`deleting disconnected state ${JSON.stringify(statename)} of ${devId} `);
+                                    this.deleteObj(devId.concat('.',statename));
+                                }
+                                catch (error) {
+                                    //messages.push(`ERROR: failed to delete state ${JSON.stringify(statename)} of ${devId} `)
+                                }
+                            }
                         }
                     } else {
                         this.debug(`keeping connecte state ${JSON.stringify(statename)} of  ${devId} `);
+                        messages.push(`keeping connecte state ${JSON.stringify(statename)} of  ${devId} `);
                     }
                 });
             }
+            if (callback) callback(messages);
         });
     }
 
@@ -349,89 +431,134 @@ class StatesController extends EventEmitter {
         setTimeout(() => this.updateState(dev_id, name, outValue, common), timeout);
     }
 
-    updateState(devId, name, value, common) {
-        this.adapter.getObject(devId, (err, obj) => {
-            if (obj) {
-                if (!obj.common.deactivated) {
-                    const new_common = {name: name};
-                    const id = 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;
-                        }
+    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) {
+                    if (common.name !== undefined) {
+                        new_common.name = common.name;
                     }
-                    // check if state exist
-                    this.adapter.getObject(id, (err, stobj) => {
-                        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}`;
-                            }
-                            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;
-                                        }
-                                    }
+                    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;
+                    }
+                }
+                // 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}`;
+                    }
+                    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;
                                 }
                             }
-                        } else {
-                            hasChanges = true;
                         }
-
-                        // only change object when any common property has changed
-                        if (hasChanges) {
-                            this.adapter.extendObject(id, {type: 'state', common: new_common, native: {}}, () =>
-                                value !== undefined && this.setState_typed(id, value, true, stobj ? stobj.common.type : new_common.type));
-                        } else if (value !== undefined) {
-                            this.setState_typed(id, value, true, stobj.common.type);
+                    }
+                } 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 {
-                    this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
+                // 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) || -Number.MAX_VALUE;
+                        const maxval = (stobj ? stobj.common.max: new_common.max) || Number.MAX_VALUE;
+                        let nval = (typeof value == 'number' ? value : parseFloat(value));
+                        if (isNaN(nval)) {
+                            if (minval !== undefined && typeof minval === 'number')
+                                nval = minval;
+                            else
+                                nval = 0;
+                        }
+                        if (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.stashedErrors[`${stateId}.min`] = `State value for ${stateId} has value "${nval}." less than min "${minval}"`;
+                            }
+                        }
+                        if (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.stashedErrors[`${stateId}.max`] = `State value for ${stateId} has value "${nval}" more than max "${maxval}".`;
+                            }
+                        }
+                    }
+                }
+                //
+                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);
                 }
             } else {
-                this.debug(`UpdateState: missing device ${devId} ${JSON.stringify(obj)}`);
+                this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
             }
-        });
+        } else {
+            this.debug(`UpdateState: missing device ${devId} ${JSON.stringify(obj)}`);
+        }
     }
 
     setState_typed(id, value, ack, type, callback) {
@@ -476,28 +603,51 @@ class StatesController extends EventEmitter {
         this.adapter.setState(id, value, ack, callback);
     }
 
-    updateDev(dev_id, dev_name, model, callback) {
-        const __dev_name = this.verifyDeviceName(dev_id, dev_name);
+    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 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 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}`);
         const id = '' + dev_id;
         const modelDesc = statesMapping.findModel(model);
-        let icon = (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 undef
+        // download icon if it external and not undefined
         if (model === undefined) {
             this.warn(`download icon ${__dev_name} for undefined Device not available. Check your devices.`);
         } else {
             const model_modif = model.replace(/\//g, '-');
-            const pathToIcon = `${this.adapter.adapterDir}/admin/img/${model_modif}.png`;
+            const pathToAdminIcon = `img/${model_modif}.png`;
 
             if (icon.startsWith('http')) {
                 try {
-                    if (!fs.existsSync(pathToIcon)) {
-                        this.warn(`download icon from ${icon} saved into ${pathToIcon}`);
-                        this.downloadIcon(icon, pathToIcon);
-                    }
+                    this.downloadIconToAdmin(icon, pathToAdminIcon)
                     icon = `img/${model_modif}.png`;
                 } catch (e) {
-                    this.warn(`ERROR : icon not found from ${icon} saved into ${pathToIcon}`);
+                    this.warn(`ERROR : icon not found at ${icon}`);
                 }
             }
         }
@@ -509,6 +659,7 @@ class StatesController extends EventEmitter {
                 name: __dev_name,
                 type: model,
                 icon,
+                modelIcon: modelIcon,
                 color: null,
                 statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
             },
@@ -517,8 +668,10 @@ class StatesController extends EventEmitter {
             // update type and icon
             this.adapter.extendObject(id, {
                 common: {
+                    name: __dev_name,
                     type: model,
                     icon,
+                    modelIcon: modelIcon,
                     color: null,
                     statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
                 }
@@ -527,26 +680,84 @@ class StatesController extends EventEmitter {
     }
 
     async downloadIcon(url, image_path) {
-        if (!fs.existsSync(image_path)) {
-            return new Promise((resolve, reject) => {
-                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}`);
+        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(() => {
+                        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);
         }
     }
 
+    async downloadIconToAdmin(url, target) {
+        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)}`);
+                                    else this.info(`removed ${src}`)
+                                });
+                            })
+                        }
+                    })
+                }
+                catch (error) {
+                    this.error('fs.readfile error : ', error);
+                }
+            }
+        });
+    }
+
+    CleanupRequired(set) {
+        if (typeof set === 'boolean') this.cleanupRequired = set;
+        return this.cleanupRequired;
+    }
+
     async syncDevStates(dev, model) {
+        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);
@@ -590,24 +801,39 @@ class StatesController extends EventEmitter {
             };
             this.updateState(devId, statedesc.id, undefined, common);
         }
+        this.deleteOrphanedDeviceStates(dev.ieeeAddr, model, false, undefined, true);
+    }
+
+    async getExposes() {
+        await this.localConfig.init();
+        await this.applyLegacyDevices();
+        statesMapping.fillStatesWithExposes();
     }
 
-    async getExcludeExposes(allExcludesObj) {
-        statesMapping.fillStatesWithExposes(allExcludesObj);
+    async elevatedMessage(device, message, isError) {
+        if (isError) this.error(message); else this.warn(message);
+        // emit data here for debug tab later
+
+    }
+
+    async elevatedDebugMessage(id, message, isError) {
+        if (isError) this.error(message); else this.warn(message);
+        this.emit('debugmessage', {id: id, message:message});
     }
 
     async publishToState(devId, model, payload) {
         const devStates = await this.getDevStates(`0x${devId}`, model);
-        let has_debug = false;
-        if (this.checkDebugDevice(devId))
+
+        const has_elevated_debug = (this.checkDebugDevice(devId) && !payload.hasOwnProperty('msg_from_zigbee'));
+
+
+        if (has_elevated_debug)
         {
-            if (!payload.hasOwnProperty('msg_from_zigbee')) {
-                this.warn(`ELEVATED I1: message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`);
-                has_debug = true;
-            }
+            this.elevatedMessage(devId, `ELEVATED I01: message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`, false);
         }
         if (!devStates) {
-            if (has_debug) this.error(`ELEVATED IE2: no device states for device ${devId} type '${model}'`)
+            if (has_elevated_debug)
+                this.elevatedMessage(devId, `ELEVATED IE02: no device states for device ${devId} type '${model}'`, true)
             return;
         }
         // find states for payload
@@ -634,8 +860,8 @@ class StatesController extends EventEmitter {
 
                     let stateID = statedesc.id;
 
-                    if (has_debug && statedesc.id !== 'msg_from_zigbee') {
-                        this.warn(`ELEVATED I2: value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`);
+                    if (has_elevated_debug) {
+                        this.elevatedMessage(devId, `ELEVATED I02: value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`, false);
                     }
 
                     const common = {
@@ -677,19 +903,20 @@ class StatesController extends EventEmitter {
                 }
             } catch (e) {
                 this.debug(`No states in device ${devId} : payload ${JSON.stringify(payload)}`);
-                if (has_debug)
-                    this.error(`ELEVATED IE3: error when enumerating states of ${devId} for payload ${JSON.stringify(payload)}, ${(e ? e.name : 'undefined')} (${(e ? e.message : '')}).`);
+                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_debug) {
-                this.error(`ELEVATED IE4: No value published for device ${devId}`);
+            if (!has_published && has_elevated_debug) {
+                this.elevatedMessage(devId, `ELEVATED IE04: No value published for device ${devId}`, true);
 
             }
         }
         else {
-            if (has_debug)
-                this.error(`ELEVATED IE5: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`);
+            if (has_elevated_debug)
+                this.elevatedMessage(devId, `ELEVATED IE05: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`, true);
         }
     }
+
 }
 
 module.exports = StatesController;