iobroker.zigbee 3.0.3 → 3.1.2

package/lib/groups.js

@@ -1,9 +1,9 @@
 'use strict';
 
-const json = require('iobroker.zigbee/lib/json');
+const json = require('./json');
 const statesMapping = require('./devices');
 const idRegExp = new RegExp(/group_(\d+)/);
-
+const { getZbId , getAdId } = require('./utils');
 
 
 class Groups {
@@ -18,12 +18,17 @@ class Groups {
         switch (typeof id) {
             case 'number': return id;
             case 'string': {
-                const regexResult = id.match(idRegExp);
-                if (regexResult) return Number(regexResult[1]);
+                if (!id.includes('x')) {
+                    const numericresult = Number(id);
+                    if (numericresult) return numericresult;
+                    const regexResult = id.match(idRegExp);
+                    if (regexResult) return Number(regexResult[1]);
+                }
                 break;
             }
             default: return -1;
         }
+        return -1;
     }
 
     static generateGroupID(gnum) {
@@ -33,12 +38,39 @@ class Groups {
     start(zbController, stController) {
         this.zbController = zbController;
         this.stController = stController;
+        this.GroupData = { states:{} }; // field to store group members
+        /*
+        {
+            groupid: { info:
+                [
+                    ieee:
+                    ep:
+                    epname:
+                ], capabilties: [], stateupdate:true, memberupdate:'off'
+            }
+            groupid: members
+            }
+            states { 0xabcdef01234567890/1 : {
+                id:
+                epid:
+                groups:[]
+                states:[]
+              }, states: [state, brightness, ...];
+            ]
+        }
+        */
+        this.anyGroupStateUpdate = false;
+        this.GroupUpdateIntervalHandle = null;
+        this.GroupUpdateQueue = []
+        this.zbController.on('published', this.onGroupStatePublished.bind(this));
+        this.stController.on('changed', this.onDeviceStateChanged.bind(this));
         this.syncGroups();
     }
 
     stop() {
         delete this.zbController;
         delete this.stController;
+        delete this.GroupData;
     }
 
     info(msg) {
@@ -80,6 +112,197 @@ class Groups {
         }
     }
 
+    setMaxVal(target, values) {
+        this.adapter.setState(target,values.sort()[values.length-1], true);
+    }
+    setMinVal(target, values) {
+        this.adapter.setState(target,  values.sort()[0], true);
+    }
+
+    setAvgVal(target, values) {
+        let sum = 0;
+        let cnt = 0;
+        let hasBooleanSrc = false;
+        for (const v of values) {
+            if (typeof v === 'boolean') {
+                sum += v ? 1 : 0;
+                hasBooleanSrc = true;
+            }
+            else if (typeof v === 'number') sum += v;
+            else cnt--;
+            cnt++;
+        }
+        if (cnt > 0) {
+            if (hasBooleanSrc) this.adapter.setState(target, sum/cnt > 0.49999999, true);
+            else this.adapter.setState(target, sum/cnt, true)
+        }
+    }
+
+    async onGroupStatePublished(deviceId, model, stateModel, stateList, options, debugId) {
+        if (Groups.extractGroupID(deviceId) >= 0) { // the states are group states
+            for (const state of stateList) {
+                const GroupDataKey =`group_${deviceId}`
+                if (state.stateDesc.id === 'memberupdate')
+                {
+                    this.GroupData[GroupDataKey][state.stateDesc.id] = state.value;
+                }
+                if ( state.stateDesc.id === 'stateupdate') {
+                    this.GroupData[GroupDataKey][state.stateDesc.id] = state.value;
+                    this.anyGroupStateUpdate = false;
+                    for (const item in this.GroupData) {
+                        if (this.GroupData[item] && this.GroupData[item].hasOwnProperty('stateupdate')) {
+                            if (this.GroupData[item].stateupdate && this.GroupData[item].stateupdate == 'off') continue;
+                            this.anyGroupStateUpdate = true;
+                            break;
+                        }
+                    }
+                }
+                if (state.stateDesc.isCommonState) continue;
+                if (this.GroupData[GroupDataKey].memberupdate) this.readGroupMemberStatus(this, { id: deviceId, state:state.stateDesc.id} );
+            }
+        }
+    }
+
+    async onDeviceStateChanged(deviceId, model, stateModel, stateList, options, debugId) {
+        if (Groups.extractGroupID(deviceId) < 0) { // the states are device states
+            for (const state of stateList) {
+                const GroupDataKey =`group_${deviceId}`
+                const sd = state.stateDesc;
+                const id = deviceId;
+                if (sd.isCommonState || !this.anyGroupStateUpdate) continue // common states are never valid for groups
+                const sid = `${this.adapter.namespace}.${deviceId.split('x')[1]}.${state.stateDesc.id}`;
+                if (this.GroupData.states[sid]) this.GroupData.states[sid].val = state.value;
+
+                const affectedStates = this.GroupData.states[sid];
+                const targetsByGroup = []
+                if (typeof affectedStates == 'object' && affectedStates.targets.length > 0) {
+                    // find who feeds into these states
+                    for (const s of affectedStates.targets)
+                    {
+                        if (!targetsByGroup.includes(s)) {
+                            targetsByGroup.push(s);
+                        }
+                    }
+                    for (const target of targetsByGroup) {
+                        const gid = Groups.generateGroupID(getZbId(target));
+                        const gData = this.GroupData[gid]
+                        if (typeof gData == 'object' && gData.hasOwnProperty('stateupdate') && typeof this.GroupData.groupStates == 'object') {
+                            const method = gData.stateupdate;
+                            const sources = this.GroupData.groupStates[target]
+                            const values = [];
+                            if (typeof sources != 'object' || method === 'off') continue;
+                            for (const s of sources) {
+                                const v = await this.getGroupMemberValue(s);
+                                if (v != undefined) {
+                                    values.push(v);
+                                }
+                            }
+                            if (values.length < 2) {
+                                if (values.length > 0) this.adapter.setState(target, values[0], true)
+                                continue;
+                            }
+                            switch (method) {
+                                case 'min':
+                                    this.setMinVal(target, values);
+                                    break;
+                                case 'max':
+                                    this.setMaxVal(target, values);
+                                    break;
+                                case 'avg':
+                                    this.setAvgVal(target, values);
+                                    break;
+                                case 'mat': if (values.filter(c => c == values[0]).length == values.length)
+                                    this.adapter.setState(target, values[0], true);
+                                    break;
+                            }
+                        }
+
+                    }
+                }
+            }
+        }
+        else {
+            for (const state of stateList) {
+                const GroupDataKey =`group_${deviceId}`
+                if (state.stateDesc.id === 'memberupdate')
+                {
+                    this.GroupData[GroupDataKey][state.stateDesc.id] = state.value;
+                }
+                if ( state.stateDesc.id === 'stateupdate') {
+                    this.GroupData[GroupDataKey][state.stateDesc.id] = state.value;
+                    this.anyGroupStateUpdate = false;
+                    for (const item in this.GroupData) {
+                        if (this.GroupData[item] && this.GroupData[item].hasOwnProperty('stateupdate')) {
+                            if (this.GroupData[item].stateupdate && this.GroupData[item].stateupdate == 'off') continue;
+                            this.anyGroupStateUpdate = true;
+                            break;
+                        }
+                    }
+                }
+            }
+
+        }
+    }
+
+
+
+    static readables = {
+        state: { cluster:6, attributes:['onOff']},
+        brightness: { cluster:8, attributes:['currentLevel']},
+        colortemp: { cluster:768, attributes:['colorTemperature', 'colorMode']},
+        color_temp: { cluster:768, attributes:['colorTemperature', 'colorMode']},
+    }
+
+    async readMemberStatus(member, item, toRead) {
+        const entity = await this.zbController.resolveEntity(member.ieee, member.epid);
+        if (!entity) return;
+        const device = entity.device;
+        const endpoint = entity.endpoint;
+        const mappedModel = entity.mapped;
+        if (!mappedModel) return;
+        const converter = mappedModel.toZigbee.find(c => c && (c.key.includes(item.state)));
+        const canReadViaConverter = converter && converter.hasOwnProperty('convertGet');
+        if (canReadViaConverter) {
+            try {
+                await converter.convertGet(endpoint, item.state, {device:entity.device});
+            } catch (error) {
+                this.warn(`reading ${item.state} from ${member.id}${member.ieee ? '/' + member.epid : ''} via convertGet failed with ${error && error.message ? error.message : 'no reason given'}`);
+                return {unread:member.device};
+            }
+            this.warn(`reading ${item.state} from ${member.ieee}${member.ep ? '/' + member.epid : ''} via convertGet succeeded` )
+            return {read:member.device};
+        }
+        if (toRead.cluster) {
+            if (device && endpoint) {
+                if (entity.endpoint.inputClusters.includes(toRead.cluster)) {
+                    try {
+                        const result = await endpoint.read(toRead.cluster, toRead.attributes,{disableDefaultResponse : true });
+                        this.warn(`readGroupMemberStatus for ${item.state} from ${member.ieee}${member.ep ? '/' + member.epid : ''} resulted in ${JSON.stringify(result)}`);
+                    }
+                    catch (error) {
+                        this.warn(`reading ${item.state} from ${member.ieee}${member.ep ? '/' + member.epid : ''} via endpoint.read with ${toRead.cluster}, ${JSON.stringify(toRead.attributes)} resulted in ${error && error.message ? error.message : 'an unspecified error'}`);
+                    }
+                    this.warn(`reading ${item.state} from ${member.ieee}${member.ep ? '/' + member.epid : ''} via endpoint.read with ${toRead.cluster}, ${JSON.stringify(toRead.attributes)} succeeded`);
+                }
+                else this.warn(`omitting cluster ${toRead.cluster} - not supported`);
+            }
+            else {
+                this.warn(`unable to read ${item.state} from ${member.id}${member.ep ? '/' + member.epid : ''} - unable to resolve the entity`);
+            }
+            return;
+        }
+    }
+
+    async readGroupMemberStatus(obj, item) {
+        obj.warn(`rgms with ${JSON.stringify(item)}`);
+
+        const toRead = Groups.readables[item.state]
+        if (toRead) {
+            const members = await obj.zbController.getGroupMembersFromController(item.id);
+            Promise.all(members.map((m) => this.readMemberStatus(m, item, toRead)))
+        }
+    }
+
 
     buildGroupID(id, withInstance) {
         const parts = [];
@@ -157,16 +380,13 @@ class Groups {
                 this.adapter.sendTo(from, command, {error: 'No device specified'}, callback);
             }
             const sysid = devId.replace(this.adapter.namespace + '.', '0x');
-            // Keeping this for reference. State update or state removal needs to be decided upon
-            //const id = `${devId}.groups`;
-            // this.adapter.setState(id, JSON.stringify(groups), true);
-
-            //const current = await this.zbController.getGroupMembersFromController(sysid);
             const errors = [];
+            const GroupsToSync = [];
             for (const epid in groups) {
                 for (const gpid of groups[epid]) {
                     const gpidn = parseInt(gpid);
                     if (gpidn < 0) {
+                        GroupsToSync.push(-gpidn);
                         this.debug(`calling removeDevFromGroup with ${sysid}, ${-gpidn}, ${epid}` );
                         const response = await this.zbController.removeDevFromGroup(sysid, (-gpidn), epid);
                         if (response && response.error) {
@@ -175,6 +395,7 @@ class Groups {
                         }
                         const icon = this.stController.getDefaultGroupIcon(-gpidn)
                     } else if (gpidn > 0) {
+                        GroupsToSync.push(gpidn);
                         this.debug(`calling addDevToGroup with ${sysid}, ${gpidn}, ${epid}` );
                         const response = await this.zbController.addDevToGroup(sysid, (gpidn), epid);
                         if (response && response.error) {
@@ -186,13 +407,13 @@ class Groups {
                     }
                 }
             }
+            this.syncGroups(GroupsToSync);
         } catch (e) {
             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);
     }
 
@@ -239,6 +460,7 @@ class Groups {
     async deleteGroup(from, command, message) {
         await this.zbController.removeGroupById(message);
         await this.stController.deleteObj(`group_${parseInt(message)}`);
+        await this.removeGroupMemberStateList(parseInt(message));
     }
 
     async renameGroup(from, command, message) {
@@ -266,58 +488,181 @@ class Groups {
             }
         }
         this.debug(`rename group name ${name}, id ${id}, icon ${icon} remove ${JSON.stringify(message.removeMembers)}`);
-        const group = await this.adapter.getObjectAsync(id);
-        if (!group) {
-            this.debug('group object doesnt exist ')
-            // assume we have to create the group
-            this.adapter.setObjectNotExists(id, {
-                type: 'device',
-                common: {name: (name ? name : `Group ${message.id}` ), type: 'group', icon: icon},
-                native: {id}
-            }, () => {
-                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)) {
-                        continue;
+        this.syncGroups([parseInt(message.id)]);
+    }
+
+    addMissingState(arr, states) {
+        if (typeof arr != 'object') arr = [];
+        for (const state of [...states]) {
+            if (arr.find((candidate) => candidate == state.id)=== undefined) arr.push(state.id)
+        }
+        return arr;
+    }
+
+    async getGroupMemberCapabilities(members) {
+        // const rv = [];
+        const rv = this.addMissingState([],statesMapping.commonGroupStates);
+        for (const member of members) {
+            const entity = await this.zbController.resolveEntity(member.ieee, member.epid);
+            if (!entity) continue;
+            if (entity.endpoint.inputClusters.includes(6)) { // genOnOff
+                this.addMissingState(rv,statesMapping.onOffStates);
+            }
+            if (entity.endpoint.inputClusters.includes(768)) { //genLightingColorCtrl
+                this.addMissingState(rv, statesMapping.lightStatesWithColor);
+            } else if (entity.endpoint.inputClusters.includes(8)) { // genLvlControl
+                this.addMissingState(rv,statesMapping.lightStates);
+            }
+        }
+        return rv;
+    }
+
+    async removeGroupMemberStateList(numericGroupID, allowedDevices) {
+        const groupID = `group_${numericGroupID}`;
+        const gd = this.GroupData;
+
+        const devices = allowedDevices ? allowedDevices : undefined;
+
+        const trackedStates = gd && gd.states ? gd.states : {};
+        const t = this;
+        if (!devices && this.GroupData.hasOwnProperty(groupID)) delete this.GroupData[groupID];
+
+        // remove the ones which are no longer part of the group
+        const keys = Object.keys(trackedStates);
+
+        for (const key of keys) {
+            const devId = key.split('.')[2]
+            if (devices && devices.includes(getZbId(key))) continue;
+            if (trackedStates[key] && typeof trackedStates[key].targets == 'object')
+                trackedStates[key].targets = trackedStates[key].targets.filter((c) => !c.includes(groupID));
+            else trackedStates[key].targets = [];
+            if (trackedStates[key].targets.length < 1) delete trackedStates[key]
+        };
+
+    }
+
+    async rebuildGroupMemberStateList(numericGroupID, memberInfo) {
+        const groupID = `group_${numericGroupID}`;
+        const gd = this.GroupData[groupID];
+        const t = this;
+
+        // remove the ones which are no longer part of the group
+        const keys = Object.keys(this.GroupData.states);
+        this.removeGroupMemberStateList(numericGroupID, memberInfo.members.map((m) => m.ieee));
+
+        const UpdatableStates = [];
+        for (const member of memberInfo.members) {
+            const entity = await t.zbController.resolveEntity(member.ieee, member.epid);
+            if (!entity) return;
+            const device = entity.device;
+            const endpoint = entity.endpoint;
+            const mappedModel = entity.mapped;
+            if (!mappedModel) return;
+            const ieeeParts = member.ieee.split('x');
+            const devId = ieeeParts.length > 1 ? ieeeParts[1]:ieeeParts[0]
+            const devStates = await t.stController.getDevStates(devId, mappedModel.model);
+            devStates.states.forEach(state => {
+                const key = state.setattr || state.prop || state.id;
+                if (key) {
+                    if (memberInfo.capabilities && memberInfo.capabilities.find(candidate => candidate == key)) {
+                        if (member.epname && member.epname == state.epname) return;
+                        UpdatableStates.push({id: `${t.adapter.namespace}.${devId}.${state.id}`, grpid: `${t.adapter.namespace}.${groupID}.${key}`})
                     }
-                    const statedesc = statesMapping.groupStates[stateInd];
-                    const common = {
-                        name: statedesc.name,
-                        type: statedesc.type,
-                        unit: statedesc.unit,
-                        read: statedesc.read,
-                        write: statedesc.write,
-                        icon: statedesc.icon,
-                        role: statedesc.role,
-                        min: statedesc.min,
-                        max: statedesc.max,
-                    };
-                    this.stController.updateState(id, statedesc.id, undefined, common);
                 }
-                this.stController.storeDeviceName(id, name);
-            });
+            })
+
+        };
+        UpdatableStates.forEach(entry => {
+            const ged = this.GroupData.states[entry.id]
+            if (ged) {
+                if (!ged.targets.includes(entry.grpid))
+                    ged.targets.push(entry.grpid);
+            }
+            else
+            {
+                this.GroupData.states[entry.id] = {val:undefined, targets:[entry.grpid]};
+            }
+        })
+        const gsm = {};
+        for (const s in this.GroupData.states) {
+            const gds = this.GroupData.states[s]
+            if (gds && typeof gds.targets && gds.targets.length > 0) {
+                for (const t of gds.targets) {
+                    if (!gsm.hasOwnProperty(t))
+                        gsm[t] = [];
+                    if (!gsm[t].includes(s)) gsm[t].push(s)
+                }
+            }
         }
-        else {
-            this.debug('group object exists');
-            this.adapter.extendObject(id, {common: {name, type: 'group', icon: icon}});
+        this.GroupData.groupStates = gsm;
+    }
+
+    async getGroupMemberValue(id) {
+        if (!this.GroupData.states[id]) return undefined;
+        const val = this.GroupData.states[id].val;
+        if (val == null || val == undefined) {
+            const obj = await this.adapter.getStateAsync(id);
+            if (obj) {
+                this.GroupData.states[id].val = obj.val;
+                return obj.val;
+            }
+            return undefined;
         }
+        return val;
     }
 
-    async syncGroups() {
+    async syncGroups(group_id) {
+        const numericGroupIdArray = [];
+        if (group_id) group_id.forEach(gid => numericGroupIdArray.push(Groups.extractGroupID(gid)));
+        // get all group id's from the database and the respective names from the local overrides (if present)
         const groups = await this.getGroups();
-        this.debug('sync Groups called: groups is '+ JSON.stringify(groups))
         const chain = [];
-        const usedGroupsIds = [];
-        let GroupCount = 0;
+        const usedGroupsIds = Object.keys(groups);
         for (const j in groups) {
-            GroupCount++;
-            this.debug(`group ${GroupCount} is ${JSON.stringify(j)}`);
+            if (numericGroupIdArray.length > 0 && !numericGroupIdArray.includes(Number(j))) continue; // skip groups we didnt ask for
+            this.debug(`Analysing group_${JSON.stringify(j)}`);
             if (groups.hasOwnProperty(j)) {
                 const id = `group_${j}`;
+                const members = await this.zbController.getGroupMembersFromController(j);
+                const memberInfo = { capabilities: [], members: [] };
+                const storedGroupInfo = this.GroupData.hasOwnProperty(id) ? this.GroupData[id] : { capabilities: [], members: [] };
+                let GroupMembersChanged = false;
+                if (members) for (const member of members) {
+                    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();
+                        for (const key in epnames) {
+                            if (epnames[key] == member.epid) {
+                                epname = key;
+                                break;
+                            }
+                        }
+                    }
+                    GroupMembersChanged |= (storedGroupInfo.members.find((obj) => obj.ieee === member.ieee && obj.epid === member.epid) === undefined)
+                    memberInfo.members.push({ ieee:member.ieee, epid:member.epid, epname: epname });
+                    const key = `${member.ieee}/${member.epid}`;
+                }
+                GroupMembersChanged |= (memberInfo.members.length != storedGroupInfo.length);
+                this.GroupData[id] = memberInfo;
+
+                const mu = await this.adapter.getStateAsync(`${this.adapter.namespace}.group_${j}.memberupdate`);
+                if (mu) this.GroupData[id].memberupdate = mu.val;
+                else    this.GroupData[id].memberupdate = false;
+                const su = await this.adapter.getStateAsync(`${this.adapter.namespace}.group_${j}.stateupdate`);
+                if (su) this.GroupData[id].stateupdate = (typeof su.val == 'string' ? su.val : 'off') ;
+                else    this.GroupData[id].stateupdate = 'off';
+                if (this.GroupData[id].stateupdate != 'off') this.anyGroupStateUpdate = true;
+
+                if (GroupMembersChanged) {
+                    memberInfo.capabilities = await this.getGroupMemberCapabilities(memberInfo.members);
+                    this.rebuildGroupMemberStateList(j, memberInfo);
+                }
+
                 const name = groups[j];
                 const icon = this.stController.localConfig.IconForId(id, 'group', await this.stController.getDefaultGroupIcon(id));
                 chain.push(new Promise(resolve => {
+                    const isActive = false;
                     this.adapter.setObjectNotExists(id, {
                         type: 'device',
                         common: {name: name, type: 'group', icon: icon },
@@ -330,23 +675,16 @@ class Groups {
                                 continue;
                             }
                             const statedesc = statesMapping.groupStates[stateInd];
-                            const common = {
-                                name: statedesc.name,
-                                type: statedesc.type,
-                                unit: statedesc.unit,
-                                read: statedesc.read,
-                                write: statedesc.write,
-                                icon: statedesc.icon,
-                                role: statedesc.role,
-                                min: statedesc.min,
-                                max: statedesc.max,
-                            };
+                            const common = {};
+                            for (const prop in statedesc) common[prop] = statedesc[prop];
+                            common.color= memberInfo.capabilities.find((candidate) => candidate == statedesc.id) ? null: '#888888';
+
                             this.stController.updateState(id, statedesc.id, undefined, common);
                         }
                         resolve();
                     });
                 }));
-                usedGroupsIds.push(parseInt(j));
+                usedGroupsIds.push(j);
             }
         }
         chain.push(new Promise(resolve =>
@@ -355,9 +693,8 @@ class Groups {
                 if (!err) {
                     devices.forEach((dev) => {
                         if (dev.common.type === 'group') {
-                            const groupid = parseInt(dev.native.id);
-                            if (!usedGroupsIds.includes(groupid)) {
-                                this.stController.deleteObj(`group_${groupid}`);
+                            if ( dev.native.id && !usedGroupsIds.includes(dev.native.id)) {
+                                this.stController.deleteObj(`group_${dev.native.id}`);
                             }
                         }
                     });

package/lib/localConfig.js

@@ -60,7 +60,7 @@ class localConfig extends EventEmitter {
         }
         if (typeof name != 'string' || name.trim().length < 1)
         {
-            if (this.localData.hasOwnProperty(id))
+            if (this.localData.by_id.hasOwnProperty(id))
                 delete this.localData.by_id[id].name;
         }
         else {
@@ -103,6 +103,7 @@ class localConfig extends EventEmitter {
             else this.localData.by_id[target] = base;
         }
         this.info(`Local Data for ${target} is ${JSON.stringify(base)} after update`);
+        this.retainData();
         return true;
     }
 
@@ -311,11 +312,21 @@ class localConfig extends EventEmitter {
         return rv;
     }
 
-    getOptions(dev_id) {
+    getOptions(dev_id, model_id) {
+        function extractOptions(target, options) {
+            if (typeof target != 'object') target = {};
+            if (typeof options != 'object') return target;
+            Object.keys(options).forEach((option) => target[option] = options[option]);
+            return target;
+        }
+
         const ld = this.localData.by_id[dev_id];
-        if (ld === undefined || ld.options === undefined) return {};
-        this.debug(`getOptions for ${dev_id} : ${JSON.stringify(ld.options)}`);
-        return ld.options;
+        const gd = this.localData.by_model[model_id];
+        const rv = {};
+        if (gd) extractOptions(rv, gd.options);
+        if (ld) extractOptions(rv, ld.options);
+        this.debug(`getOptions for ${dev_id} : ${JSON.stringify(rv)}`);
+        return rv;
     }
 
 }