iobroker.zigbee 2.0.0 → 2.0.2

package/lib/exposes.js

@@ -1,11 +1,14 @@
 'use strict';
 
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
-const statesDefs = require('./states.js').states;
-const rgb = require('./rgb.js');
-const utils = require('./utils.js');
-const colors = require('./colors.js');
-const ea = require('zigbee-herdsman-converters/lib/exposes.js').access;
+const statesDefs = require('./states').states;
+const rgb = require('./rgb');
+const utils = require('./utils');
+const colors = require('./colors');
+const ea = require('zigbee-herdsman-converters/lib/exposes').access;
+
+
+const __logger = undefined;
 
 function genState(expose, role, name, desc) {
     let state;
@@ -16,6 +19,7 @@ function genState(expose, role, name, desc) {
     const stateId = stname.replace(/\*/g, '');
     const stateName = (desc || expose.description || expose.name);
     const propName = expose.property;
+    // 'switch' | 'lock' | 'binary' | 'list' | 'numeric' | 'enum' | 'text' | 'composite' | 'light' | 'cover' | 'fan' | 'climate';
     switch (expose.type) {
         case 'binary':
             state = {
@@ -133,7 +137,7 @@ function genState(expose, role, name, desc) {
     return state;
 }
 
-function createFromExposes(model, def) {
+function createFromExposes(model, def, device, log) {
     const states = [];
     // make the different (set and get) part of state is updatable if different exposes is used for get and set
     // as example:
@@ -252,15 +256,12 @@ function createFromExposes(model, def) {
     if (typeof def.exposes == 'object') {
         for (const expose of def.exposes) {
             genStateFromExpose(expose);
-
-
         }
     }
 
     // maybee here check manufacturerName for tuya devices
     if (typeof def.exposes == 'function') {
-        const expFunction = def.exposes(def, {});   // maybee here check manufacturerName for tuya devices
-
+        const expFunction = def.exposes(device, {});   // maybee here check manufacturerName for tuya devices
         for (const expose of expFunction) {
             genStateFromExpose(expose);
         }
@@ -275,12 +276,24 @@ function createFromExposes(model, def) {
 
     return newDev;
 
-
+    function hasMultipleProperties(obj, prop, len) {
+        const l = (len ? len: Object.keys.length(obj));
+        if (l != prop.length) return false;
+        for (const key of prop) {
+            if (!obj.hasOwnProperty(key)) return false;
+        }
+        return true;
+    };
 
     function genStateFromExpose(expose) {
         let state;
         switch (expose.type) {
-            case 'light':
+            case 'light': {
+                let hasColorXY = false;
+                let hasColorHS = false;
+                let colorXYprop = undefined;
+                let colorHSprop = undefined;
+
                 for (const prop of expose.features) {
                     switch (prop.name) {
                         case 'state': {
@@ -364,237 +377,14 @@ function createFromExposes(model, def) {
                             pushToStates(statesDefs.colortemp_move, prop.access);
                             break;
                         }
-                        case 'color_xy': {
-                            const stateNameC = expose.endpoint ? `color_${expose.endpoint}` : 'color';
-                            pushToStates({
-                                id: stateNameC,
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Color ${expose.endpoint ? expose.endpoint : ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.rgb',
-                                write: true,
-                                read: true,
-                                type: 'string',
-                                setter: value => {
-                                    // convert RGB to XY for set
-                                    /*
-                                    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(value);
-                                    let xy = [0, 0];
-                                    if (result) {
-                                        const r = parseInt(result[1], 16),
-                                            g = parseInt(result[2], 16),
-                                            b = parseInt(result[3], 16);
-                                        xy = rgb.rgb_to_cie(r, g, b);
-                                    }
-                                    return {
-                                        x: xy[0],
-                                        y: xy[1]
-                                    };
-        */
-                                    let xy = [0, 0];
-                                    const rgbcolor = colors.ParseColor(value);
-
-                                    xy = rgb.rgb_to_cie(rgbcolor.r, rgbcolor.g, rgbcolor.b);
-                                    return {
-                                        x: xy[0],
-                                        y: xy[1],
-                                    };
-                                },
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    return {...options, transition: transitionTime};
-                                },
-                                getter: payload => {
-                                    if (payload.color && payload.color.hasOwnProperty('x') && payload.color.hasOwnProperty('y')) {
-                                        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])}`;
-                                    } else {
-                                        return undefined;
-                                    }
-                                },
-                                epname: expose.endpoint,
-                                setattr: 'color',
-                            }, prop.access);
-                            break;
-                        }
+                        case 'color_xy':
+                            colorXYprop = prop;
+                            hasColorXY = true; break;
                         case 'color_hs': {
-                            const stateNameH = expose.endpoint ? `color_${expose.endpoint}` : 'color';
-                            pushToStates({
-                                id: stateNameH,
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Color ${expose.endpoint ? expose.endpoint : ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.rgb',
-                                write: true,
-                                read: true,
-                                type: 'string',
-                                setter: value => {
-                                    const _rgb = colors.ParseColor(value);
-                                    const hsv = rgb.rgbToHSV(_rgb.r, _rgb.g, _rgb.b, true);
-                                    return {
-                                        hue: Math.min(Math.max(hsv.h, 1), 359),
-                                        saturation: hsv.s,
-                                        //                                        brightness: Math.floor(hsv.v * 2.55),
-                                    };
-                                },
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    return {...options, transition: transitionTime};
-                                },
-                                epname: expose.endpoint,
-                                setattr: 'color',
-                            }, prop.access);
-                            pushToStates({
-                                id: expose.endpoint ? `hue_${expose.endpoint}` : 'hue',
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Hue ${expose.endpoint || ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.hue',
-                                write: true,
-                                read: false,
-                                type: 'number',
-                                min: 0,
-                                max: 360,
-                                inOptions: true,
-                                setter: (value, options) => {
-                                    return {
-                                        hue: value,
-                                        saturation: options.saturation,
-                                    };
-                                },
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    const hasHueCalibrationTable = options && options.hasOwnProperty('hue_calibration');
-                                    if (hasHueCalibrationTable)
-                                        try {
-                                            return {
-                                                ...options,
-                                                transition: transitionTime,
-                                                hue_correction: JSON.parse(options.hue_calibration)
-                                            };
-                                        } catch {
-                                            const hue_correction_table = [];
-                                            options.hue_calibration.split(',').forEach(element => {
-                                                const match = /([0-9]+):([0-9]+)/.exec(element);
-                                                if (match && match.length === 3)
-                                                    hue_correction_table.push({
-                                                        in: Number(match[1]),
-                                                        out: Number(match[2])
-                                                    });
-                                            });
-                                            if (hue_correction_table.length > 0) {
-                                                return {
-                                                    ...options,
-                                                    transition: transitionTime,
-                                                    hue_correction: hue_correction_table
-                                                };
-                                            }
-                                        }
-                                    return {...options, transition: transitionTime};
-                                },
-
-                            }, prop.access);
-                            pushToStates({
-                                id: expose.endpoint ? `saturation_${expose.endpoint}` : 'saturation',
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Saturation ${expose.endpoint ? expose.endpoint : ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.saturation',
-                                write: true,
-                                read: false,
-                                type: 'number',
-                                min: 0,
-                                max: 100,
-                                inOptions: true,
-                                setter: (value, options) => ({
-                                    hue: options.hue,
-                                    saturation: value,
-                                }),
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    const hasHueCalibrationTable = options && options.hasOwnProperty('hue_calibration');
-                                    if (hasHueCalibrationTable)
-                                        try {
-                                            return {
-                                                ...options,
-                                                transition: transitionTime,
-                                                hue_correction: JSON.parse(options.hue_calibration)
-                                            };
-                                        } catch {
-                                            const hue_correction_table = [];
-                                            options.hue_calibration.split(',').forEach(element => {
-                                                const match = /([0-9]+):([0-9]+)/.exec(element);
-                                                if (match && match.length === 3)
-                                                    hue_correction_table.push({
-                                                        in: Number(match[1]),
-                                                        out: Number(match[2])
-                                                    });
-                                            });
-                                            if (hue_correction_table.length > 0) {
-                                                return {
-                                                    ...options,
-                                                    transition: transitionTime,
-                                                    hue_correction: hue_correction_table
-                                                };
-                                            }
-                                        }
-                                    return {...options, transition: transitionTime};
-                                },
-
-                            }, prop.access);
+                            colorHSprop = prop;
+                            hasColorHS = true;
                             pushToStates(statesDefs.hue_move, prop.access);
                             pushToStates(statesDefs.saturation_move, prop.access);
-                            pushToStates({
-                                id: 'hue_calibration',
-                                prop: 'color',
-                                name: 'Hue color calibration table',
-                                icon: undefined,
-                                role: 'table',
-                                write: true,
-                                read: false,
-                                type: 'string',
-                                inOptions: true,
-                                setter: (value, options) => ({
-                                    hue: options.hue,
-                                    saturation: options.saturation,
-                                }),
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    const hasHueCalibrationTable = options && options.hasOwnProperty('hue_calibration');
-                                    if (hasHueCalibrationTable)
-                                        try {
-                                            return {
-                                                ...options,
-                                                transition: transitionTime,
-                                                hue_correction: JSON.parse(options.hue_calibration)
-                                            };
-                                        } catch {
-                                            const hue_correction_table = [];
-                                            options.hue_calibration.split(',').forEach(element => {
-                                                const match = /([0-9]+):([0-9]+)/.exec(element);
-                                                if (match && match.length === 3) {
-                                                    hue_correction_table.push({
-                                                        in: Number(match[1]),
-                                                        out: Number(match[2])
-                                                    });
-                                                }
-                                            });
-                                            if (hue_correction_table.length > 0) {
-                                                return {
-                                                    ...options,
-                                                    transition: transitionTime,
-                                                    hue_correction: hue_correction_table
-                                                };
-                                            }
-                                        }
-                                    return {...options, transition: transitionTime};
-                                },
-                            }, prop.access);
                             break;
                         }
                         default:
@@ -602,9 +392,181 @@ function createFromExposes(model, def) {
                             break;
                     }
                 }
+                if (hasColorXY || hasColorHS) {
+                    const nameWithEp = expose.endpoint ? `color_${expose.endpoint}` : 'color';
+                    pushToStates({
+                        id: nameWithEp,
+                        name: `Color ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                        icon: undefined,
+                        role: 'level.color.rgb',
+                        write: true,
+                        read: true,
+                        type: 'string',
+                        setter: value => {
+                            try {
+                                // JSON
+                                const colorJSON = JSON.parse(value.replaceAll("'",'"'));
+                                const numProp = Object.keys(colorJSON).length;
+                                if (hasMultipleProperties(colorJSON, ['hsb'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hsl'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hsv'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['h','s','b'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['h','s','v'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['h','s','l'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hue', 'saturation'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hex'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['rgb'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['x', 'y'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['r', 'g', 'b'], numProp)) return colorJSON;
+                                //return { json:colorJSON, numProp:numProp, value:value };
+                            }
+                            catch (error) {
+                                //return { error: error.message };
+                            };
+                            // hex or named color
+                            const rgbcolor = colors.ParseColor(value);
+                            return rgbcolor;
+                        },
+                        setterOpt: (value, options) => {
+                            const hasTransitionTime = options && options.hasOwnProperty('transition_time');
+                            const transitionTime = hasTransitionTime ? options.transition_time : 0;
+                            return {...options, transition: transitionTime};
+                        },
+                        getter: payload => {
+                            if (typeof payload.color == 'object') {
+                                const colorJSON = payload.color;
+                                const color = JSON.stringify(colorJSON)
+                                const numProp = Object.keys(colorJSON);
+                                if (hasMultipleProperties(colorJSON, ['hsb'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hsl'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hsv'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','b'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','v'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','l'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hue', 'saturation'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hex'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['rgb'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['x', 'y'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['r', 'g', 'b'], numProp)) return color;
+                            }
+                            return undefined;
+                        },
+                        epname: expose.endpoint,
+                        setattr: 'color',
+                    }, (colorHSprop ? colorHSprop.access : colorXYprop.access));
+                    if (hasColorXY) {
+                        let channelWithEp = expose.endpoint ? `color_xy_${expose.endpoint}` : 'color_xy';
+                        pushToStates({
+                            id: `${channelWithEp}.x`,
+                            name: `X`,
+                            icon: undefined,
+                            role: 'level.color',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 1,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorXYprop.access);
+                        pushToStates({
+                            id: `${channelWithEp}.y`,
+                            name: `Y`,
+                            icon: undefined,
+                            role: 'level.color',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 1,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorXYprop.access);
+                        channelWithEp = expose.endpoint ? `color_rgb_${expose.endpoint}` : 'color_rgb';
+                        pushToStates({
+                            id: `${channelWithEp}.r`,
+                            name: `Red`,
+                            icon: undefined,
+                            role: 'level.color.red',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 255,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color',
+                            composites: [`${channelWithEp}.r`,`${channelWithEp}.g`]
+                        }, colorXYprop.access);
+                        pushToStates({
+                            id: `${channelWithEp}.g`,
+                            name: `Green`,
+                            icon: undefined,
+                            role: 'level.color.green',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 255,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color',
+                            composites: [`${channelWithEp}.x`,`${channelWithEp}.y`]
+                        });
+                        pushToStates({
+                            id: `${channelWithEp}.b`,
+                            name: `Blue`,
+                            icon: undefined,
+                            role: 'level.color.blue',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 255,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorXYprop.access);
+                    }
+                    if (hasColorHS) {
+                        const channelWithEp = expose.endpoint ? `color_hs_${expose.endpoint}` : 'color_hs';
+                        pushToStates({
+                            id: `${channelWithEp}.hue`,
+                            name: `Hue`,
+                            icon: undefined,
+                            role: 'level.color.hue',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 360,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorHSprop.access);
+                        pushToStates({
+                            id: `${channelWithEp}.saturation`,
+                            name: `Saturation`,
+                            icon: undefined,
+                            role: 'level.color',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 100,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorHSprop.access);
+
+                    }
+                }
+
                 pushToStates(statesDefs.transition_time, ea.STATE_SET);
                 break;
-
+            }
             case 'switch':
                 for (const prop of expose.features) {
                     switch (prop.name) {
@@ -671,25 +633,33 @@ function createFromExposes(model, def) {
 
             case 'enum':
                 switch (expose.name) {
+
                     case 'action': {
                         // Ansatz:
-
-                        // Action aufspalten in 2 Blöcke:
-                        // Action (bekommt text ausser hold und release, auto reset nach 250 ms)
-                        // Hold: wird gesetzt bei hold, gelöscht bei passendem Release
+                        //generate an 'action' state\
+                        state = genState(expose);
+                        state.isEvent = true;
+                        pushToStates(state, expose.access);
 
                         if (!Array.isArray(expose.values)) break;
-                        const hasHold = expose.values.find((actionName) => actionName.includes('hold'));
-                        const hasRelease = expose.values.find((actionName) => actionName.includes('release'));
-                        const hasPress = expose.values.find((actionName) => actionName.includes('press'));
-                        const hasPressRelease = expose.values.find((actionName) => actionName.includes('press_release'));
+                        // identify hold/release pairs
+                        // if pairs of (prefix)press(postfix) and (prefix)release(postfix) or
+                        //              (prefix)hold(postfix) and (prefix)release(postfix)
+                        // exist, the release action will not get its own state. Instead, the
+                        // respective press or hold state will not be an event and be cleared at release time
+                        //
+                        const phr = {};
+                        const phc = expose.values.filter((actionName) => actionName.match(/hold|press/gm));
+                        for (const actionName of phc) {
+                            const releasestr = actionName.replace(/hold|press/gm, 'release');
+                            const release = expose.values.find((actionName) => actionName == releasestr);
+                            phr[actionName]=release;
+                            if (release) phr[release]= 'IGNORE';
+                        }
                         for (const actionName of expose.values) {
-                            // is release state ? - skip
-                            if (hasHold && hasRelease && actionName.includes('release')) continue;
-                            // is hold state ?
-                            if (hasHold && hasRelease && actionName.includes('hold')) {
-                                const releaseActionName = actionName.replace('hold', 'release');
-                                const releaseActionName2 = actionName.concat('_release');
+                            const release = phr[actionName];
+                            if (release === 'IGNORE') continue // a release message for which a press or hold exists.
+                            if (release) { // a press or hold state with a matching release state
                                 state = {
                                     id: actionName.replace(/\*/g, ''),
                                     prop: 'action',
@@ -699,25 +669,10 @@ function createFromExposes(model, def) {
                                     write: false,
                                     read: true,
                                     type: 'boolean',
-                                    getter: payload => payload.action === actionName ? true : (payload.action === releaseActionName || payload.action === releaseActionName2 ? false : undefined),
-                                };
-                            } else if (hasPress && hasPressRelease && actionName.includes('press')) {
-                                let getterKey = actionName.concat('_release');
-                                if (expose.values.indexOf(getterKey) < 0) getterKey = actionName;
-                                state = {
-                                    id: actionName.replace(/\*/g, ''),
-                                    prop: 'action',
-                                    name: actionName,
-                                    icon: undefined,
-                                    role: 'button',
-                                    write: false,
-                                    read: true,
-                                    type: 'boolean',
-                                    getter: payload => payload.action === getterKey ? true : undefined,
-                                    isEvent: true,
+                                    getter: payload => payload.action === actionName ? true : (payload.action === release ? false : undefined),
                                 };
                             } else {
-			        			state = {
+                                state = {
                                     id: actionName.replace(/\*/g, ''),
                                     prop: 'action',
                                     name: actionName,
@@ -911,16 +866,15 @@ function createFromExposes(model, def) {
     }
 
 }
-function applyExposes(mappedDevices, byModel, allExcludesObj) {
-    // for exclude search
-    const allExcludesStr = JSON.stringify(allExcludesObj);
-    // create or update device from exposes
+
+function applyExposes(mappedDevices, byModel) {
+    // create or device from exposes
     for (const deviceDef of zigbeeHerdsmanConverters.definitions) {
-        applyDeviceDef(mappedDevices, byModel, allExcludesStr, deviceDef);
+        applyDeviceDef(mappedDevices, byModel, deviceDef);
 
         if (deviceDef.hasOwnProperty('whiteLabel')) {
             for (const deviceWhiteLabel of deviceDef.whiteLabel) {
-                applyDeviceDef(mappedDevices, byModel, allExcludesStr, {
+                applyDeviceDef(mappedDevices, byModel, {
                     ...deviceDef,
                     model: deviceWhiteLabel.model,
                     vendor: deviceWhiteLabel.vendor,
@@ -931,26 +885,29 @@ function applyExposes(mappedDevices, byModel, allExcludesObj) {
     }
 }
 
-function applyDeviceDef(mappedDevices, byModel, allExcludesStr, deviceDef) {
+async function applyExposeForDevice(mappedDevices, byModel, device) {
+    const deviceDef = await zigbeeHerdsmanConverters.findByDevice(device);
+    if (!deviceDef) return false;
+    applyDeviceDef(mappedDevices, byModel, deviceDef, device);
+    return true;
+}
+
+function applyDeviceDef(mappedDevices, byModel, deviceDef, device) {
     const stripModel = utils.getModelRegEx(deviceDef.model);
     const existsMap = byModel.get(stripModel);
-
-    if ((deviceDef.hasOwnProperty('exposes') && (!existsMap || !existsMap.hasOwnProperty('states'))) || allExcludesStr.indexOf(stripModel) > 0) {
+    if (deviceDef.hasOwnProperty('exposes') && (!existsMap || !existsMap.hasOwnProperty('states'))) {
         try {
-            const newDevice = createFromExposes(stripModel, deviceDef);
-            if (!existsMap) {
-                mappedDevices.push(newDevice);
-                byModel.set(stripModel, newDevice);
-            } else {
-                existsMap.states = newDevice.states;
-                existsMap.exposed = true;
-            }
+            const newDevice = createFromExposes(stripModel, deviceDef, device);
+            mappedDevices.push(newDevice);
+            byModel.set(stripModel, newDevice);
+
         } catch (e) {
-            console.log(`Wrong expose device definition ${deviceDef.vendor} ${stripModel}`);
+            //this.debug('empty catch in exposes');
         }
     }
 }
 
 module.exports = {
     applyExposes: applyExposes,
+    applyExposeForDevice: applyExposeForDevice,
 };