iobroker.zigbee2mqtt 3.0.20 → 3.1.1

package/lib/deviceController.js

@@ -33,8 +33,17 @@ class DeviceController {
      * @param devicesMessage
      */
     async createDeviceDefinitions(devicesMessage) {
+        // Fix 1: devicesMessage kann null/kein Array sein (z.B. leerer bridge/devices payload)
+        if (!Array.isArray(devicesMessage)) {
+            this.adapter.log.warn('createDeviceDefinitions: payload ist kein Array');
+            return;
+        }
         utils.clearArray(this.deviceCache);
         for (const devicesMessag of devicesMessage) {
+            if (!devicesMessag || !devicesMessag.ieee_address) {
+                continue;
+            }
+
             if (this.logCustomizations.debugDevices.includes(devicesMessag.ieee_address)) {
                 this.adapter.log.warn(
                     `--->>> fromZ2M -> ${devicesMessag.ieee_address} exposes: ${JSON.stringify(devicesMessag)}`
@@ -42,16 +51,17 @@ class DeviceController {
             }
 
             if (devicesMessag.definition != null) {
-                // if the device is already present in the cache, remove it
                 this.removeDeviceByIeee(this.deviceCache, devicesMessag.ieee_address);
 
-                if (devicesMessag.definition.exposes) {
+                // Fix 3: exposes muss auch ein Array sein
+                if (Array.isArray(devicesMessag.definition.exposes)) {
                     try {
                         const newDevice = await createDeviceFromExposes(devicesMessag, this.adapter);
                         newDevice.icon = await this.imageController.getDeviceIcon(devicesMessag);
                         this.deviceCache.push(newDevice);
                     } catch (err) {
-                        this.adapter.log.warn(`Cannot ${devicesMessag.friendly_name} create Device from Exposes!`);
+                        // Fix 2: friendly_name im Fehlerlog verwenden
+                        this.adapter.log.warn(`Cannot create Device from Exposes for ${devicesMessag.friendly_name || devicesMessag.ieee_address}!`);
                         this.adapter.log.debug(JSON.stringify(devicesMessag));
                         this.adapter.log.debug(err);
                     }
@@ -67,23 +77,22 @@ class DeviceController {
      * @param scenes
      */
     async defineGroupDevice(groupID, ieee_address, scenes) {
-        const brmPropName =
-			this.adapter.config.brightnessMoveOnOff == true ? 'brightness_move_onoff' : 'brightness_move';
-        const brsPropName =
-			this.adapter.config.brightnessStepOnOff == true ? 'brightness_step_onoff' : 'brightness_step';
+        const brmPropName = this.adapter.config.brightnessMoveOnOff === true ? 'brightness_move_onoff' : 'brightness_move';
+        const brsPropName = this.adapter.config.brightnessStepOnOff === true ? 'brightness_step_onoff' : 'brightness_step';
         const newDevice = {
             id: groupID,
             ieee_address: ieee_address,
             icon: undefined, //  await imageController.getDeviceIcon(devicesMessag), device.definition.model
             optionsValues: {},
             states: [
-                statesDefs.available,
-                statesDefs.brightness,
-                statesDefs.colortemp_move,
-                statesDefs.transition,
+                // Fix 1: Klone aller statesDefs-Objekte – sonst werden geteilte Referenzen mutiert
+                Object.assign({}, statesDefs.available),
+                Object.assign({}, statesDefs.brightness),
+                Object.assign({}, statesDefs.colortemp_move),
+                Object.assign({}, statesDefs.transition),
                 {
                     id: 'state',
-                    prob: 'state',
+                    prop: 'state',
                     name: 'Switch state',
                     options: ['transition'],
                     icon: undefined,
@@ -133,29 +142,28 @@ class DeviceController {
                     type: 'string',
                     def: '#ff00ff',
                     setter: (value) => {
-                        let xy = [0, 0];
+                        // Fix 6: redundante [0,0]-Initialisierung entfernt
                         const rgbcolor = colors.ParseColor(value);
-                        xy = rgb.rgb_to_cie(rgbcolor.r, rgbcolor.g, rgbcolor.b);
+                        const xy = rgb.rgb_to_cie(rgbcolor.r, rgbcolor.g, rgbcolor.b);
                         return {
                             x: xy[0],
                             y: xy[1],
                         };
                     },
                     getter: (payload) => {
-                        if (payload.color_mode != 'xy' && this.config.colorTempSyncColor == false) {
+                        if (payload.color_mode !== 'xy' && !this.config.colorTempSyncColor) {
                             return undefined;
                         }
-                        if (payload.color && payload.color.x && payload.color.y) {
+                        // Fix 2: x=0 / y=0 sind gültige CIE-Koordinaten → != null statt truthy
+                        if (payload.color && payload.color.x != null && payload.color.y != null) {
                             const colorval = rgb.cie_to_rgb(payload.color.x, payload.color.y);
                             return (
-                                `#${ 
-								utils.decimalToHex(colorval[0]) 
-								}${utils.decimalToHex(colorval[1]) 
-								}${utils.decimalToHex(colorval[2])}`
+                                `#${utils.decimalToHex(colorval[0])
+                                }${utils.decimalToHex(colorval[1])
+                                }${utils.decimalToHex(colorval[2])}`
                             );
-                        } 
-                            return undefined;
-                        
+                        }
+                        return undefined;
                     },
                 },
                 {
@@ -168,22 +176,21 @@ class DeviceController {
                     write: true,
                     read: true,
                     type: 'number',
-                    min: this.config.useKelvin == true ? utils.miredKelvinConversion(550) : 150,
-                    max: this.config.useKelvin == true ? utils.miredKelvinConversion(153) : 500,
-                    def: this.config.useKelvin == true ? utils.miredKelvinConversion(153) : 500,
-                    unit: this.config.useKelvin == true ? 'K' : 'mired',
+                    min: this.config.useKelvin === true ? utils.miredKelvinConversion(550) : 150,
+                    max: this.config.useKelvin === true ? utils.miredKelvinConversion(153) : 500,
+                    def: this.config.useKelvin === true ? utils.miredKelvinConversion(153) : 500,
+                    unit: this.config.useKelvin === true ? 'K' : 'mired',
                     setter: (value) => {
                         return utils.toMired(value);
                     },
                     getter: (payload) => {
-                        if (payload.color_mode != 'color_temp') {
+                        if (payload.color_mode !== 'color_temp') {
                             return undefined;
                         }
-                        if (this.config.useKelvin == true) {
+                        if (this.config.useKelvin === true) {
                             return utils.miredKelvinConversion(payload.color_temp);
-                        } 
-                            return payload.color_temp;
-                        
+                        }
+                        return payload.color_temp;
                     },
                 },
                 {
@@ -248,12 +255,21 @@ class DeviceController {
      * @param groupsMessage
      */
     async createGroupDefinitions(groupsMessage) {
+        // Fix 4: groupsMessage kann null/kein Array sein
+        if (!Array.isArray(groupsMessage)) {
+            this.adapter.log.warn('createGroupDefinitions: payload ist kein Array');
+            return;
+        }
         utils.clearArray(this.groupCache);
         for (const groupMessage of groupsMessage) {
-            if (this.logCustomizations.debugDevices.includes(groupMessage.id)) {
+            // Fix 5: fehlende Pflichtfelder abfangen
+            if (!groupMessage || groupMessage.id == null || !groupMessage.friendly_name) {
+                continue;
+            }
+            if (this.logCustomizations.debugDevices.includes(String(groupMessage.id))) {
                 this.adapter.log.warn(`--->>> fromZ2M -> ${groupMessage.id} exposes: ${JSON.stringify(groupMessage)}`);
             }
-            await this.defineGroupDevice(groupMessage.friendly_name, `group_${groupMessage.id}`, groupMessage.scenes);
+            await this.defineGroupDevice(groupMessage.friendly_name, `group_${groupMessage.id}`, groupMessage.scenes || []);
         }
     }
 
@@ -261,144 +277,158 @@ class DeviceController {
      *
      */
     async createOrUpdateDevices() {
-        for (const device of this.groupCache.concat(this.deviceCache)) {
-            let deviceName = await this.getDeviceName(device);
-            let description = await this.getDeviceDescription(device);
+        // Gruppen und Geräte getrennt verarbeiten
+        for (const device of this.groupCache) {
+            await this._createOrUpdateSingleDevice(device, true);
+        }
+        for (const device of this.deviceCache) {
+            await this._createOrUpdateSingleDevice(device, false);
+        }
+    }
 
-            if (deviceName == '' && device.description) {
-                deviceName = device.description;
-                description = '';
-            }
+    /**
+     * @param device
+     * @param isGroup
+     */
+    async _createOrUpdateSingleDevice(device, isGroup) {
+        let deviceName = await this.getDeviceName(device);
+        let description = await this.getDeviceDescription(device);
 
-            // Manipulate deviceName if the device is disabled, so the update of the device is triggered as well
-            if (device.disabled && device.disabled == true) {
-                if (this.config.useEventInDesc == true) {
-                    description = 'Device is disabled!';
-                } else {
-                    deviceName = `[Disabled] ${deviceName}`;
-                }
+        if (deviceName === '' && device.description) {
+            deviceName = device.description;
+            description = '';
+        }
+
+        // Disabled-Flag nur bei echten Geräten – Gruppen können nicht disabled sein
+        if (!isGroup && device.disabled === true) {
+            if (this.config.useEventInDesc === true) {
+                description = 'Device is disabled!';
+            } else {
+                deviceName = `[Disabled] ${deviceName}`;
             }
+        }
 
-            if (!this.createCache[device.ieee_address] || this.createCache[device.ieee_address].name != deviceName || this.createCache[device.ieee_address].description != description) {
-                const deviceObj = {
-                    type: 'device',
-                    common: {
-                        icon: device.icon,
-                        name: deviceName,
-                        desc: description,
-                        statusStates: { onlineId: '' },
-                    },
-                    native: {
-                        deviceRemoved: false,
-                        groupDevice: false,
-                    },
-                };
+        if (!this.createCache[device.ieee_address] ||
+            this.createCache[device.ieee_address].name !== deviceName ||
+            this.createCache[device.ieee_address].description !== description) {
 
-                // Group Device
-                if (device.ieee_address.includes('group_')) {
-                    deviceObj.native.groupDevice = true;
-                    deviceObj.common.statusStates.onlineId = `${this.adapter.name}.${this.adapter.instance}.${device.ieee_address}.available`;
-                }
-                // Disabled Device
-                else if (device.disabled || device.disabled == true) {
-                    // Placeholder for possible later logic
-                }
-                // Only the onlineId is set if the device is not disabled
-                else {
-                    deviceObj.common.statusStates.onlineId = `${this.adapter.name}.${this.adapter.instance}.${device.ieee_address}.available`;
-                }               
-                await this.adapter.extendObjectAsync(device.ieee_address, deviceObj);
-                this.createCache[device.ieee_address] = { name: deviceName, description: description };
-            }
+            const deviceObj = {
+                type: 'device',
+                common: {
+                    icon: device.icon,
+                    name: deviceName,
+                    desc: description,
+                    statusStates: { onlineId: '' },
+                },
+                native: {
+                    deviceRemoved: false,
+                    groupDevice: isGroup,
+                },
+            };
 
-            // Here it is checked whether the scenes match the current data from z2m.
-            // If necessary, scenes are automatically deleted from ioBroker.
-            const sceneStates = await this.adapter.getStatesAsync(`${device.ieee_address}.scene_*`);
-            const sceneIDs = Object.keys(sceneStates);
-            for (const sceneID of sceneIDs) {
-                const stateID = sceneID.split('.')[3];
-                if (device.states.find((x) => x.id == stateID) == null) {
-                    this.adapter.delObject(sceneID);
-                }
+            if (isGroup || device.disabled !== true) {
+                deviceObj.common.statusStates.onlineId = `${this.adapter.name}.${this.adapter.instance}.${device.ieee_address}.available`;
             }
 
-            if (device != undefined && device.states != undefined) {
-                for (const state of device.states) {
-                    if (state && (!this.createCache[device.ieee_address][state.id] || this.createCache[device.ieee_address][state.id].name != state.name)) {
-                        const iobState = {
-                            type: 'state',
-                            common: await this.copyAndCleanStateObj(state),
-                            native: {},
-                        };
+            await this.adapter.extendObjectAsync(device.ieee_address, deviceObj);
+            this.createCache[device.ieee_address] = { name: deviceName, description: description };
+        }
 
-                        await this.adapter.extendObjectAsync(`${device.ieee_address}.${state.id}`, iobState);
-                        this.createCache[device.ieee_address][state.id] = {name: state.name, created: true};
-                    }
+        if (!Array.isArray(device.states)) {
+            return;
+        }
+
+        // Veraltete scene_*-States bereinigen – getForeignObjectsAsync mit vollem Namespace-Pfad
+        const sceneObjects = await this.adapter.getForeignObjectsAsync(
+            `${this.adapter.namespace}.${device.ieee_address}.scene_*`
+        );
+        if (sceneObjects) {
+            for (const sceneObjId of Object.keys(sceneObjects)) {
+                const parts = sceneObjId.split('.');
+                const stateID = parts[parts.length - 1];
+                if (!device.states.find((x) => x.id === stateID)) {
+                    await this.adapter.delForeignObjectAsync(sceneObjId);
                 }
             }
         }
-    }
 
-    /**
-     *
-     * @param messageObj
-     */
-    async renameDeviceInCache(messageObj) {
-        const renamedDevice = this.groupCache
-            .concat(this.deviceCache)
-            .find((x) => x.id == messageObj.payload.data.from);
-        if (renamedDevice) {
-            renamedDevice.id = messageObj.payload.data.to;
+        for (const state of device.states) {
+            if (state && (!this.createCache[device.ieee_address][state.id] ||
+                this.createCache[device.ieee_address][state.id].name !== state.name)) {
+
+                const iobState = {
+                    type: 'state',
+                    common: await this.copyAndCleanStateObj(state),
+                    native: {},
+                };
+
+                await this.adapter.extendObjectAsync(`${device.ieee_address}.${state.id}`, iobState);
+                this.createCache[device.ieee_address][state.id] = { name: state.name, created: true };
+            }
         }
     }
 
     /**
-     *
+     * Nur echte Geräte prüfen – Gruppen werden hier nie verarbeitet
      */
     async checkAndProgressDeviceRemove() {
-        let description = '';
-        let deviceName = '';
         let iobDevices = await this.adapter.getDevicesAsync();
-        // Do not consider devices already marked as "deviceRemoved"
-        iobDevices = iobDevices.filter((x) => x.native.deviceRemoved == false);
-        // Do not consider groups
-        iobDevices = iobDevices.filter((x) => x.native.groupDevice == false);
+        // Nur nicht-entfernte, echte Geräte (keine Gruppen)
+        iobDevices = iobDevices.filter((x) => x.native && x.native.deviceRemoved === false);
+        iobDevices = iobDevices.filter((x) => x.native && x.native.groupDevice === false);
 
         for (const iobDevice of iobDevices) {
-            const ieee_address = iobDevice._id.split('.')[2];
-            //Check whether the devices found from the object tree are also available in the DeviceCache
-            if (!this.deviceCache.find((x) => x.ieee_address == ieee_address)) {
-                deviceName = iobDevice.common.name;
+            const idParts = iobDevice._id.split('.');
+            if (idParts.length < 3) {continue;}
+            const ieee_address = idParts[2];
 
-                if (this.config.useEventInDesc == true) {
+            // Gruppen-Einträge im ioBroker-Baum explizit überspringen
+            if (ieee_address.startsWith('group_')) {continue;}
+
+            if (!this.deviceCache.find((x) => x.ieee_address === ieee_address)) {
+                let deviceName = iobDevice.common && iobDevice.common.name ? iobDevice.common.name : ieee_address;
+                let description = '';
+
+                if (this.config.useEventInDesc === true) {
                     description = 'Device was removed!';
                 } else {
                     deviceName = `[Removed] ${deviceName}`;
                 }
 
-                this.adapter.extendObject(`${ieee_address}`, {
-                    common: {
-                        name: deviceName,
-                        desc: description,
-                    },
-                    native: {
-                        deviceRemoved: true,
-                    },
+                await this.adapter.extendObjectAsync(ieee_address, {
+                    common: { name: deviceName, desc: description },
+                    native: { deviceRemoved: true },
                 });
-                this.adapter.setStateChangedAsync(`${ieee_address}.available`, false, true);
+                await this.adapter.setStateChangedAsync(`${ieee_address}.available`, false, true);
 
                 delete this.createCache[ieee_address];
             }
         }
     }
 
+    /**
+     *
+     * @param messageObj
+     */
+    async renameDeviceInCache(messageObj) {
+        if (!messageObj.payload || !messageObj.payload.data) {
+            return;
+        }
+        const renamedDevice = this.groupCache
+            .concat(this.deviceCache)
+            .find((x) => x.id === messageObj.payload.data.from);
+        if (renamedDevice) {
+            renamedDevice.id = messageObj.payload.data.to;
+        }
+    }
+
     /**
      *
      * @param devices
      * @param ieee_address
      */
     removeDeviceByIeee(devices, ieee_address) {
-        const idx = devices.findIndex((x) => x.ieee_address == ieee_address);
+        const idx = devices.findIndex((x) => x.ieee_address === ieee_address);
         if (idx > -1) {
             devices.splice(idx, 1);
         }
@@ -434,7 +464,7 @@ class DeviceController {
      * @param device
      */
     getDeviceName(device) {
-        return device.id == device.ieee_address ? '' : device.id;
+        return device.id === device.ieee_address ? '' : device.id;
     }
 
     /**
@@ -456,7 +486,11 @@ class DeviceController {
             this.adapter.setState('info.missing_routers_count', missingRoutersCount, true);
 
             if (missingRoutersCount > 0) {
-                this.adapter.log[this.config.coordinatorCheckLogLvl](
+                const logLvl = this.config.coordinatorCheckLogLvl;
+                const logFn = (logLvl && typeof this.adapter.log[logLvl] === 'function')
+                    ? this.adapter.log[logLvl].bind(this.adapter.log)
+                    : this.adapter.log.warn.bind(this.adapter.log);
+                logFn(
                     `Coordinator check: ${missingRoutersCount} missing routers were found, please check the data point 'zigbee2mqtt.x.info.missing_routers'!`
                 );
             } else {