iobroker.zigbee 1.10.14 → 2.0.1

package/lib/exclude.js

@@ -1,4 +1,5 @@
 'use strict';
+const devicedefinitions = require('./devices');
 
 class Exclude {
     constructor(adapter) {
@@ -9,6 +10,7 @@ class Exclude {
     start(zbController, stController) {
         this.zbController = zbController;
         this.stController = stController;
+        this.localConfig = stController.localConfig;
     }
 
     stop() {
@@ -52,6 +54,12 @@ class Exclude {
                             this.adapter.sendTo(obj.from, obj.command, exclude, obj.callback));
                     }
                     break;
+                case 'getExcludable':
+                    if (obj && obj.message && typeof obj.message === 'object') {
+                        this.getExcludable(exclude =>
+                            this.adapter.sendTo(obj.from, obj.command, exclude, obj.callback));
+                    }
+                    break;
                 case 'delExclude':
                     if (obj && obj.message) {
                         this.delExclude(obj.from, obj.command, obj.message, err =>
@@ -74,7 +82,7 @@ class Exclude {
     }
 
     extractExcludeId(stateId) {
-        return stateId.replace(`${this.adapter.namespace}.exclude.`, '');
+        return stateId.replace(`${this.adapter.namespace}.info.legacy.`, '');
     }
 
     getExcludeName(devName, stateId) {
@@ -83,18 +91,10 @@ class Exclude {
 
     async addExclude(from, command, params, callback) {
         try {
-            this.debug('addExclude message: ' + JSON.stringify(params));
+            //this.warn('addExclude message: ' + JSON.stringify(params));
             const exclude_mod = params.exclude_model.common.type;
-            const stateId = `exclude.${exclude_mod}`;
-
-            this.adapter.setObjectNotExists(stateId,
-                {
-                    type: 'state',
-                    common: {name: exclude_mod},
-                },
-                () => this.adapter.setState(stateId, exclude_mod, true, () =>
-                    callback()),
-            );
+            this.localConfig.updateLocalOverride(exclude_mod, exclude_mod, 'legacy', exclude_mod, true);
+            callback({});
         } catch (error) {
             this.error(`Failed to addExclude ${error.stack}`);
             throw new Error(`Failed to addExclude ${error.stack}`);
@@ -104,58 +104,34 @@ class Exclude {
     async delExclude(from, command, exclude_id, callback) {
         try {
             this.debug(`delExclude message: ${JSON.stringify(exclude_id)}`);
-            const stateId = `exclude.${exclude_id}`;
-            this.adapter.getStateAsync(stateId)
-                .then(async (stateV) => {
-                    this.debug(`found state: ${JSON.stringify(stateV)}`);
-                    this.adapter.deleteState(null, 'exclude', exclude_id, async () =>
-                        callback());
-                });
+            this.localConfig.updateLocalOverride(exclude_id, exclude_id, 'legacy', '', true);
+            callback({});
         } catch (error) {
             this.error(`Failed to delExclude ${error.stack}`);
             throw new Error(`Failed to delExclude ${error.stack}`);
         }
     }
 
-    getExclude(callback) {
+    async getExclude(callback) {
         try {
-            const exclude = [];
-            this.adapter.getStatesOf('exclude', (err, states) => {
-                if (!err && states) {
-                    const exc = [];
-                    states.forEach(state => {
-                        if (state._id.startsWith(`${this.adapter.namespace}.exclude`)) {
-                            exc.push(new Promise(resolve =>
-                                this.adapter.getStateAsync(state._id)
-                                    .then(stateVa => {
-                                        if (stateVa !== null) {
-                                            const val = {
-                                                id: this.extractExcludeId(state._id),
-                                                name: stateVa.val
-                                            };
-                                            if (this.extractExcludeId(state._id) !== 'all') {
-                                                exclude.push(val);
-                                            }
-                                        }
-                                        resolve();
-                                    })));
-                        }
-                    });
-                    return Promise.all(exc)
-                        .then(() => {
-                            const arrExclude = JSON.stringify(exclude);
-                            this.debug(`getExclude result: ${arrExclude}`);
-                            this.adapter.setState('exclude.all', arrExclude, true, () =>
-                                callback(exclude));
-                        });
-                } else {
-                    this.debug(`getExclude result: ${JSON.stringify(exclude)}`);
-                    callback(exclude);
-                }
-            });
+            const exclude = this.localConfig.getOverridesWithKey('legacy', true)
+            callback({legacy: exclude});
         } catch (error) {
             this.error(`Failed to getExclude ${error.stack}`);
+            callback({error: 'unable to get excludes' });
+        }
+    }
+
+    async getExcludable(callback) {
+        const devices = this.zbController.getClients();
+        const excludables = [];
+        for (const device of devices) {
+            const obj = await this.adapter.getObjectAsync(device.ieeeAddr.substr(2));
+            if (obj && obj.common && obj.common.type) {
+                excludables.push(obj.common.tyoe);
+            }
         }
+        callback(devices.pairedLegacyDevices(excludables));
     }
 }