iobroker.zigbee 2.0.0 → 2.0.2

package/lib/groups.js

@@ -1,25 +1,40 @@
 'use strict';
 
+const json = require('iobroker.zigbee/lib/json');
 const statesMapping = require('./devices');
+const { numberWithinRange } = require('zigbee-herdsman-converters/lib/utils');
+const idRegExp = new RegExp(/group_(\d+)/);
+
+
 
 class Groups {
     constructor(adapter) {
         this.adapter = adapter;
         this.adapter.on('message', this.onMessage.bind(this));
+        this.log = this.adapter.log;
+        this.idRegex = new RegExp(/group_(\d+)/)
+    }
+
+    static extractGroupID(id) {
+        switch (typeof id) {
+            case 'number': return id;
+            case 'string': {
+                const regexResult = id.match(idRegExp);
+                if (regexResult) return Number(regexResult[1]);
+                break;
+            }
+            default: return -1;
+        }
     }
 
+    static generateGroupID(gnum) {
+        return `group_${gnum}`;
+    };
+
     start(zbController, stController) {
         this.zbController = zbController;
         this.stController = stController;
-        this.adapter.getStateAsync('info.groups')
-            .then(groupsState => {
-                const groups = (groupsState && groupsState.val) ? JSON.parse(groupsState.val) : {};
-                for (const gid in groups) {
-                    stController.storeDeviceName(`group_${gid}`, groups[gid]);
-                }
-                // this.Adapter.deleteState('info.groups');
-                this.syncGroups();
-            });
+        this.syncGroups();
     }
 
     stop() {
@@ -66,10 +81,22 @@ class Groups {
         }
     }
 
+
+    buildGroupID(id, withInstance) {
+        const parts = [];
+        if (withInstance) parts.push(this.adapter.namespace);
+        if (Number(id) > 0)
+            parts.push(Groups.generateGroupID(id));
+        else {
+            if (Groups.extractGroupID(id) > 0) parts.push(id);
+        }
+        return parts.join('.');
+    }
+
     async getGroupMembersFromController(id) {
         const members = [];
         try {
-            const group = await this.zbController.getGroupByID(id);
+            const group = await this.zbController.getGroupByID(Number(id));
             if (group) {
                 const groupmembers = group.members;
 
@@ -85,29 +112,32 @@ class Groups {
             }
 
         } catch (error) {
-            if (error) this.error(`getGroupMembersFromController: error is  ${(error && error.message ? error.message : 'no error message')} ${(error && error.stack ? error.stack : 'no call stack')}`);
+            if (error) this.error(`getGroupMembersFromController: error is  ${JSON.stringify(error)} ${JSON.stringify(new Error().stack)}`);
             else this.error('unidentifed error in getGroupMembersFromController');
         }
         return members;
     }
 
     async getGroups(obj) {
+        this.debug('get groupes called with ' + JSON.stringify(obj));
         const response = {groups: {}};
 
         const isEnable = await this.adapter.getStateAsync('info.connection');
+        this.debug('get groupes called with ' + (obj ? JSON.stringify(obj) : 'no object') + ' ' + (isEnable.val ? 'connected' : 'disconnected'));
         if (isEnable.val) {
             try {
                 const herdsmanGroups = await this.zbController.getGroups();
                 const groups = {};
                 if (typeof herdsmanGroups === 'object') {
                     for (const group of herdsmanGroups) {
-                        const gid = group.groupID;
+                        const gid = group.id;
                         if (gid) {
-                            groups[gid] = this.stController.verifyDeviceName(`group_${gid}`, `Group ${gid}`);
+                            const name = this.stController.verifyDeviceName(`group_${gid}`, `Group`, `Group ${gid}`);
+                            groups[gid] = name;
                         }
                     }
                 }
-                this.debug(`getGroups result: ${JSON.stringify(groups)}`);
+                this.debug(`getGroups result: ${JSON.stringify(groups)} ( ${JSON.stringify(herdsmanGroups)})`);
                 response.groups = groups;
             } catch (error) {
                 response.error = `res getGroups: caught error: ${error}`;
@@ -123,7 +153,7 @@ class Groups {
         try {
             const groups = message && message.groups ? message.groups : {};
             const devId = message && message.id ? message.id : undefined;
-            this.warn('updateGroupMembership called with ' + JSON.stringify(devId));
+            this.debug('updateGroupMembership called with ' + JSON.stringify(devId));
             if (devId === undefined) {
                 this.adapter.sendTo(from, command, {error: 'No device specified'}, callback);
             }
@@ -138,30 +168,32 @@ class Groups {
                 for (const gpid of groups[epid]) {
                     const gpidn = parseInt(gpid);
                     if (gpidn < 0) {
-                        this.debug(`calling removeDevFromGroup with ${sysid}, ${-gpidn}, ${epid}` );
+                        this.warn(`calling removeDevFromGroup with ${sysid}, ${-gpidn}, ${epid}` );
                         const response = await this.zbController.removeDevFromGroup(sysid, (-gpidn), epid);
                         if (response && response.error) {
                             errors.push(response.error);
                             this.error(`remove dev from group Error: ${JSON.stringify(response.error)}`);
                         }
-
+                        const icon = this.stController.getDefaultGroupIcon(-gpidn)
                     } else if (gpidn > 0) {
-                        this.debug(`calling addDevToGroup with ${sysid}, ${gpidn}, ${epid}` );
+                        this.warn(`calling addDevToGroup with ${sysid}, ${gpidn}, ${epid}` );
                         const response = await this.zbController.addDevToGroup(sysid, (gpidn), epid);
                         if (response && response.error) {
                             errors.push(response.error);
                             this.error(`add dev to group Error: ${JSON.stringify(response.error)}`);
                         }
                     } else {
-                        this.warn('illegal group id 0');
+                        this.error('illegal group id 0');
                     }
                 }
             }
         } catch (e) {
-            this.warn('caught error ' + (e && e.message ? e.message : 'no error message') + ' in updateGroupMembership');
+            this.warn('caught error ' + JSON.stringify(e) + ' in updateGroupMembership');
             this.adapter.sendTo(from, command, {error: e}, callback);
             return;
         }
+        //await this.renameGroup(from, command, { name: undefined, id: message.id});
+        this.syncGroups();
         this.adapter.sendTo(from, command, {}, callback);
     }
 
@@ -211,28 +243,41 @@ class Groups {
     }
 
     async renameGroup(from, command, message) {
+        this.debug(`rename group called with ${from}, ${command}, ${JSON.stringify(message)}`);
         // const groupsEntry = await this.adapter.getStateAsync('info.groups');
         // const objGroups = (groupsEntry && groupsEntry.val ? JSON.parse(groupsEntry.val) : {});
         const name = message.name;
         const id = `group_${message.id}`;
-        this.stController.storeDeviceName(id, name);
+        let icon = this.stController.localConfig.IconForId(id, 'group', await this.stController.getDefaultGroupIcon(id));
         try {
-            await this.zbController.verifyGroupExists(message.id);
+            const group = await this.zbController.verifyGroupExists(message.id);
+            if (message.remove) {
+                for (const member of message.remove) {
+                    const response = await this.zbController.removeDevFromGroup(member.id, id, member.ep);
+                    this.warn('trying to remove ' + member.id + (member.ep ? '.'+member.ep : '') + ' ' + ' from group ' + message.id + ' response is '+JSON.stringify(response));
+                }
+            }
+            if (icon.match(/img\/group_\d+\.png/g)) {
+                this.warn('.');
+                icon = await this.zbController.rebuildGroupIcon(group);
+            }
         } catch (e) {
+            this.warn('renameGroup caught error ' + (e && e.message ? e.message : 'no message'));
             if (e && e.hasOwnProperty('code')) {
                 this.warn(`renameGroup caught error ${JSON.stringify(e.code)}`);
             }
         }
-
-        const group = await this.adapter.getStateAsync(id);
+        this.warn(`rename group name ${name}, id ${id}, icon ${icon} remove ${JSON.stringify(message.removeMembers)}`);
+        const group = await this.adapter.getObjectAsync(id);
         if (!group) {
+            this.warn('group object doesnt exist ')
             // assume we have to create the group
             this.adapter.setObjectNotExists(id, {
                 type: 'device',
-                common: {name: name, type: 'group'},
+                common: {name: (name ? name : `Group ${message.id}` ), type: 'group', icon: icon},
                 native: {id}
             }, () => {
-                this.adapter.extendObject(id, {common: {name, type: 'group'}});
+                this.adapter.extendObject(id, {common: {name, type: 'group', icon: icon}});
                 // create writable states for groups from their devices
                 for (const stateInd in statesMapping.groupStates) {
                     if (!statesMapping.groupStates.hasOwnProperty(stateInd)) {
@@ -252,25 +297,35 @@ class Groups {
                     };
                     this.stController.updateState(id, statedesc.id, undefined, common);
                 }
+                this.stController.storeDeviceName(id, name);
             });
         }
+        else {
+            this.warn('group object exists');
+            this.adapter.extendObject(id, {common: {name, type: 'group', icon: icon}});
+        }
     }
 
     async syncGroups() {
         const groups = await this.getGroups();
+        this.debug('sync Groups called: groups is '+ JSON.stringify(groups))
         const chain = [];
         const usedGroupsIds = [];
+        let GroupCount = 0;
         for (const j in groups) {
+            GroupCount++;
+            this.debug(`group ${GroupCount} is ${JSON.stringify(j)}`);
             if (groups.hasOwnProperty(j)) {
                 const id = `group_${j}`;
                 const name = groups[j];
+                const icon = this.stController.localConfig.IconForId(id, 'group', await this.stController.getDefaultGroupIcon(id));
                 chain.push(new Promise(resolve => {
                     this.adapter.setObjectNotExists(id, {
                         type: 'device',
-                        common: {name: name, type: 'group'},
+                        common: {name: name, type: 'group', icon: icon },
                         native: {id: j}
                     }, () => {
-                        this.adapter.extendObject(id, {common: {type: 'group'}});
+                        this.adapter.extendObject(id, {common: {type: 'group', icon: icon}});
                         // create writable states for groups from their devices
                         for (const stateInd in statesMapping.groupStates) {
                             if (!statesMapping.groupStates.hasOwnProperty(stateInd)) {
@@ -316,4 +371,4 @@ class Groups {
     }
 }
 
-module.exports = Groups;
+module.exports = Groups ;

package/lib/localConfig.js

@@ -0,0 +1,301 @@
+'use strict';
+
+/*eslint no-unused-vars: ['off']*/
+const fs = require('fs');
+const path = require('path');
+const utils = require('@iobroker/adapter-core'); // Get common adapter utils
+// const { src } = require('gulp');
+
+const EventEmitter = require('events').EventEmitter;
+
+class localConfig extends EventEmitter {
+    constructor(adapter, options) {
+        super();
+        this.adapter = adapter;
+        this.name = 'localConfig';
+        this.localData = { by_id:{}, by_model:{} };
+        this.filename = undefined;
+        this.basefolder = undefined;
+        this.retTimeoutHanlde = undefined;
+        this.adapter.on('ready', () => this.onReady());
+        this.adapter.on('unload', callback => this.onUnload(callback));
+    }
+
+
+    async onReady()
+    {
+    }
+
+    async onUnload(callback)
+    {
+        this.info('local config saved');
+        this.retainData();
+        callback();
+    }
+
+    info(message) {
+        this.adapter.log.info(message);
+        this.emit('log', 'info',message);
+    }
+
+    error(message, errobj) {
+        this.adapter.log.error(`${this.name}:${message}`);
+        this.emit('log', 'error',`${this.name}:${message}`, errobj);
+    }
+
+    warn(message) {
+        this.adapter.log.warn(`${this.name}:${message}`);
+        this.emit('log', 'warn',`${this.name}:${message}`);
+    }
+
+    debug(message) {
+        this.adapter.log.debug(`${this.name}:${message}`);
+        this.emit('log', 'debug',`${this.name}:${message}`);
+    }
+
+    async updateDeviceName(id, name) {
+        this.debug('updateDev with ' + id + ' and .'+ name +'.');
+        if (typeof id != 'string') {
+            this.error(`update called with illegal device entry:${JSON.stringify(id)}`)
+            return true;
+        }
+        if (typeof name != 'string' || name.trim().length < 1)
+        {
+            if (this.localData.hasOwnProperty(id))
+                delete this.localData.by_id[id].name;
+        }
+        else {
+            if (this.localData.by_id.hasOwnProperty(id))
+                this.localData.by_id[id].name = name;
+            else
+                this.localData.by_id[id] = { name: name };
+        }
+        return true;
+    }
+
+    async updateLocalOverride(_target, model, key, data, global)
+    {
+        const target = (global ? model : _target);
+        this.info(`updating local data: (${global ? 'global':'local'}) : ${target}:${key}:${data}`);
+
+        if (typeof target != 'string' || typeof key != 'string') {
+            this.error(`update called with illegal id data:${JSON.stringify(target)}:${JSON.stringify(key)}:${JSON.stringify(data)}`)
+            return false;
+        }
+        const base = global ? this.localData.by_model[target] || {} : this.localData.by_id[target] || {};
+        if (data && data.length > 0 && data != 'none') {
+            if (key == 'icon')
+                base[key] = data.replace(this.basefolder, '.');
+            else
+                base[key] = data;
+        }
+        else
+        {
+            if (base.hasOwnProperty(key)) {
+                delete base[key]
+            }
+        }
+        if (global) {
+            if (base == {}) delete this.localData.by_model[target];
+            else this.localData.by_model[target] = base;
+        }
+        else {
+            if (base == {}) delete this.localData.by_id[target];
+            else this.localData.by_id[target] = base;
+        }
+        this.info(`Local Data for ${target} is ${JSON.stringify(base)}`);
+        return true;
+    }
+
+
+    NameForId(id, model, defaultName) {
+        this.debug('name for id with ' + id + ' and ' + defaultName + ' from ' + JSON.stringify(this.localData));
+        const localstorage = (this.localData.by_id[id] || this.localData.by_model[model]);
+        if (localstorage && localstorage.hasOwnProperty['name']) return localstorage.name;
+        return defaultName;
+    }
+
+    IconForId(id, model, defaultIcon) {
+        let modeloverride = {};
+        this.debug('Icon for id with ' + id + ', ' + model + ' and ' + defaultIcon);
+        if (this.localData.by_id.hasOwnProperty(id))
+        {
+            modeloverride = this.localData.by_id[id]
+        }
+        if (!modeloverride.icon) {
+            if (this.localData.by_model.hasOwnProperty(model))
+                modeloverride = this.localData.by_model[model];
+        }
+        const iconPath = modeloverride.icon;
+        this.debug('icon Path is  '+ JSON.stringify(iconPath));
+        if (typeof iconPath != 'string') {
+            this.debug('icon path is no string, returning ' + JSON.stringify(defaultIcon));
+            return defaultIcon;
+        }
+        if (iconPath.startsWith('http')) return iconPath;
+        const namespace = `${this.adapter.name}.admin`;
+        const rv = `img/${path.basename(iconPath)}`;
+        try {
+            this.adapter.fileExists(namespace, rv, (err, result) => {
+                if (result) return;
+                const src = this.adapter.expandFileName(iconPath).replace('.','_');
+                fs.readFile(src, (err, data) => {
+                    if (err) {
+                        this.error('unable to read ' + src + ' : '+ (err && err.message? err.message:' no message given'))
+                        return;
+                    }
+                    if (data) {
+                        this.adapter.writeFile(namespace, rv, data, (err) => {
+                            if (err) {
+                                this.error('error writing file ' + path + JSON.stringify(err))
+                                return;
+                            }
+                            this.info('Updated image file ' + rv)
+                        })
+                    }
+                })
+
+            })
+        } catch (error) {
+            this.error(`Error accessing target image: ${error && error.message ? error.message : 'no error message'}`);
+        }
+        return rv;
+    }
+
+
+    async copyDeviceImage(src) {
+        const dst = `${this.adapter.adapterDir}/admin/img/${path.basename(src)}`;
+        const _src = this.adapter.expandFileName(src);
+        if (fs.existsSync(src)  && !fs.existsSync(dst))
+        {
+            try {
+                this.log.info(`copying image from :${src} to ${dst}`)
+                fs.copyFileSync(src, dst)
+            }
+            catch {
+                this.log.debug(`failed to copy from :${src} to ${dst}`)
+            }
+        }
+    }
+
+    getOverrideData(target, isGlobal) {
+        const base = (isGlobal ? this.localData.by_model : this.localData.by_id);
+        if (base.hasOwnProperty(target)) return base[target];
+        return {};
+    }
+
+    setOverrideData(target, isGlobal, data) {
+        const base = (isGlobal ? this.localData.by_model : this.localData.by_id);
+        if (typeof target != 'string') {
+            this.error('illegal target for override data: '+JSON.stringify(target));
+            return;
+        }
+        base[target]=data;
+    };
+
+    async getLegacyModels() {
+        const legacyModels = [];
+        for (const model in this.localData.by_model) {
+            if (this.localData.by_model[model].hasOwnProperty('legacy') && this.localData.by_model[model].legacy)
+                legacyModels.push(model);
+        }
+        return legacyModels;
+    }
+
+    getOverridesWithKey(key, isGlobal) {
+        const base = (isGlobal ? this.localData.by_model : this.localData.by_id);
+        const rv = [];
+        for(const prop in base) {
+            if (base[prop].hasOwnProperty(key)) {
+                rv.push({key:prop, value:base[prop][key]});
+            }
+        }
+        return rv;
+    }
+
+    getOverrideWithKey(target, key, isGlobal) {
+        const targetdata = this.getOverrideData(target, isGlobal);
+        if (targetdata && targetdata.hasOwnProperty(key)) return targetdata[key];
+        return undefined;
+    }
+
+    async updateFromDeviceNames() {
+        this.warn('updateFromDeviceNames');
+        const fn = this.adapter.expandFileName('dev_names').replace('.', '_').concat('.json');
+        fs.readFile(fn, (err, content) => {
+            if (!err) {
+                let data_js = {};
+                try {
+                    data_js = JSON.parse(content);
+                }
+                catch (error) {
+                    this.error(`unable to parse data read from ${fn} : ${error.message ? error.message : 'undefined error'}`)
+                    return;
+                }
+                try {
+                    for (const prop in data_js) {
+                        if (data_js[prop] != 'undefined')
+                            this.updateDeviceName(prop, data_js[prop]);
+                    }
+                }
+                catch (error) {
+                    this.error(`error in updateFromDeviceNames : ${error.message ? error.message : 'undefined error'}`)
+                    return;
+
+                }
+                this.retainData();
+            }
+        });
+    }
+
+    async init() {
+        this.info('init localConfig');
+        const fn = this.adapter.expandFileName('LocalOverrides').replace('.','_').concat('.json');
+        this.filename = fn;
+        this.basefolder = path.dirname(fn);
+
+        try {
+            const content = fs.readFileSync(fn);
+            try {
+                const data_js = JSON.parse(content);
+                this.localData = data_js;
+            }
+            catch (error) {
+                this.error(`unable to parse data read from ${fn} : ${error.message ? error.message : 'undefined error'}`);
+            }
+        } catch(error) {
+            await this.updateFromDeviceNames();
+        }
+    }
+
+    async retainData() {
+        //this.warn('retaining local config: ' + JSON.stringify(this.localData));
+        try {
+            fs.writeFileSync(this.filename, JSON.stringify(this.localData, null, 2))
+            this.info('Saved local configuration data');
+        }
+        catch (error) {
+            this.error(`error saving local config: ${error.message}`);
+        }
+    }
+
+    enumerateImages(_path) {
+        const rv = [];
+        try
+        {
+            const files= fs.readdirSync(_path, {withFileTypes: true, recursive: true}).filter(item => (!item.isDirectory() && item.name.endsWith('.png')));
+            files.forEach((item) => {
+                const fn = path.join(item.parentPath, item.name);
+                rv.push({file: fn, name: item.name, data: fs.readFileSync(path.join(item.parentPath, item.name), 'base64')})
+            });
+            //this.warn('enumerateImages for  ' + _path + ' is ' + JSON.stringify(rv));
+        }
+        catch (error) {
+            this.error(`error in enumerateImages : ${error.message ? error.message : 'undefined error'}`)
+        }
+        return rv;
+    }
+
+}
+
+module.exports = localConfig;

package/lib/ota.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const getZbId = require('./utils').getZbId;
+const zhc_ota = require('zigbee-herdsman-converters').ota;
 
 class Ota {
     constructor(adapter) {
@@ -24,7 +25,7 @@ class Ota {
     }
 
     warn(msg) {
-        this.adapter.log.info(msg);
+        this.adapter.log.warn(msg);
     }
 
     error(msg) {
@@ -94,10 +95,10 @@ class Ota {
             this.debug(`Checking if firmware update is available for ${device.name}`);
 
             if (device && device.mapped.ota) {
-                const available = await device.mapped.ota.isUpdateAvailable(device.device, null);
+                const available = await zhc_ota.isUpdateAvailable(device.device, device.mapped.ota, undefined, false);
                 result.status = available.available ? 'available' : 'not_available';
                 if (available.currentFileVersion !== available.otaFileVersion) {
-                    this.warn(`current Firmware for ${device.name} is ${available.currentFileVersion} new is ${available.otaFileVersion}`);
+                    this.debug(`current Firmware for ${device.name} is ${available.currentFileVersion} new is ${available.otaFileVersion}`);
                 }
             } else {
                 result.status = 'not_supported';
@@ -155,7 +156,7 @@ class Ota {
             };
 
             const from_ = await this.readSoftwareBuildIDAndDateCode(device.device, false);
-            const fileVersion = await device.mapped.ota.updateToLatest(device.device, onProgress);
+            const fileVersion = await zhc_ota.update(device.device, device.mapped.ota, false, onProgress)
             const to = await this.readSoftwareBuildIDAndDateCode(device.device, true);
             const [fromS, toS] = [JSON.stringify(from_), JSON.stringify(to)];
             result.status = 'success';