iobroker.zigbee 1.8.1 → 1.8.3

package/lib/statescontroller.js

@@ -7,8 +7,9 @@ const getZbId = require('./utils').getZbId;
 const fs = require('fs');
 const request = require('request');
 
-let savedDeviceNames = {};
-let knownUndefinedDevices = {};
+var savedDeviceNames = {};
+var knownUndefinedDevices = {};
+
 
 class StatesController extends EventEmitter {
     constructor(adapter) {
@@ -17,16 +18,19 @@ 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');
+        let 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 {
+                try 
+                {
                     savedDeviceNames = JSON.parse(data);
-                } catch {
+                } 
+                catch 
+                {
                     savedDeviceNames = {};
-                }
+                };
             }
         });
     }
@@ -51,77 +55,68 @@ class StatesController extends EventEmitter {
         this.adapter.sendError(error, message);
     }
 
-    retainDeviceNames() {
+    retainDeviceNames()
+    {
         clearTimeout(this.retTimeoutHandle);
-        this.retTimeoutHanlde = setTimeout(() => {
-            fs.writeFile(this.dev_names_fn, JSON.stringify(savedDeviceNames, null, 2), err => {
-                if (err) {
-                    this.error(`error saving device names: ${JSON.stringify(err)}`);
-                } else {
+        this.retTimeoutHanlde = setTimeout(()=> {
+            fs.writeFile(this.dev_names_fn, JSON.stringify(savedDeviceNames, null, 2), (err) => {
+                if (err)
+                    this.error('error saving device names: ' + JSON.Stringify(err));
+                else
                     this.debug('saved device names');
-                }
-            });
-        }, 5000);
+        });},5000);
     }
 
     getDebugDevices() {
         this.debugDevices = [];
-        this.adapter.getState(`${this.adapter.namespace}.info.debugmessages`, (err, state) => {
+        this.adapter.getState(this.adapter.namespace + '.info.debugmessages', (err, state) => {
             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 (typeof(state.val) == 'string' && state.val.length > 2) this.debugDevices = state.val.split(';');
+                this.info('debug devices set to ' + JSON.stringify(this.debugDevices));
             } else {
                 this.adapter.setObject('info.debugmessages', {
-                    type: 'state',
-                    common: {
-                        name: 'Log changes as warnings for',
-                        role: '',
-                        type: 'string',
-                        read: true,
-                        write: true,
+                    'type': 'state',
+                    'common': {
+                        'name': 'Log changes as warnings for',
+                        'role': '',
+                        'type': 'string',
+                        'read': true,
+                        'write': true,
                     },
-                    native: {},
+                    'native': {},
                 });
             }
         });
         this.adapter.setObject('info.undefinedDevices', {
-            type: 'state',
-            common: {
-                name: 'Recorded undefined devices',
-                role: '',
-                type: 'string',
-                read: true,
-                write: false,
+            'type': 'state',
+            'common': {
+                'name': 'Recorded undefined devices',
+                'role': '',
+                'type': 'string',
+                'read': true,
+                'write': false,
             },
-            native: {},
+            'native': {},
         });
         this.adapter.setStateAsync(`info.undefinedDevices`, JSON.stringify(knownUndefinedDevices), true);
     }
 
-    onStateChange(id, state) {
-        if (!this.adapter.zbController || !this.adapter.zbController.connected()) {
-            return;
-        }
-        if (this.debugDevices === undefined) {
-            this.getDebugDevices();
-        }
+    onStateChange(id, state){
+        if (!this.adapter.zbController || !this.adapter.zbController.connected()) return;
+        if (this.debugDevices === undefined) this.getDebugDevices();
         if (state && !state.ack) {
-            if (id.endsWith('pairingCountdown') || id.endsWith('pairingMessage') || id.endsWith('connection')) {
-                return;
-            }
+            if (id.endsWith('pairingCountdown') || id.endsWith('pairingMessage') || id.endsWith('connection')) return;
             if (id.endsWith('debugmessages')) {
-                if (typeof state.val === 'string' && state.val.length > 2) {
+                if  (typeof(state.val) == 'string' && state.val.length > 2)
                     this.debugDevices = state.val.split(';');
-
-                } else {
+                else {
                     this.debugDevices = [];
                 }
                 return;
             }
             for (const addressPart of this.debugDevices) {
-                if (typeof id === 'string' && id.includes(addressPart)) {
+                if (typeof(id) == 'string' && id.indexOf(addressPart) > -1)
+                {
                     this.warn(`ELEVATED: User stateChange ${id} ${JSON.stringify(state)}`);
                     break;
                 }
@@ -139,9 +134,7 @@ class StatesController extends EventEmitter {
             this.adapter.getObject(devId, (err, obj) => {
                 if (obj) {
                     const model = obj.common.type;
-                    if (!model) {
-                        return;
-                    }
+                    if (!model) return;
                     if (obj.common.deactivated) {
                         this.debug('State Change detected on deactivated Device - ignored');
                         return;
@@ -149,8 +142,9 @@ class StatesController extends EventEmitter {
                     if (model === 'group') {
                         deviceId = parseInt(deviceId.replace('0xgroup_', ''));
                     }
-                    this.collectOptions(id.split('.')[2], model, options =>
-                        this.publishFromState(deviceId, model, stateKey, state, options));
+                    this.collectOptions(id.split('.')[2], model, options => {
+                        this.publishFromState(deviceId, model, stateKey, state, options);
+                    });
                 }
             });
         }
@@ -159,12 +153,12 @@ class StatesController extends EventEmitter {
     async collectOptions(devId, model, callback) {
         const result = {};
         // find model states for options and get it values
-        const devStates = await this.getDevStates('0x' + devId, model);
+        const devStates = await this.getDevStates('0x'+devId, model);
         if (!devStates) {
             callback(result);
             return;
         }
-        const states = devStates.states.filter(statedesc => statedesc.isOption || statedesc.inOptions);
+        const states = devStates.states.filter((statedesc) => statedesc.isOption || statedesc.inOptions);
         if (!states) {
             callback(result);
             return;
@@ -173,7 +167,7 @@ class StatesController extends EventEmitter {
         try {
             const len = states.length;
             states.forEach(statedesc => {
-                const id = `${this.adapter.namespace}.${devId}.${statedesc.id}`;
+                const id = this.adapter.namespace + '.' + devId + '.' + statedesc.id;
                 this.adapter.getState(id, (err, state) => {
                     cnt = cnt + 1;
                     if (!err && state) {
@@ -184,29 +178,29 @@ class StatesController extends EventEmitter {
                     }
                 });
             });
-            if (!len) {
-                callback(result);
-            }
-        } catch (error) {
+            if (!len) callback(result);
+         } catch (error) {
             this.sendError(error);
             this.error(`Error collectOptions for ${devId}. Error: ${error.stack}`);
-        }
+         }
     }
 
     async getDevStates(deviceId, model) {
         try {
-            let states;
+            let states = [];
             let stateModel;
             if (model === 'group') {
                 states = statesMapping.groupStates;
             } else {
                 stateModel = statesMapping.findModel(model);
                 if (!stateModel) {
-                    if (knownUndefinedDevices[deviceId]) {
+                    if (knownUndefinedDevices[deviceId])
+                    {
                         knownUndefinedDevices[deviceId]++;
-                    } else {
+                    }
+                    else {
                         knownUndefinedDevices[deviceId] = 1;
-                        this.error(`Device ${deviceId} "${model}" not described in statesMapping.`);
+                        this.error('Device ' + deviceId + ' "' + model + '" not described in statesMapping.');
                     }
                     this.adapter.setStateAsync(`info.undefinedDevices`, JSON.stringify(knownUndefinedDevices), true);
                     states = statesMapping.commonStates;
@@ -215,12 +209,11 @@ class StatesController extends EventEmitter {
                 }
                 if (typeof states === 'function' && !states.prototype) {
                     const entity = await this.adapter.zbController.resolveEntity(deviceId);
-                    if (entity) {
+                    if (entity)
                         states = states(entity);
-                    }
                 }
             }
-            return {states, stateModel};
+            return {states: states, stateModel: stateModel};
         } catch (error) {
             this.sendError(error);
             this.error(`Error getDevStates for ${deviceId}. Error: ${error.stack}`);
@@ -231,7 +224,8 @@ class StatesController extends EventEmitter {
         if (this.debugDevices === undefined) this.getDebugDevices();
         this.debug(`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
         for (const addressPart of this.debugDevices) {
-            if (typeof deviceId === 'string' && deviceId.includes(addressPart)) {
+            if (typeof(deviceId) == 'string' && deviceId.indexOf(addressPart) > -1)
+            {
                 this.warn(`ELEVATED Change state '${stateKey}' at device ${deviceId} type '${model}'`);
                 break;
             }
@@ -240,8 +234,8 @@ class StatesController extends EventEmitter {
         if (!devStates) {
             return;
         }
-        const commonStates = statesMapping.commonStates.find(statedesc => stateKey === statedesc.id);
-        const stateDesc = (commonStates === undefined ? devStates.states.find(statedesc => stateKey === statedesc.id) : commonStates);
+        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}'`);
@@ -249,20 +243,20 @@ class StatesController extends EventEmitter {
         }
 
         const value = state.val;
-        if (value === undefined || value === '') {
+        if (value === undefined || value === '')
             return;
-        }
         let stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0}];
         if (stateModel && stateModel.linkedStates) {
-            stateModel.linkedStates.forEach(linkedFunct => {
+            stateModel.linkedStates.forEach((linkedFunct) => {
                 try {
                     if (typeof linkedFunct === 'function') {
                         const res = linkedFunct(stateDesc, value, options, this.adapter.config.disableQueue);
                         if (res) {
                             stateList = stateList.concat(res);
                         }
-                    } else {
-                        this.warn(`publish from State - LinkedState is not a function ${JSON.stringify(linkedFunct)}`);
+                    }
+                    else {
+                        this.warn('publish from State - LinkedState is not a function ' + JSON.stringify(linkedFunct));
                     }
                 } catch (e) {
                     this.sendError(e);
@@ -271,14 +265,17 @@ class StatesController extends EventEmitter {
 
             });
             // sort by index
-            stateList.sort((a, b) => a.index - b.index);
+            stateList.sort((a, b) => {
+                return a.index - b.index;
+            });
         }
 
-        // holds the states for read after write requests
+        // holds the states for for read after write requests
         let readAfterWriteStates = [];
         if (stateModel && stateModel.readAfterWriteStates) {
-            stateModel.readAfterWriteStates.forEach((readAfterWriteStateDesc) =>
-                readAfterWriteStates = readAfterWriteStates.concat(readAfterWriteStateDesc.id));
+            stateModel.readAfterWriteStates.forEach((readAfterWriteStateDesc) => {
+                readAfterWriteStates = readAfterWriteStates.concat(readAfterWriteStateDesc.id);
+            });
         }
 
         this.emit('changed', deviceId, model, stateModel, stateList, options);
@@ -290,42 +287,42 @@ class StatesController extends EventEmitter {
     }
 
     setDeviceActivated(id, active) {
-        this.adapter.extendObject(id, {common: {deactivated: active}});
+      this.adapter.extendObject(id, {common: {deactivated: active }})
     }
 
     storeDeviceName(id, name) {
-        savedDeviceNames[id.replace(`${this.adapter.namespace}.`, '')] = name;
-        this.retainDeviceNames();
+      savedDeviceNames[id.replace(`${this.adapter.namespace}.`, '')] = name;
+      this.retainDeviceNames();
     }
 
     verifyDeviceName(id, name) {
-        const savedId = id.replace(`${this.adapter.namespace}.`, '');
-        if (!savedDeviceNames.hasOwnProperty(savedId)) {
-            savedDeviceNames[savedId] = name;
-            this.retainDeviceNames();
-        }
-        return savedDeviceNames[savedId];
+      const savedId = id.replace(`${this.adapter.namespace}.`, '');
+      if (!savedDeviceNames.hasOwnProperty(savedId)) {
+        savedDeviceNames[savedId] = name;
+        this.retainDeviceNames();
+      }
+      return savedDeviceNames[savedId];
     }
 
     deleteDeviceStates(devId, callback) {
         this.adapter.getStatesOf(devId, (err, states) => {
             if (!err && states) {
-                states.forEach(state =>
-                    this.adapter.deleteState(devId, null, state._id));
+                states.forEach((state) => {
+                    this.adapter.deleteState(devId, null, state._id);
+                });
             }
-            this.adapter.deleteDevice(devId, () =>
-                callback && callback());
+            this.adapter.deleteDevice(devId, () => {
+                callback && callback();
+            });
         });
     }
 
     async deleteDeviceStatesAsync(devId) {
-        const states = await this.adapter.getStatesOf(devId);
-        if (states) {
-            for (const state of states) {
-                await this.adapter.deleteState(devId, null, state._id);
-            }
-        }
-        await this.adapter.deleteDevice(devId);
+      const states = await this.adapter.getStatesOf(devId);
+      if (states) {
+          await this.adapter.deleteState(devId, null, state._id);
+      }
+      await this.adapter.deleteDevice(devId);
     }
 
     // eslint-disable-next-line no-unused-vars
@@ -341,22 +338,20 @@ class StatesController extends EventEmitter {
                     if (arr[1] === undefined) {
                         this.warn(`unable to extract id from state ${statename}`);
                         const idx = statename.lastIndexOf('.');
-                        if (idx > -1) {
-                            statename = statename.slice(idx + 1);
-                        }
+                        if (idx > -1) statename = statename.slice(idx+1);
                     } else {
                         statename = arr[1];
                     }
-                    if (commonStates.find(statedesc => statename === statedesc.id) === undefined &&
-                        devStates.states.find(statedesc => statename === statedesc.id) === undefined
-                    ) {
+                    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} `);
                         } else {
                             this.info(`deleting disconnected state ${JSON.stringify(statename)} of  ${devId} `);
                             this.adapter.deleteState(devId, null, state._id);
                         }
-                    } else {
+                    }
+                    else {
                         this.debug(`keeping connecte state ${JSON.stringify(statename)} of  ${devId} `);
                     }
                 });
@@ -413,11 +408,10 @@ class StatesController extends EventEmitter {
                         let hasChanges = false;
                         if (stobj) {
                             // update state - not change name and role (user can it changed)
-                            if (stobj.common.name) {
+                            if (stobj.common.name)
                                 delete new_common.name;
-                            } else {
-                                new_common.name = `${new_name} ${new_common.name}`;
-                            }
+                            else
+                                new_common.name = new_name + ' ' + new_common.name;
                             delete new_common.role;
 
                             // check whether any common property is different
@@ -438,58 +432,54 @@ class StatesController extends EventEmitter {
 
                         // 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));
+                            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 {
-                    this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
                 }
+                else 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) {
+    setState_typed(id, value, ack, type, callback)
+    {
         // never set a null or undefined value
         if (value === null || value === undefined) return;
         if (!type) {
-            this.debug('SetState_typed called without type');
+            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) {
-                    this.setState_typed(id, value, ack, obj.common.type, callback);
-                } else {
+                if (obj && obj.common)
+                   this.setState_typed(id, value, ack, obj.common.type, callback);
+                else {
                     this.setState_typed(id, value, ack, 'noobj', callback);
                 }
             });
             return;
         }
-        if (typeof value !== type) {
-            this.debug(`SetState_typed : converting ${JSON.stringify(value)} for ${id} from ${typeof value} to ${type}`);
+        if (typeof value != type) {
+            this.debug("SetState_typed : converting " + JSON.stringify(value) + " for " + id + " from " + typeof value + " to " + type);
             switch (type) {
                 case 'number':
                     value = parseFloat(value);
-                    if (isNaN(value)) {
-                        value = 0;
-                    }
+                    if (isNaN (value)) value = 0;
                     break;
                 case 'string':
-                case 'text':
-                    value = JSON.stringify(value);
-                    break;
-                case 'boolean': {
+                case 'text': value = JSON.stringify(value); break;
+                case 'boolean':
                     if (typeof value == 'number') {
-                        value = value !== 0;
+                        value = (value != 0);
                         break;
                     }
                     const sval = JSON.stringify(value).toLowerCase().trim();
-                    value = sval === 'true' || sval === 'yes' || sval === 'on';
-                }
+                    value = (sval == 'true' || sval == 'yes' || sval == 'on');
                     break;
             }
         }
@@ -501,68 +491,60 @@ class StatesController extends EventEmitter {
         const id = '' + dev_id;
         const modelDesc = statesMapping.findModel(model);
         let icon = (modelDesc && modelDesc.icon) ? modelDesc.icon : 'img/unknown.png';
-
+        
         // download icon if it external and not undef
-        if (model === 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 model_modif = model.replace(/\//g, '-');        
+            const pathToIcon = this.adapter.adapterDir + '/admin/img/' + model_modif + '.png';
 
-            if (icon.startsWith('http')) {
-                try {
+            if (icon.startsWith('http')) {           
+                try {           
                     if (!fs.existsSync(pathToIcon)) {
                         this.warn(`download icon from ${icon} saved into ${pathToIcon}`);
-                        this.downloadIcon(icon, pathToIcon);
+                        this.downloadIcon(icon, pathToIcon);          
                     }
-                    icon = `img/${model_modif}.png`;
+                    icon = 'img/' + model_modif + '.png';
                 } catch (e) {
                     this.debug(`ERROR : icon not found from ${icon} saved into ${pathToIcon}`);
                 }
             }
         }
-
+        
         this.adapter.setObjectNotExists(id, {
             type: 'device',
             // actually this is an error, so device.common has no attribute type. It must be in native part
-            common: {
-                name: __dev_name,
-                type: model,
-                icon,
-                color: null,
-                statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
-            },
+            common: {name: __dev_name, type: model, icon: icon, color: null, statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}},
             native: {id: dev_id}
         }, () => {
             // update type and icon
-            this.adapter.extendObject(id, {
-                common: {
-                    type: model,
-                    icon,
-                    color: null,
-                    statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
-                }
-            }, callback);
+            this.adapter.extendObject(id, {common: {type: model, icon: icon, color: null, statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}}}, callback);
         });
     }
 
     async downloadIcon(url, image_path) {
-        if (!fs.existsSync(image_path)) {
-            return new Promise((resolve, reject) => {
-                request.head(url, (err, res, body) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    const stream = request(url);
-                    stream.pipe(
-                        fs.createWriteStream(image_path)
-                            .on('error', err => reject(err)))
-                        .on('close', () => resolve());
-                });
-            });
-        }
+      if (!fs.existsSync(image_path)) {
+          return new Promise((resolve, reject) => {
+              request.head(url, function (err, res, body) {
+                  if (err) {
+                      return reject(err);
+                  }
+                  let stream = request(url);
+                  stream.pipe(
+                      fs.createWriteStream(image_path)
+                          .on('error',  err => {
+                              reject(err);
+                          })
+                      )
+                      .on('close', function () {                        
+                          resolve();
+                      });
+              });
+          });
+       }
     }
-
+ 
     async syncDevStates(dev, model) {
         const devId = dev.ieeeAddr.substr(2);
         // devId - iobroker device id
@@ -573,25 +555,20 @@ class StatesController extends EventEmitter {
         const states = statesMapping.commonStates.concat(devStates.states);
 
         for (const stateInd in states) {
-            if (!states.hasOwnProperty(stateInd)) {
-                continue;
-            }
+            if (!states.hasOwnProperty(stateInd)) continue;
 
             const statedesc = states[stateInd];
-            if (statedesc === undefined) {
+            if (statedesc === undefined)
+            {
                 this.error(`syncDevStates: Illegal state in ${JSON.stringify(dev)} -  ${JSON.stringify(stateInd)}`);
                 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')
+                if (!(dev.type === 'Router') || dev.powerSource === 'Battery')
                     continue;
-                }
-            }
             // lazy states
-            if (statedesc.lazy) {
-                continue;
-            }
+            if (statedesc.lazy) continue;
 
             const common = {
                 name: statedesc.name,
@@ -609,16 +586,19 @@ class StatesController extends EventEmitter {
         }
     }
 
+
     async getExcludeExposes(allExcludesObj) {
         statesMapping.fillStatesWithExposes(allExcludesObj);
     }
 
+
     async publishToState(devId, model, payload) {
-        const devStates = await this.getDevStates(`0x${devId}`, model);
-        let has_debug = false;
+        const devStates = await this.getDevStates('0x'+devId, model);
+        let has_debug=false;
         if (this.debugDevices === undefined) this.getDebugDevices();
         for (const addressPart of this.debugDevices) {
-            if (typeof devId === 'string' && devId.includes(addressPart)) {
+            if (typeof(devId) == 'string' && devId.indexOf(addressPart) > -1)
+            {
                 if (payload.hasOwnProperty('msg_from_zigbee')) break;
                 this.warn(`ELEVATED publishToState: message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`);
                 has_debug = true;
@@ -631,8 +611,8 @@ class StatesController extends EventEmitter {
         // find states for payload
         if (devStates.states !== undefined) {
             const states = statesMapping.commonStates.concat(
-                devStates.states.filter(statedesc => payload.hasOwnProperty(statedesc.prop || statedesc.id)));
-
+                devStates.states.filter((statedesc) => payload.hasOwnProperty(statedesc.prop || statedesc.id))
+            );
             for (const stateInd in states) {
                 const statedesc = states[stateInd];
                 let value;
@@ -642,12 +622,10 @@ class StatesController extends EventEmitter {
                     value = payload[statedesc.prop || statedesc.id];
                 }
                 // checking value
-                if (value === undefined || value === null) {
-                    continue;
-                }
+                if (value === undefined || value === null) continue;
                 let stateID = statedesc.id;
 
-                if (has_debug && statedesc.id !== 'msg_from_zigbee') {
+                if (has_debug && statedesc.id != 'msg_from_zigbee') {
                     this.warn(`ELEVATED publishToState: value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`);
                 }
 
@@ -662,25 +640,24 @@ class StatesController extends EventEmitter {
                     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';
+                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 need return value to back after timeout
                 if (statedesc.isEvent) {
                     this.updateStateWithTimeout(devId, statedesc.id, value, common, 300, !value);
                 } else {
                     if (statedesc.prepublish) {
-                        this.collectOptions(devId, model, options =>
-                            statedesc.prepublish(devId, value, newvalue =>
-                                this.updateState(devId, stateID, newvalue, common), options));
+                        this.collectOptions(devId, model, (options) => {
+                            statedesc.prepublish(devId, value, (newvalue) => {
+                                this.updateState(devId, stateID, newvalue, common);
+                            }, options);
+                        });
                     } else {
                         this.updateState(devId, stateID, value, common);
                     }