iobroker.zigbee 3.1.2 → 3.1.5

package/lib/commands.js

@@ -7,10 +7,12 @@ 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 dns = require('dns');
 const net = require('net');
-const { access, constants } =require('fs');
-
+const access = fs.access;
+const constants = fs.constants;
+*/
 const disallowedDashStates = [
     'link_quality', 'available', 'battery', 'groups', 'device_query',
     'hue_move', 'color_temp_move', 'satuation_move', 'brightness_move', 'brightness_step', 'hue_calibration',
@@ -82,9 +84,9 @@ class Commands {
                             this.renameDevice(obj.from, obj.command, obj.message, obj.callback);
                         }
                         break;
-                    case 'deleteDevice':
+                    case 'deleteZigbeeDevice':
                         if (obj.message && typeof obj.message === 'object') {
-                            this.deleteDevice(obj.from, obj.command, obj.message, obj.callback);
+                            this.deleteZigbeeDevice(obj.from, obj.command, obj.message, obj.callback);
                         }
                         break;
                     case 'getChannels':
@@ -163,15 +165,22 @@ class Commands {
                         if (this.stController) this.adapter.sendTo(obj.from, obj.command, {clean:this.stController.CleanupRequired(), errors:this.stController.getStashedErrors()}, obj.callback);
                         // NO Break - returning the debug-data as well is intentional
                     case 'getDebugMessages':
-                        this.adapter.sendTo(obj.from, obj.command, {byId:this.adapter.deviceDebug.collectDebugData( obj.message.inlog)},obj.callback);
+                        this.adapter.sendTo(obj.from, obj.command, {byId:this.adapter.deviceDebug.collectDebugData( obj.message.inlog, obj.message.del )},obj.callback);
                         break;
                     case 'testConnection':
                         this.testConnection(obj.from, obj.command, obj.message, obj.callback);
                         break;
                     case 'readNVRam':
                         this.readNvBackup(obj.from, obj.command, obj.message, obj.callback);
+                        break;
+                    case 'downloadIcons':
+                        this.triggerIconDownload(obj);
+                        break;
+                    case 'aliveCheck':
+                        this.adapter.sendTo(obj.from, obj.command, {msg:'success'}, obj.callback);
+                        break;
                     default:
-                        //this.warn(`Commands: Command ${obj.command} is unknown`);
+                        this.debug(`Commands: Command ${obj.command} is unknown`);
                         //this.adapter.sendTo(obj.from, obj.command, obj.message, obj.callback);
                         break;
                 }
@@ -289,6 +298,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);
             }
             else {
@@ -329,196 +339,256 @@ class Commands {
         }
     }
 
