iobroker.zigbee 3.1.5 → 3.2.0

package/lib/commands.js

@@ -1,13 +1,11 @@
 'use strict';
 
-const getZbId = require('./utils').getZbId;
-const getNetAddress = require('./utils').getNetAddress;
-const reverseByteString = require('./utils').reverseByteString;
+const { getZbId, getNetAddress, reverseByteString, zbIdorIeeetoAdId, adIdtoZbIdorIeee } = require('./utils');
 const fs = require('fs');
 const statesMapping = require('./devices');
-const utils = require('@iobroker/adapter-core'); // Get common adapter utils
 const colors = require('./colors.js');
 /* currently not needed, kept for referencce
+const utils = require('@iobroker/adapter-core'); // Get common adapter utils
 const dns = require('dns');
 const net = require('net');
 const access = fs.access;
@@ -54,12 +52,12 @@ class Commands {
     /**
      * @param {ioBroker.Message} obj
      */
-    onMessage(obj) {
+    async onMessage(obj) {
         if (typeof obj === 'object' && obj.command) {
             if (obj) {
                 switch (obj.command) {
                     case 'testConnect':
-                        this.adapter.testConnect(obj.from, obj.command, obj.message, obj.callback);
+                        this.adapter.sendTo(obj.from, obj.command, await this.adapter.testConnect(obj.message), obj.callback);
                         break;
                     case 'deleteNVBackup':
                         this.delNvBackup(obj.from, obj.command, {}, obj.callback);
@@ -153,7 +151,7 @@ class Commands {
                         break;
                     case 'updateLocalConfigItems':
                         if (obj.message && typeof obj.message === 'object') {
-                            this.updateLocalConfigItems(obj.from, obj.command, obj.message, obj.callback);
+                            this.updateConfigItems(obj.from, obj.command, obj.message, obj.callback);
                         }
                         break;
                     case 'getLocalConfigItems':
@@ -298,8 +296,7 @@ class Commands {
 
             if (await this.zbController.permitJoin(cTimer, devId)) {
                 this.adapter.setState('info.pairingMode', cTimer > 0, true);
-                if (devId) this.zbController.emit(`Pairing started for ${devId}`);
-                this.adapter.sendTo(from, command, cTimer ? 'Start pairing!':'Stop pairing!', callback);
+                //this.adapter.sendTo(from, command, cTimer ? 'Start pairing!':'Stop pairing!', callback);
             }
             else {
                 this.adapter.sendTo(
@@ -339,12 +336,8 @@ class Commands {
         }
     }
 
-
-    async handleDeviceforInfo(device, states) {
-    }
-
     async handleGroupforInfo(group, groups) {
-        group.icon = 'img/group.png';
+        group.icon = 'img/group_1.png';
         group.vendor = 'ioBroker';
         // get group members and store them
         const match = /zigbee.\d.group_([0-9]+)/.exec(group._id);
@@ -356,8 +349,8 @@ class Commands {
                 const memberinfo = [];
                 for (const member of groupmembers) {
                     if (member && typeof member.ieee === 'string') {
-                        const memberId = member.ieee.substr(2);
-                        const device = await this.adapter.getObjectAsync(`${this.adapter.namespace}.${member.ieee.substr(2)}`);
+                        const memberId = zbIdorIeeetoAdId(this.adapter, member.ieee, false);
+                        const device = await this.adapter.getObjectAsync(zbIdorIeeetoAdId(this.adapter, member.ieee, true));
                         const item = groups[memberId] || { groups:[], gep: { }};
                         const gep = item.gep[member.epid] || [];
 
@@ -365,12 +358,12 @@ class Commands {
                         if (!gep.includes(`${groupID}`)) gep.push(`${groupID}`);
                         item.gep[member.epid] = gep;
                         groups[memberId] = item;
-                        if (device) {
-                            member.device = device.common.name;
-                        } else {
-                            member.device = 'unknown';
-                        }
-                        memberinfo.push(member);
+                        memberinfo.push({
+                            ieee:member.ieee,
+                            epid:member.epid,
+                            model:member.model,
+                            device:device? device.common.name:'unknown'
+                        });
                     }
                 }
                 group.memberinfo = memberinfo;
@@ -379,7 +372,7 @@ class Commands {
         }
     }
 
-    async fillInfo(device, device_stateDefs, all_states) {
+    async fillInfo(device, device_stateDefs, all_states, models) {
         device.statesDef = (device_stateDefs || []).filter(stateDef => {
             const sid = stateDef._id.replace(this.adapter.namespace + '.', '');
             const names = sid.split('.');
@@ -403,7 +396,25 @@ class Commands {
         });
 
         const id = getZbId(device._id);
-        device.info = this.buildDeviceInfo(await this.zbController.resolveEntity(id));
+        const entity = await this.zbController.resolveEntity(id)
+
+        device.info = this.buildDeviceInfo(entity);
+
+        const UID = models.UIDbyModel[device.info?.mapped?.model || 'unknown'] || `m_${Object.keys(models.UIDbyModel).length}`;
+        if (models.byUID.hasOwnProperty(UID)) {
+            models.byUID[UID].devices.push(device);
+        }
+        else {
+            models.byUID[UID] = {
+                model:device.info.mapped,
+                availableOptions : [...device.info?.mapped?.options || [], ...['use_legacy_model']],
+                setOptions: this.adapter.stController.localConfig.getByModel(device.info?.mapped?.model || 'unknown') || [],
+                devices: [device],
+            }
+            if (!models.byUID[UID].model.type)
+                models.byUID[UID].model.type = 'Group';
+            models.UIDbyModel[device.info?.mapped?.model || 'unknown'] = UID;
+        }
         // check configuration
         try {
             if (device.info) {
@@ -412,26 +423,38 @@ class Commands {
                     [device.info.device, device.info.mapped],
                 );
                 if (result.length > 0) device.isConfigured = !result[0];
-            }
+                device.paired = true;
+            } else device.paired = false;
         } catch (error) {
             this.warn('error calling shouldConfigure: ' + error && error.message ? error.message : 'no error message');
         }
-        device.paired = !!device.info;
-
-
     }
 
     buildDeviceInfo(device) {
+        function getKey(object, value) {
+            try {
+                for (const key of Object.keys(object)) {
+                    if (object[key] == value) {
+                        return key;
+                    }
+                }
+            }
+            catch {
+                return undefined;
+            }
+            return undefined;
+
+        }
         const rv = {};
         try {
             rv.device = {
                 modelZigbee:device.device.modelID,
                 type:device.device.type,
-                ieee:device.device.ieeeAddr,
-                nwk:device.device.networkAddress,
+                ieee:device.device.ieeeAddr || device.device.groupID,
+                nwk:device.device.networkAddress || 0,
                 manuf_id:device.device.maufacturerID,
                 manuf_name:device.device.manufacturerName,
-                manufacturer:device.mapped ? device.mapped.vendor : '',
+                manufacturer:device.mapped?.vendor,
                 power:device.device.powerSource,
                 app_version:device.device.applicationVersion,
                 hard_version:device.device.hardwareVersion,
@@ -446,32 +469,40 @@ class Commands {
                 const ep = device.endpoints[ep_idx];
                 rv.endpoints.push({
                     ID:ep.ID,
+                    epName: device.mapped?.endpoint ? getKey(device.mapped?.endpoint(device), ep.ID) : ep.ID,
                     profile:ep.profileID,
                     input_clusters:ep.inputClusters,
                     output_clusters:ep.outputClusters,
                 })
+                if (ep.inputClusters.includes(4)) rv.device.isGroupable = true;
             }
             if (device.mapped) {
                 rv.mapped = {
                     model:device.mapped.model,
+                    type:device.device.type,
                     description:device.mapped.description,
+                    hasLegacyDef:statesMapping.hasLegacyDevice(device.mapped.model),
                     //fingerprint:JSON.stringify(device.mapped.fingerprint),
                     vendor:device.mapped.vendor,
                     hasOnEvent:device.mapped.onEvent != undefined,
                     hasConfigure:device.mapped.configure != undefined,
+                    icon:`img/${device.mapped.model.replace(/\//g, '-')}.png`,
+                    legacyIcon: statesMapping.getIconforLegacyModel(device.mapped.model),
                     options:[],
                 }
                 if (device.mapped.options && typeof (device.mapped.options == 'object')) {
-                    const optionDesc = [];
+                    rv.mapped.optionExposes = device.mapped.options;
                     for (const option of device.mapped.options) {
-                        if (option.name)
+                        if (option.name) {
                             rv.mapped.options.push(option.name);
+                        }
                     }
                 }
             }
             else {
                 rv.mapped = {
                     model:device.name,
+                    type: device.device.type,
                     description:device.name,
                     vendor:'not set',
                     hasOnEvent: false,
@@ -501,19 +532,18 @@ class Commands {
                 paired: true,
                 info: this.buildDeviceInfo(device),
                 native: { id: device.device.ieeeAddr.substring(2) },
-                mapped : {},
+                mapped : { model: client.modelID || client.type || 'NotSet' },
                 statesDev: [],
             }
-            if (device.device.name === 'Coordinator') {
+            if (device.name === 'Coordinator') {
                 coordinatorData.icon = 'zigbee.png';
-                coordinatorData.common = { name: undefined, type: undefined  };
-            } else {
                 coordinatorData.common = { name: 'Coordinator', type: 'Coordinator'  };
+            } else {
+                coordinatorData.common = { name: device.mapped?.model || 'unknown', type: device.type  };
                 coordinatorData.icon= 'img/unknown.png';
             }
             devices.push(coordinatorData);
         }
-
     }
 
     async getDevices(from, command, id, callback) {
@@ -522,13 +552,14 @@ class Commands {
             this.adapter.sendTo(from, command, {error: 'No active connection to Zigbee Hardware!'}, callback);
             return;
         }
-        const rooms = await this.adapter.getEnumsAsync('enum.rooms') || {};
+        const roomsEnum = await this.adapter.getEnumsAsync('enum.rooms') || {};
         const deviceObjects = (id ? [await this.adapter.getObjectAsync(id)] : await this.adapter.getDevicesAsync());
         const all_states = id ? await this.adapter.getStatesAsync(id + '.*') : await this.adapter.getStatesAsync('*');
         const all_stateDefs = id ? await this.adapter.getStatesOfAsync(id) : await this.adapter.getStatesOfAsync();
         const illegalDevices = [];
         const groups = {};
         const PromiseChain = [];
+        const models = { byUID : {}, UIDbyModel: {} };
         for (const devInfo of deviceObjects) {
             if (devInfo._id.indexOf('group') > -1) {
                 PromiseChain.push(this.handleGroupforInfo(devInfo, groups));
@@ -537,29 +568,29 @@ class Commands {
                 const modelDesc = statesMapping.findModel(devInfo.common.type);
                 devInfo.icon = (modelDesc && modelDesc.icon) ? modelDesc.icon : 'img/unknown.png';
                 devInfo.vendor = modelDesc ? modelDesc.vendor : '';
-                const legacyDesc = statesMapping.findModel(devInfo.common.type, true);
-                devInfo.legacyIcon = (legacyDesc && legacyDesc.icon) ? legacyDesc.icon : undefined;
+                devInfo.legacyIcon = statesMapping.getIconforLegacyModel(devInfo.common.type);
                 const lq_state = all_states[`${devInfo._id}.link_quality`];
                 devInfo.link_quality = lq_state ? lq_state.val : -1;
                 devInfo.link_quality_lc = lq_state ? lq_state.lc : undefined;
                 const battery_state = all_states[`${devInfo._id}.battery`];
                 devInfo.battery = battery_state ? battery_state.val : undefined;
-                devInfo.rooms = [];
-                for (const room in rooms) {
-                    if (!rooms.hasOwnProperty(room) ||
-                        !rooms[room] ||
-                        !rooms[room].common ||
-                        !rooms[room].common.members
-                    ) {
-                        continue;
-                    }
-                    if (rooms[room].common.members.includes(devInfo._id)) {
-                        devInfo.rooms.push(rooms[room].common.name);
-                    }
-                }
 
             }
-            PromiseChain.push(this.fillInfo(devInfo, all_stateDefs.filter(item => item._id.startsWith(devInfo._id)),all_states));
+            devInfo.rooms = [];
+            const rooms = roomsEnum['enum.rooms'] || {};
+            for (const room of Object.keys(rooms)) {
+                if (!rooms.hasOwnProperty(room) ||
+                    !rooms[room] ||
+                    !rooms[room].common ||
+                    !rooms[room].common.members
+                ) {
+                    continue;
+                }
+                if (rooms[room].common.members.includes(devInfo._id)) {
+                    devInfo.rooms.push(rooms[room].common.name);
+                }
+            }
+            PromiseChain.push(this.fillInfo(devInfo, all_stateDefs.filter(item => item._id.startsWith(devInfo._id)),all_states, models));
         }
         if (!id) {
             for (const client of this.zbController.getClientIterator(true)) {
@@ -580,7 +611,12 @@ class Commands {
 
         this.debug(`getDevices contains ${deviceObjects.length} Devices`);
         const rv = { devices:deviceObjects, inLog:this.adapter.deviceDebug.logStatus, }
-        if (!id) rv.byId = this.adapter.deviceDebug.collectDebugData();
+        if (!id) {
+            rv.deviceDebugData = this.adapter.deviceDebug.collectDebugData();
+            rv.localOverrides = this.adapter.stController.localConfig.localData;
+            rv.models = models.byUID;
+        }
+
         if (this.stController) {
             rv.clean = this.stController.CleanupRequired();
             rv.errors = this.stController.getStashedErrors();
@@ -682,32 +718,43 @@ class Commands {
         }
     }
 
-    deleteZigbeeDevice(from, command, msg, callback) {
+    async deleteZigbeeDevice(from, command, msg, callback) {
         if (this.zbController && this.zbController.herdsmanStarted && this.stController) {
             this.debug(`deleteZigbeeDevice message: ${JSON.stringify(msg)}`);
             const id = msg.id;
             const force = msg.force;
-            const sysid = id.replace(this.adapter.namespace + '.', '0x');
+            const sysid = id.startsWith(this.adapter.namespace) ?  id.replace(this.adapter.namespace + '.', '0x') : `0x${id}`;
             const devId = id.replace(this.adapter.namespace + '.', '');
             this.debug(`deleteZigbeeDevice sysid: ${sysid}`);
             const dev = this.zbController.getDevice(sysid);
             if (!dev) {
+
                 this.info(`Attempted to delete device ${devId} - the device is not known to the zigbee controller.`);
-                this.stController.deleteObj(devId, () =>
-                    this.adapter.sendTo(from, command, {}, callback));
+                const err = await this.stController.deleteObj(devId);
+                if (err != '') this.adapter.sendTo(from, command, {errror:err}, callback);
+                else this.adapter.sendTo(from, command, {}, callback);
                 return;
             }
             this.info(`${force ? 'Force removing' : 'Gracefully removing '} device ${devId} from the network.`);
-            this.zbController.remove(sysid, force, err => {
+            this.zbController.remove(sysid, force, async (err) => {
                 if (!err) {
                     this.info('Device removed from the network, deleting objects.')
-                    this.stController.deleteObj(devId, () => {
-                        this.adapter.sendTo(from, command, {}, callback);
-                    });
+                    if (!force) {
+                        const err = await this.stController.deleteObj(devId);
+                        if (err == '') this.adapter.sendTo(from, command, {}, callback);
+                        else this.adapter.sendTo(from, command, {error:err}, callback);
+                    }
+                    this.adapter.sendTo(from, command, {}, callback);
+                    this.adapter.stController.localConfig.removeLocalData()
                 } else {
                     this.adapter.sendTo(from, command, {error: err}, callback);
                 }
             });
+            if (force) {
+                const err = await this.stController.deleteObj(devId);
+                if (err != '') this.adapter.sendTo(from, command, {errror:err}, callback);
+                else this.adapter.sendTo(from, command, {}, callback);
+            }
         } else {
             this.adapter.sendTo(from, command, {error: 'No active connection to Zigbee Hardware!'}, callback);
         }
@@ -802,43 +849,47 @@ class Commands {
         }
     }
 
-    async updateLocalConfigItems(from, command, msg, callback) {
+    async updateConfigItems(from, command, msg, callback) {
         if (this.stController) {
-            this.debug(`updateLocalConfigItems : ${JSON.stringify(msg)}`);
-            const target = msg.target.replace(`${this.adapter.namespace}.`, '');
-            const entity = await this.zbController.resolveEntity(target);
-            if (entity && !entity.mapped) {
-                this.warn('unable to set local Override for device whithout mapped model');
+            this.debug(`updateConfigItems : ${JSON.stringify(msg)}`);
+            if (msg == {}) {
+                this.adapter.sendTo(from, command, {}, callback);
                 return;
             }
-            if (msg.data)
+            const target = msg.target ? msg.target.replace(`${this.adapter.namespace}.`, '') : '';
+            const entity = await this.zbController.resolveEntity(target);
+            if (msg.data);
             {
                 for (const prop in msg.data) {
                     if (prop==='options') {
                         // we need to trigger the option change
-                        const changed_from = entity.options;
-                        const changed_to = msg.data.prop;
-                        /*
-                        const allKeys = Object.keys(changed_from);
-                        for (const nk of Object.keys(changed_to)) {
-                            if (allKeys.includes(nk)) continue;
-                            allKeys.push(nk);
-                        }
-                        for (const key of allKeys) {
-                            if (changed_from.hasOwnProperty(key) && changed_to.hasOwnProperty(key) && changed_from[key] == changed_to[key])
-                            {
-                                delete changed_from[key];
-                                delete changed_to[key];
+                        // first: retrieve the global options.
+                        const newOptions = {};
+                        const globalOptions = this.stController.localConfig.getLocalOverride(target, entity?.mapped?.model || '', prop, true)?.options;
+                        if (globalOptions) {
+                            for (const key of Object.keys(entity.options)) {
+                                if (globalOptions[key] != undefined)
+                                    newOptions[key] = globalOptions[key];
                             }
                         }
-                        */
-                        this.zbController.callExtensionMethod(
-                            'onZigbeeEvent',
-                            [{'device': entity.device, 'type': 'deviceOptionsChanged', from: changed_from, to:changed_to  || {}, }, entity ? entity.mapped : null]);
+                        for (const key of Object.keys(msg.data.options)) {
+                            newOptions[key]= msg.data.options[key];
+                        }
+                        if (entity && entity.device) {
+                            this.zbController.callExtensionMethod(
+                                'onZigbeeEvent',
+                                [{'device': entity.device, 'type': 'deviceOptionsChanged', from: entity.options, to:newOptions  || {}, }, entity.mapped]);
+                        }
+                    }
+                    this.warn(`enumerating data: ${JSON.stringify(prop)}`);
+                    let val = msg.data[prop];
+                    if (typeof val === 'string') {
+                        val = val.trim();
+                        if (val.length < 1) val = '##REMOVE##';
                     }
-                    this.debug('enumerating data: ' + prop);
-                    await this.stController.localConfig.updateLocalOverride(target, (entity ? entity.mapped.model : 'group'), prop, msg.data[prop], msg.global);
+                    await this.stController.localConfig.updateLocalOverride(target, target, prop, val, msg.global);
                 }
+                await this.stController.localConfig.retainData();
             }
             try {
                 if (entity) {
@@ -846,8 +897,12 @@ class Commands {
                     this.stController.updateDev(target, entity.mapped.model, entity.mapped.model, () => {this.adapter.sendTo(from, command, {}, callback)});
                 }
                 else {
-                    this.debug('updateLocalConfigItems without Entity');
-                    this.stController.updateDev(target, undefined, 'group',() => {this.adapter.sendTo(from, command, {}, callback)});
+                    // try to see if it is a model -> find the devices for that model
+                    const devicesFromObjects = (await this.adapter.getDevicesAsync()).filter(item => item.common.type === target).map((item) => item.native.id);
+                    for (const device of devicesFromObjects) {
+                        await this.stController.updateDev(device, target, target);
+                    }
+
                 }
             }
             catch (error) {
@@ -875,6 +930,9 @@ class Commands {
                 //const targetModel = msg.model ? msg.model : '';
             }
             else {
+                if (msg.getAllData) {
+                    this.adapter.sendTo(from, command, this.stController.localConfig.localData, callback);
+                }
                 rv.error = `missing data in message ${JSON.stringify(msg)}`;
             }
         }

package/lib/devices.js

@@ -3165,9 +3165,16 @@ function setLegacyDevices(legacyModels) {
 }
 
 function getIconforLegacyModel(model) {
+    const mid = findModel(model, true);
+    if (!mid) return undefined;
+    return mid.icon;
 
 }
 
+function hasLegacyDevice(model) {
+    return Boolean(findModel(model, true));
+}
+
 module.exports = {
     devices,
     legacy_devices,
@@ -3183,5 +3190,7 @@ module.exports = {
     findModel,
     fillDevicesForLegacy,
     pairedLegacyDevices,
-    setLegacyDevices
+    setLegacyDevices,
+    hasLegacyDevice,
+    getIconforLegacyModel,
 };

package/lib/exclude.js

@@ -1,5 +1,6 @@
 'use strict';
 const devicedefinitions = require('./devices');
+const utils = require('./utils');
 
 class Exclude {
     constructor(adapter) {
@@ -126,7 +127,7 @@ class Exclude {
         const devices = this.zbController.getClients();
         const excludables = [];
         for (const device of devices) {
-            const obj = await this.adapter.getObjectAsync(device.ieeeAddr.substr(2));
+            const obj = await this.adapter.getObjectAsync(utils.zbIdorIeeetoAdId(this.adapter, device.ieeeAddr, false));//device.ieeeAddr.substr(2));
             if (obj && obj.common && obj.common.type) {
                 excludables.push(obj.common.tyoe);
             }

package/lib/exposes.js

@@ -259,7 +259,7 @@ function createFromExposes(model, def, device, log) {
 
     // maybee here check manufacturerName for tuya devices
     if (typeof def.exposes == 'function') {
-        const expFunction = def.exposes(device === undefined ? {isDummyDevice: true} : device, {});   // maybee here check manufacturerName for tuya devices
+        const expFunction = def.exposes((device === undefined || device === null) ? {isDummyDevice: true} : device, {});   // maybee here check manufacturerName for tuya devices
         for (const expose of expFunction) {
             genStateFromExpose(expose);
         }
@@ -344,7 +344,22 @@ function createFromExposes(model, def, device, log) {
                                 epname: expose.endpoint,
                                 setattr: 'brightness',
                             }, prop.access);
-                            pushToStates(statesDefs.brightness_move, prop.access);
+                            //pushToStates(statesDefs.brightness_move, prop.access);
+                            pushToStates({
+                                id: 'brightness_move',
+                                prop: 'brightness_move',
+                                name: `Dimming ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                icon: undefined,
+                                role: 'state',
+                                write: true,
+                                read: false,
+                                type: 'number',
+                                min: -50, // ignore expose.value_min
+                                max: 50, // ignore expose.value_max
+                                epname: expose.endpoint,
+                                setattr: 'brightness_move',
+                            }, prop.access);
+                            //pushToStates(statesDefs.brightness_move, prop.access);
                             break;
                         }
                         case 'color_temp': {
@@ -801,7 +816,7 @@ function createFromExposes(model, def, device, log) {
 
             case 'climate':
                 for (const prop of expose.features) {
-                    switch (prop.name) {
+                    /* switch (prop.name) {
                         case 'away_mode':
                             pushToStates(statesDefs.climate_away_mode, prop.access);
                             break;
@@ -814,7 +829,8 @@ function createFromExposes(model, def, device, log) {
                         default:
                             pushToStates(genState(prop), prop.access);
                             break;
-                    }
+                    }*/
+                    pushToStates(genState(prop), prop.access);
                 }
                 break;
 

package/lib/groups.js

@@ -629,7 +629,7 @@ class Groups {
                     const entity = await this.zbController.resolveEntity(member.ieee, member.epid);
                     let epname = undefined;
                     if (entity && entity.mapped && entity.mapped.endpoint) {
-                        const epnames = entity.mapped.endpoint();
+                        const epnames = entity.mapped.endpoint(entity);
                         for (const key in epnames) {
                             if (epnames[key] == member.epid) {
                                 epname = key;
@@ -657,7 +657,7 @@ class Groups {
                     this.rebuildGroupMemberStateList(j, memberInfo);
                 }
 
-                const name = this.stController.localConfig.NameForId(id, 'group', groups[j]);
+                const name = await this.stController.localConfig.NameForId(id, 'group', groups[j]);
                 const icon = this.stController.localConfig.IconForId(id, 'group', await this.stController.getDefaultGroupIcon(id));
                 chain.push(new Promise(resolve => {
                     const isActive = false;