iobroker.zigbee 1.8.3 → 1.8.5

package/lib/statescontroller.js

@@ -7,9 +7,8 @@ const getZbId = require('./utils').getZbId;
 const fs = require('fs');
 const request = require('request');
 
-var savedDeviceNames = {};
-var knownUndefinedDevices = {};
-
+let savedDeviceNames = {};
+let knownUndefinedDevices = {};
 
 class StatesController extends EventEmitter {
     constructor(adapter) {
@@ -18,19 +17,16 @@ class StatesController extends EventEmitter {
         this.adapter.on('stateChange', this.onStateChange.bind(this));
         this.query_device_block = [];
         this.debugDevices = undefined;
-        let fn = adapter.expandFileName('dev_names.json');
+        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 
-                {
+                try {
                     savedDeviceNames = JSON.parse(data);
-                } 
-                catch 
-                {
+                } catch {
                     savedDeviceNames = {};
-                };
+                }
             }
         });
     }
@@ -55,68 +51,77 @@ 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.indexOf(addressPart) > -1)
-                {
+                if (typeof id === 'string' && id.includes(addressPart)) {
                     this.warn(`ELEVATED: User stateChange ${id} ${JSON.stringify(state)}`);
                     break;
                 }
@@ -134,7 +139,9 @@ 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;
@@ -142,9 +149,8 @@ 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));
                 }
             });
         }
@@ -153,12 +159,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;
@@ -167,7 +173,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) {
@@ -178,29 +184,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;
@@ -209,11 +215,12 @@ 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: states, stateModel: stateModel};
+            return {states, stateModel};
         } catch (error) {
             this.sendError(error);
             this.error(`Error getDevStates for ${deviceId}. Error: ${error.stack}`);
@@ -224,8 +231,7 @@ 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.indexOf(addressPart) > -1)
-            {
+            if (typeof deviceId === 'string' && deviceId.includes(addressPart)) {
                 this.warn(`ELEVATED Change state '${stateKey}' at device ${deviceId} type '${model}'`);
                 break;
             }
@@ -234,8 +240,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}'`);
@@ -243,20 +249,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);
@@ -265,17 +271,14 @@ class StatesController extends EventEmitter {
 
             });
             // sort by index
-            stateList.sort((a, b) => {
-                return a.index - b.index;
-            });
+            stateList.sort((a, b) => a.index - b.index);
         }
 
-        // holds the states for for read after write requests
+        // holds the states 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);
@@ -287,42 +290,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) {
-          await this.adapter.deleteState(devId, null, state._id);
-      }
-      await this.adapter.deleteDevice(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);
     }
 
     // eslint-disable-next-line no-unused-vars
@@ -338,20 +341,22 @@ 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} `);
                     }
                 });
@@ -408,10 +413,11 @@ 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
@@ -432,54 +438,58 @@ 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;
             }
         }
@@ -491,60 +501,68 @@ 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: icon, color: null, statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}},
+            common: {
+                name: __dev_name,
+                type: model,
+                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: icon, color: null, statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}}}, callback);
+            this.adapter.extendObject(id, {
+                common: {
+                    type: model,
+                    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, 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();
-                      });
-              });
-          });
-       }
+        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());
+                });
+            });
+        }
     }
- 
+
     async syncDevStates(dev, model) {
         const devId = dev.ieeeAddr.substr(2);
         // devId - iobroker device id
@@ -555,20 +573,25 @@ 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,
@@ -586,19 +609,16 @@ 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.indexOf(addressPart) > -1)
-            {
+            if (typeof devId === 'string' && devId.includes(addressPart)) {
                 if (payload.hasOwnProperty('msg_from_zigbee')) break;
                 this.warn(`ELEVATED publishToState: message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`);
                 has_debug = true;
@@ -611,8 +631,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;
@@ -622,10 +642,12 @@ 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}'`);
                 }
 
@@ -640,24 +662,25 @@ 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');
-                    value = value.value;
 
+                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 need return value to back after timeout
+
+                // if needs to 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);
                     }