-    async getDevices(from, command, id, callback) {
-        if (this.zbController && this.zbController.herdsmanStarted) {
-            this.debug(`getDevices called from  ${from} with command ${JSON.stringify(command)} and id ${JSON.stringify(id)}`);
-            const pairedDevices = await this.zbController.getClients(true);
-            const groups = {};
-            let rooms;
-            this.adapter.getEnumsAsync('enum.rooms')
-                .then(enums => {
-                    // rooms
-                    rooms = enums['enum.rooms'];
-                })
-                // get all adapter devices
-                .then(() => this.adapter.getDevicesAsync())
-                .then(async result => {
-                    const alls = id ? await this.adapter.getStatesAsync(id + '.*') : await this.adapter.getStatesAsync('*');
-                    const allst = id ? await this.adapter.getStatesOfAsync(id) : await this.adapter.getStatesOfAsync();
-                    result = result.filter(item => !id || id === item._id);
-                    // get device states and groups
-                    result.forEach(async devInfo => {
-                        if (devInfo._id) {
-                            // battery and link_quality
-                            const lqState = alls[`${devInfo._id}.link_quality`];
-                            devInfo.link_quality = lqState ? lqState.val : undefined;
-                            devInfo.link_quality_lc = lqState ? lqState.lc : undefined;
-                            const batState = alls[`${devInfo._id}.battery`];
-                            devInfo.battery = batState ? batState.val : undefined;
-                            // devInfo.states = states || {};
-
-                            const states = allst.filter(item => item._id.startsWith(devInfo._id));
-
-                            // put only allowed states
-                            devInfo.statesDef = (states || []).filter(stateDef => {
-                                const sid = stateDef._id.replace(this.adapter.namespace + '.', '');
-                                const names = sid.split('.');
-                                if (stateDef.common.color || names.length > 2) return false;
-                                return !disallowedDashStates.includes(names.pop());
-
-                            }).map(stateDef => {
-                                const name = stateDef.common.name;
-                                const devname = devInfo.common.name;
-                                // replace state
-                                return {
-                                    id: stateDef._id,
-                                    name: typeof name === 'string' ? name.replace(devname, '') : name,
-                                    type: stateDef.common.type,
-                                    read: stateDef.common.read,
-                                    write: stateDef.common.write,
-                                    val: alls[stateDef._id] ? alls[stateDef._id].val : undefined,
-                                    role: stateDef.common.role,
-                                    unit: stateDef.common.unit,
-                                    states: stateDef.common.states,
-                                };
-                            });
-                        }
-                    });
-                    return result;
-                })
-                .then(async result => {
-                    // combine info
-                    const devices = [];
-                    for (const devInfo of result) {
-                        if (devInfo._id.indexOf('group') > 0) {
-                            devInfo.icon = 'img/group.png';
-                            devInfo.vendor = 'ioBroker';
-                            // get group members and store them
-                            const match = /zigbee.\d.group_([0-9]+)/.exec(devInfo._id);
-                            if (match && match.length > 1) {
-                                const groupID = Number(match[1]);
-                                const groupmembers = await this.zbController.getGroupMembersFromController(groupID);
-                                this.debug(`group members for group ${groupID}: ${JSON.stringify(groupmembers)}`);
-                                if (groupmembers && groupmembers.length > 0) {
-                                    const memberinfo = [];
-                                    for (const member of groupmembers) {
-                                        if (member && typeof member.ieee === 'string') {
-                                            if (groups) {
-                                                const grouparray = groups[member.ieee];
-                                                if (grouparray) {
-                                                    if (!grouparray.includes(groupID)) {
-                                                        groups[member.ieee].push(groupID);
-                                                    }
-                                                } else {
-                                                    groups[member.ieee] = [groupID];
-                                                }
-                                            }
-                                            const device = await this.adapter.getObjectAsync(`${this.adapter.namespace}.${member.ieee.substr(2)}`);
-                                            if (device) {
-                                                member.device = device.common.name;
-                                            } else {
-                                                member.device = 'unknown';
-                                            }
-                                            memberinfo.push(member);
-                                        }
-                                    }
-                                    devInfo.memberinfo = memberinfo;
-                                    this.debug(`memberinfo for ${match[1]}: ${JSON.stringify(devInfo.memberinfo)}`);
-                                }
-                            }
-                        } else {
-                            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;
-                        }
 
-                        const id = getZbId(devInfo._id);
-                        devInfo.info = await this.zbController.resolveEntity(id);
-                        // check configuration
-                        try {
-                            if (devInfo.info) {
-                                const result = await this.zbController.callExtensionMethod(
-                                    'shouldConfigure',
-                                    [devInfo.info.device, devInfo.info.mapped],
-                                );
-                                if (result.length > 0) devInfo.isConfigured = !result[0];
-                            }
-                        } catch (error) {
-                            this.warn('error calling shouldConfigure: ' + error && error.message ? error.message : 'no error message');
-                        }
+    async handleDeviceforInfo(device, states) {
+    }
 
-                        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);
-                            }
-                        }
-                        devInfo.paired = !!devInfo.info;
-                        devices.push(devInfo);
-                    }
-                    return devices;
-                })
-                .then(async (devices) => {
-                    // fill group info
-                    for (const groupdev in groups) {
-                        const device = devices.find(dev => (groupdev === getZbId(dev._id)));
+    async handleGroupforInfo(group, groups) {
+        group.icon = 'img/group.png';
+        group.vendor = 'ioBroker';
+        // get group members and store them
+        const match = /zigbee.\d.group_([0-9]+)/.exec(group._id);
+        if (match && match.length > 1) {
+            const groupID = Number(match[1]);
+            const groupmembers = await this.zbController.getGroupMembersFromController(groupID);
+            this.debug(`group members for group ${groupID}: ${JSON.stringify(groupmembers)}`);
+            if (groupmembers && groupmembers.length > 0) {
+                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 item = groups[memberId] || { groups:[], gep: { }};
+                        const gep = item.gep[member.epid] || [];
+
+                        if (!item.groups.includes(groupID)) item.groups.push(groupID);
+                        if (!gep.includes(`${groupID}`)) gep.push(`${groupID}`);
+                        item.gep[member.epid] = gep;
+                        groups[memberId] = item;
                         if (device) {
-                            device.groups = groups[groupdev];
-                        }
-                    }
-                    // append devices that paired but not created
-                    if (!id) {
-                        for (const d of pairedDevices) {
-                            const device = await this.zbController.resolveEntity(d.ieeeAddr);
-                            if (!device || !device.device) {
-                                continue;
-                            }
-                            const exists = devices.find((dev) => (dev._id && device.device.ieeeAddr === getZbId(dev._id)));
-                            if (!exists) {
-                                devices.push({
-                                    _id: device.device.ieeeAddr,
-                                    icon: 'img/unknown.png',
-                                    paired: true,
-                                    info: device,
-                                    common: {
-                                        name: undefined,
-                                        type: undefined,
-                                    },
-                                    native: {}
-                                });
-                            }
+                            member.device = device.common.name;
+                        } else {
+                            member.device = 'unknown';
                         }
+                        memberinfo.push(member);
                     }
-                    return devices;
+                }
+                group.memberinfo = memberinfo;
+                this.debug(`memberinfo for ${match[1]}: ${JSON.stringify(group.memberinfo)}`);
+            }
+        }
+    }
+
+    async fillInfo(device, device_stateDefs, all_states) {
+        device.statesDef = (device_stateDefs || []).filter(stateDef => {
+            const sid = stateDef._id.replace(this.adapter.namespace + '.', '');
+            const names = sid.split('.');
+            if (stateDef.common.color || names.length > 2) return false;
+            return !disallowedDashStates.includes(names.pop());
+        }).map(stateDef => {
+            const name = stateDef.common.name;
+            const devname = device.common.name;
+            // replace state
+            return {
+                id: stateDef._id,
+                name: typeof name === 'string' ? name.replace(devname, '') : name,
+                type: stateDef.common.type,
+                read: stateDef.common.read,
+                write: stateDef.common.write,
+                val: all_states[stateDef._id] ? all_states[stateDef._id].val : undefined,
+                role: stateDef.common.role,
+                unit: stateDef.common.unit,
+                states: stateDef.common.states,
+            };
+        });
+
+        const id = getZbId(device._id);
+        device.info = this.buildDeviceInfo(await this.zbController.resolveEntity(id));
+        // check configuration
+        try {
+            if (device.info) {
+                const result = await this.zbController.callExtensionMethod(
+                    'shouldConfigure',
+                    [device.info.device, device.info.mapped],
+                );
+                if (result.length > 0) device.isConfigured = !result[0];
+            }
+        } catch (error) {
+            this.warn('error calling shouldConfigure: ' + error && error.message ? error.message : 'no error message');
+        }
+        device.paired = !!device.info;
+
+
+    }
+
+    buildDeviceInfo(device) {
+        const rv = {};
+        try {
+            rv.device = {
+                modelZigbee:device.device.modelID,
+                type:device.device.type,
+                ieee:device.device.ieeeAddr,
+                nwk:device.device.networkAddress,
+                manuf_id:device.device.maufacturerID,
+                manuf_name:device.device.manufacturerName,
+                manufacturer:device.mapped ? device.mapped.vendor : '',
+                power:device.device.powerSource,
+                app_version:device.device.applicationVersion,
+                hard_version:device.device.hardwareVersion,
+                zcl_version:device.device.zclVersion,
+                stack_version:device.device.stack_version,
+                date_code:device.device.dateCode,
+                build:device.device.softwareBuildID,
+                interviewstate:device.device.interviewState || 'UNKNOWN',
+            }
+            rv.endpoints = [];
+            for (const ep_idx in device.endpoints) {
+                const ep = device.endpoints[ep_idx];
+                rv.endpoints.push({
+                    ID:ep.ID,
+                    profile:ep.profileID,
+                    input_clusters:ep.inputClusters,
+                    output_clusters:ep.outputClusters,
                 })
-                .then(devices => {
-                    this.debug(`getDevices contains ${devices.length} Devices`);
-                    const rv = { devices:devices, inLog:this.adapter.deviceDebug.logStatus, byId:this.adapter.deviceDebug.collectDebugData() }
-                    if (this.stController) {
-                        rv.clean = this.stController.CleanupRequired();
-                        rv.errors = this.stController.getStashedErrors();
-                        rv.debugDevices = this.stController.debugDevices;
+            }
+            if (device.mapped) {
+                rv.mapped = {
+                    model:device.mapped.model,
+                    description:device.mapped.description,
+                    //fingerprint:JSON.stringify(device.mapped.fingerprint),
+                    vendor:device.mapped.vendor,
+                    hasOnEvent:device.mapped.onEvent != undefined,
+                    hasConfigure:device.mapped.configure != undefined,
+                    options:[],
+                }
+                if (device.mapped.options && typeof (device.mapped.options == 'object')) {
+                    const optionDesc = [];
+                    for (const option of device.mapped.options) {
+                        if (option.name)
+                            rv.mapped.options.push(option.name);
                     }
-                    this.adapter.sendTo(from, command, rv, callback);
-                })
-                .catch(err => {
-                    this.error(`getDevices error: ${err.stack}`);
-                    this.adapter.sendTo(from, command, {error: `Error enumerating devices : ${err && err.message ? err.message : ''}`}, callback);
-                });
-        } else {
-            this.adapter.sendTo(from, command, {error: 'No active connection to Zigbee Hardware!'}, callback);
+                }
+            }
+            else {
+                rv.mapped = {
+                    model:device.name,
+                    description:device.name,
+                    vendor:'not set',
+                    hasOnEvent: false,
+                    hasConfigure: false,
+                    options:[],
+                }
+            }
+        }
+        catch (error) {
+            if (device && device.name === 'Coordinator') return rv;
+            const dev = device ? device.device || {} : {}
+            const msg = device ? `device ${device.name} (${dev.ieeeAddr}, NWK ${dev.networkAddres}, ID: ${dev.ID})` : 'undefined device';
+            this.warn(`Error ${error && error.message ? error.message + ' ' : ''}building device info for ${msg}`);
+        }
+        return rv;
+    }
+
+    async appendDevicesWithoutObjects(devices, client) {
+        const device = await this.zbController.resolveEntity(client.ieeeAddr);
+        if (!device || !device.device) {
+            return;
         }
+        const exists = devices.find((dev) => (dev._id && device.device.ieeeAddr === getZbId(dev._id)));
+        if (!exists) {
+            const coordinatorData = {
+                _id : `${this.adapter.namespace}.${device.device.ieeeAddr.substring(2)}`,
+                paired: true,
+                info: this.buildDeviceInfo(device),
+                native: { id: device.device.ieeeAddr.substring(2) },
+                mapped : {},
+                statesDev: [],
+            }
+            if (device.device.name === 'Coordinator') {
+                coordinatorData.icon = 'zigbee.png';
+                coordinatorData.common = { name: undefined, type: undefined  };
+            } else {
+                coordinatorData.common = { name: 'Coordinator', type: 'Coordinator'  };
+                coordinatorData.icon= 'img/unknown.png';
+            }
+            devices.push(coordinatorData);
+        }
+
     }
 
+    async getDevices(from, command, id, callback) {
+        this.debug(`getDevices called from  ${from} with command ${JSON.stringify(command)}${id ? ' and id '+JSON.stringify(id) : ' without ID'}`);
+        if (!(this.zbController && this.zbController.herdsmanStarted)) {
+            this.adapter.sendTo(from, command, {error: 'No active connection to Zigbee Hardware!'}, callback);
+            return;
+        }
+        const rooms = 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 = [];
+        for (const devInfo of deviceObjects) {
+            if (devInfo._id.indexOf('group') > -1) {
+                PromiseChain.push(this.handleGroupforInfo(devInfo, groups));
+            }
+            else {
+                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;
+                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));
+        }
+        if (!id) {
+            for (const client of this.zbController.getClientIterator(true)) {
+                PromiseChain.push(this.appendDevicesWithoutObjects(deviceObjects,client))
+            }
+        }
+
+        await Promise.all(PromiseChain);
+
+        for (const groupmember in groups) {
+            const device = deviceObjects.find(dev => (groupmember === dev.native.id));
+            if (device) {
+                device.groups = groups[groupmember].groups;
+                device.groups_by_ep = groups[groupmember].gep;
+            }
+        }
+
+
+        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 (this.stController) {
+            rv.clean = this.stController.CleanupRequired();
+            rv.errors = this.stController.getStashedErrors();
+            rv.debugDevices = this.stController.debugDevices;
+        }
+        this.adapter.sendTo(from, command, rv, callback);
+
+    }
 
     async getCoordinatorInfo(from, command, callback) {
         const coordinatorinfo = {
@@ -548,6 +618,7 @@ class Commands {
                 coordinatorinfo.port = obj.native.port;
                 coordinatorinfo.type = obj.native.adapterType;
                 coordinatorinfo.channel = obj.native.channel;
+                coordinatorinfo.autostart = this.adapter.config.autostart;
                 coordinatorinfo.installedVersion = obj.common.version;
                 if (coordinatorVersion && coordinatorVersion.type && coordinatorVersion.meta) {
                     coordinatorinfo.type = coordinatorVersion.type;
@@ -588,8 +659,8 @@ class Commands {
                     }
                 }
                 else {
-                    coordinatorinfo.version = 'not connected';
-                    coordinatorinfo.revision = 'not connected';
+                    coordinatorinfo.version = this.adapter.config.autostart ? 'not connected' : 'autostart not set';
+                    coordinatorinfo.revision = this.adapter.config.autostart ? 'not connected' : 'autostart not set';
 
                 }
             } catch {
@@ -611,14 +682,14 @@ class Commands {
         }
     }
 
-    deleteDevice(from, command, msg, callback) {
+    deleteZigbeeDevice(from, command, msg, callback) {
         if (this.zbController && this.zbController.herdsmanStarted && this.stController) {
-            this.debug(`deleteDevice message: ${JSON.stringify(msg)}`);
+            this.debug(`deleteZigbeeDevice message: ${JSON.stringify(msg)}`);
             const id = msg.id;
             const force = msg.force;
             const sysid = id.replace(this.adapter.namespace + '.', '0x');
             const devId = id.replace(this.adapter.namespace + '.', '');
-            this.debug(`deleteDevice sysid: ${sysid}`);
+            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.`);
@@ -736,7 +807,6 @@ class Commands {
             this.debug(`updateLocalConfigItems : ${JSON.stringify(msg)}`);
             const target = msg.target.replace(`${this.adapter.namespace}.`, '');
             const entity = await this.zbController.resolveEntity(target);
-            //this.warn('entity for ' + target + ' is '+ JSON.stringify(entity))
             if (entity && !entity.mapped) {
                 this.warn('unable to set local Override for device whithout mapped model');
                 return;
@@ -744,17 +814,44 @@ class Commands {
             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];
+                            }
+                        }
+                        */
+                        this.zbController.callExtensionMethod(
+                            'onZigbeeEvent',
+                            [{'device': entity.device, 'type': 'deviceOptionsChanged', from: changed_from, to:changed_to  || {}, }, entity ? entity.mapped : null]);
+                    }
                     this.debug('enumerating data: ' + prop);
                     await this.stController.localConfig.updateLocalOverride(target, (entity ? entity.mapped.model : 'group'), prop, msg.data[prop], msg.global);
                 }
             }
-            if (entity) {
-                this.debug('updateLocalConfigItems with Entity');
-                this.stController.updateDev(target, entity.mapped.model, entity.mapped.model, () => {this.adapter.sendTo(from, command, {}, callback)});
+            try {
+                if (entity) {
+                    this.debug('updateLocalConfigItems with Entity');
+                    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)});
+                }
             }
-            else {
-                this.debug('updateLocalConfigItems without Entity');
-                this.stController.updateDev(target, undefined, 'group',() => {this.adapter.sendTo(from, command, {}, callback)});
+            catch (error) {
+                this.adapter.sendTo(from, command, {err: error.message}, callback);
             }
         }
     }
@@ -824,65 +921,32 @@ class Commands {
             this.adapter.logToPairing(`Error: ${result.error}`)
         }
         this.adapter.sendTo(from, command, result, callback);
-        /*
-        this.debug(`TestConnection with ${JSON.stringify(msg)}`);
-        if (msg && msg.address) {
-            const netAddress = getNetAddress(msg.address);
-            if (netAddress && netAddress.host) {
-                this.adapter.logToPairing(`attempting dns lookup for ${netAddress.host}`);
-                this.debug(`attempting dns lookup for ${netAddress.host}`);
-                dns.lookup(netAddress.host, (err, ip, _) => {
-                    if (err) {
-                        const msg = `Unable to resolve name: ${err && err.message ? err.message : 'no message'}`;
-                        this.error(msg);
-                        this.adapter.logToPairing(`Error: ${msg}`);
-                        this.adapter.sendTo(from, command, {error:msg}, callback);
-                        return;
-                    }
-                    this.debug(`dns lookup for ${msg.address} produced ${ip}`);
-                    this.adapter.logToPairing(`dns lookup for ${msg.address} produced ${ip}`);
-                    const client = new net.Socket();
-                    this.debug(`attempting to connect to ${ip} port ${netAddress.port ? netAddress.port : 80}`);
-                    client.connect(netAddress.port, ip, () => {
-                        client.destroy()
-                        this.adapter.logToPairing(`connected successfully to connect to ${ip} port ${netAddress.port ? netAddress.port : 80}`);
-                        this.debug(`connected successfully to connect to ${ip} port ${netAddress.port ? netAddress.port : 80}`);
-                        this.adapter.sendTo(from, command, {}, callback)
-                    })
-                    client.on('error', (error) => {
-                        const msg = `unable to connect to ${ip} port ${netAddress.port ? netAddress.port : 80} : ${error && error.message ? error.message : 'no message given'}`
-                        this.error(msg);
-                        this.adapter.logToPairing(`Error: ${msg}`);
-                        this.adapter.sendTo(from, command, {error:msg}, callback);
-                    });
-                })
-            }
-            else
-            {
-                try {
-                    const port = msg.address.trim();
-                    this.adapter.logToPairing(`reading access rights for ${port}`);
-                    access(port, constants.R_OK | constants.W_OK, (error) => {
-                        if (error) {
-                            const msg = `unable to access ${port} : ${error && error.message ? error.message : 'no message given'}`;
-                            this.error(msg);
-                            this.adapter.logToPairing(`Error: ${msg}`);
-                            this.adapter.sendTo(from, command, {error:msg}, callback);
-                            return;
-                        }
-                        this.adapter.logToPairing(`read and write access available for ${port}`);
-                        this.adapter.sendTo(from, command, {}, callback);
-                    });
-                }
-                catch (error) {
-                    const msg = `File access error: ${error && error.message ? error.message : 'no message given'}`;
-                    this.error(msg);
-                    this.adapter.logToPairing(`Error: ${msg}`);
-                    this.adapter.sendTo(from, command, {error:msg}, callback);
-                }
+    }
+
+    async triggerIconDownload(obj) {
+        if (!this.stController) {
+            this.adapter.sendTo(obj.from, obj.command, {msg:'No States controller'}, obj.callback);
+            return;
+        }
+        const clients = await this.adapter.getDevicesAsync();
+        const Promises = [];
+        for (const client of clients) {
+            if (client.common.modelIcon && client.common.icon && client.common.modelIcon.startsWith('http')) {
+                const filestatus = await this.adapter.fileExistsAsync(this.adapter.namespace, client.common.icon);
+                if (!filestatus)
+                    Promises.push(this.stController.downloadIconToAdmin(client.common.modelIcon, client.common.icon))
             }
+
+        }
+        const NumDownloads = Promises.length;
+        if (NumDownloads) {
+            this.adapter.sendTo(obj.from, obj.command, {msg:`${NumDownloads} downloads triggered.`}, obj.callback);
+            Promise.all(Promises);
         }
-        */
+        else {
+            this.adapter.sendTo(obj.from, obj.command, {msg:'Nothing to download'}, obj.callback);
+        }
+
     }
 }