Use device feature for scene action of type turn on/off light/switch

front/src/routes/scene/edit-scene/actions/TurnOnOffLightParams.jsx

@@ -4,6 +4,8 @@ import { Text } from 'preact-i18n';
 import Select from 'react-select';
 
 import { ACTIONS } from '../../../../../../server/utils/constants';
+import { getDeviceFeatureName } from '../../../../utils/device';
+import withIntlAsProp from '../../../../utils/withIntlAsProp';
 
 class TurnOnOffLight extends Component {
   getOptions = async () => {
@@ -12,32 +14,41 @@ class TurnOnOffLight extends Component {
         device_feature_category: 'light',
         device_feature_type: 'binary'
       });
-      const deviceOptions = devices.map(device => ({
-        value: device.selector,
-        label: device.name
-      }));
-      await this.setState({ deviceOptions });
+      // keep only write lights, not read only
+      const deviceFeatureOptions = [];
+      devices.forEach(device => {
+        device.features
+          .filter(deviceFeature => deviceFeature.read_only === false)
+          .map(deviceFeature => ({
+            value: deviceFeature.selector,
+            label: getDeviceFeatureName(this.props.intl.dictionary, device, deviceFeature)
+          }))
+          .forEach(deviceFeatureOption => deviceFeatureOptions.push(deviceFeatureOption));
+      });
+      await this.setState({ deviceFeatureOptions });
       this.refreshSelectedOptions(this.props);
-      return deviceOptions;
+      return deviceFeatureOptions;
     } catch (e) {
       console.error(e);
     }
   };
   handleChange = selectedOptions => {
     if (selectedOptions) {
       const lights = selectedOptions.map(selectedOption => selectedOption.value);
-      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'devices', lights);
+      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'device_features', lights);
     } else {
-      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'devices', []);
+      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'device_features', []);
     }
   };
   refreshSelectedOptions = nextProps => {
     const selectedOptions = [];
-    if (nextProps.action.devices && this.state.deviceOptions) {
-      nextProps.action.devices.forEach(light => {
-        const deviceOption = this.state.deviceOptions.find(deviceOption => deviceOption.value === light);
-        if (deviceOption) {
-          selectedOptions.push(deviceOption);
+    if (nextProps.action.device_features && this.state.deviceFeatureOptions) {
+      nextProps.action.device_features.forEach(light => {
+        const deviceFeatureOption = this.state.deviceFeatureOptions.find(
+          deviceFeatureOption => deviceFeatureOption.value === light
+        );
+        if (deviceFeatureOption) {
+          selectedOptions.push(deviceFeatureOption);
         }
       });
     }
@@ -46,7 +57,7 @@ class TurnOnOffLight extends Component {
   constructor(props) {
     super(props);
     this.state = {
-      deviceOptions: null,
+      deviceFeatureOptions: null,
       selectedOptions: []
     };
   }
@@ -58,7 +69,7 @@ class TurnOnOffLight extends Component {
     this.refreshSelectedOptions(nextProps);
   }
 
-  render(props, { selectedOptions, deviceOptions }) {
+  render(props, { selectedOptions, deviceFeatureOptions }) {
     return (
       <div class="form-group">
         <label class="form-label">
@@ -76,11 +87,11 @@ class TurnOnOffLight extends Component {
           isMulti
           value={selectedOptions}
           onChange={this.handleChange}
-          options={deviceOptions}
+          options={deviceFeatureOptions}
         />
       </div>
     );
   }
 }
 
-export default connect('httpClient', {})(TurnOnOffLight);
+export default withIntlAsProp(connect('httpClient', {})(TurnOnOffLight));

front/src/routes/scene/edit-scene/actions/TurnOnOffSwitchParams.jsx

@@ -4,6 +4,8 @@ import { Text } from 'preact-i18n';
 import Select from 'react-select';
 
 import { ACTIONS } from '../../../../../../server/utils/constants';
+import { getDeviceFeatureName } from '../../../../utils/device';
+import withIntlAsProp from '../../../../utils/withIntlAsProp';
 
 class TurnOnOffSwitch extends Component {
   getOptions = async () => {
@@ -13,36 +15,40 @@ class TurnOnOffSwitch extends Component {
         device_feature_type: 'binary'
       });
       // keep only write switches, not read only
-      const devicesFiltered = devices.filter(device => {
-        const writeSwitch = device.features.find(f => f.read_only === false);
-        return writeSwitch !== undefined;
+      const deviceFeatureOptions = [];
+      devices.forEach(device => {
+        device.features
+          .filter(deviceFeature => deviceFeature.read_only === false)
+          .map(deviceFeature => ({
+            value: deviceFeature.selector,
+            label: getDeviceFeatureName(this.props.intl.dictionary, device, deviceFeature)
+          }))
+          .forEach(deviceFeatureOption => deviceFeatureOptions.push(deviceFeatureOption));
       });
-      const deviceOptions = devicesFiltered.map(device => ({
-        value: device.selector,
-        label: device.name
-      }));
-      await this.setState({ deviceOptions });
+      await this.setState({ deviceFeatureOptions });
       this.refreshSelectedOptions(this.props);
-      return deviceOptions;
+      return deviceFeatureOptions;
     } catch (e) {
       console.error(e);
     }
   };
   handleChange = selectedOptions => {
     if (selectedOptions) {
       const switches = selectedOptions.map(selectedOption => selectedOption.value);
-      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'devices', switches);
+      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'device_features', switches);
     } else {
-      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'devices', []);
+      this.props.updateActionProperty(this.props.columnIndex, this.props.index, 'device_features', []);
     }
   };
   refreshSelectedOptions = nextProps => {
     const selectedOptions = [];
-    if (nextProps.action.devices && this.state.deviceOptions) {
-      nextProps.action.devices.forEach(switches => {
-        const deviceOption = this.state.deviceOptions.find(deviceOption => deviceOption.value === switches);
-        if (deviceOption) {
-          selectedOptions.push(deviceOption);
+    if (nextProps.action.device_features && this.state.deviceFeatureOptions) {
+      nextProps.action.device_features.forEach(switches => {
+        const deviceFeatureOption = this.state.deviceFeatureOptions.find(
+          deviceFeatureOption => deviceFeatureOption.value === switches
+        );
+        if (deviceFeatureOption) {
+          selectedOptions.push(deviceFeatureOption);
         }
       });
     }
@@ -51,7 +57,7 @@ class TurnOnOffSwitch extends Component {
   constructor(props) {
     super(props);
     this.state = {
-      deviceOptions: null,
+      deviceFeatureOptions: null,
       selectedOptions: []
     };
   }
@@ -63,7 +69,7 @@ class TurnOnOffSwitch extends Component {
     this.refreshSelectedOptions(nextProps);
   }
 
-  render(props, { selectedOptions, deviceOptions }) {
+  render(props, { selectedOptions, deviceFeatureOptions }) {
     return (
       <div class="form-group">
         <label class="form-label">
@@ -81,11 +87,11 @@ class TurnOnOffSwitch extends Component {
           isMulti
           value={selectedOptions}
           onChange={this.handleChange}
-          options={deviceOptions}
+          options={deviceFeatureOptions}
         />
       </div>
     );
   }
 }
 
-export default connect('httpClient', {})(TurnOnOffSwitch);
+export default withIntlAsProp(connect('httpClient', {})(TurnOnOffSwitch));

server/lib/scene/scene.actions.js

@@ -18,7 +18,7 @@ const get = require('get-value');
 const dayjs = require('dayjs');
 const utc = require('dayjs/plugin/utc');
 const timezone = require('dayjs/plugin/timezone');
-const { ACTIONS, DEVICE_FEATURE_CATEGORIES, DEVICE_FEATURE_TYPES } = require('../../utils/constants');
+const { ACTIONS } = require('../../utils/constants');
 const { getDeviceFeature } = require('../../utils/device');
 const { AbortScene } = require('../../utils/coreErrors');
 const { compare } = require('../../utils/compare');
@@ -64,90 +64,78 @@ const actionsFunc = {
     return self.device.setValue(device, deviceFeature, value);
   },
   [ACTIONS.LIGHT.TURN_ON]: async (self, action, scope) => {
-    await Promise.map(action.devices, async (deviceSelector) => {
+    await Promise.map(action.device_features, async (deviceFeatureSelector) => {
       try {
-        const device = self.stateManager.get('device', deviceSelector);
-        const deviceFeature = getDeviceFeature(
-          device,
-          DEVICE_FEATURE_CATEGORIES.LIGHT,
-          DEVICE_FEATURE_TYPES.LIGHT.BINARY,
-        );
-        await self.device.setValue(device, deviceFeature, 1);
+        const deviceFeature = self.stateManager.get('deviceFeature', deviceFeatureSelector);
+        if (deviceFeature) {
+          const device = self.stateManager.get('deviceById', deviceFeature.device_id);
+          await self.device.setValue(device, deviceFeature, 1);
+        }
       } catch (e) {
         logger.warn(e);
       }
     });
   },
   [ACTIONS.LIGHT.TURN_OFF]: async (self, action, scope) => {
-    await Promise.map(action.devices, async (deviceSelector) => {
+    await Promise.map(action.device_features, async (deviceFeatureSelector) => {
       try {
-        const device = self.stateManager.get('device', deviceSelector);
-        const deviceFeature = getDeviceFeature(
-          device,
-          DEVICE_FEATURE_CATEGORIES.LIGHT,
-          DEVICE_FEATURE_TYPES.LIGHT.BINARY,
-        );
-        await self.device.setValue(device, deviceFeature, 0);
+        const deviceFeature = self.stateManager.get('deviceFeature', deviceFeatureSelector);
+        if (deviceFeature) {
+          const device = self.stateManager.get('deviceById', deviceFeature.device_id);
+          await self.device.setValue(device, deviceFeature, 0);
+        }
       } catch (e) {
         logger.warn(e);
       }
     });
   },
   [ACTIONS.LIGHT.TOGGLE]: async (self, action, scope) => {
-    await Promise.map(action.devices, async (deviceSelector) => {
+    await Promise.map(action.device_features, async (deviceFeatureSelector) => {
       try {
-        const device = self.stateManager.get('device', deviceSelector);
-        const deviceFeature = getDeviceFeature(
-          device,
-          DEVICE_FEATURE_CATEGORIES.LIGHT,
-          DEVICE_FEATURE_TYPES.LIGHT.BINARY,
-        );
-        await self.device.setValue(device, deviceFeature, deviceFeature.last_value === 0 ? 1 : 0);
+        const deviceFeature = self.stateManager.get('deviceFeature', deviceFeatureSelector);
+        if (deviceFeature) {
+          const device = self.stateManager.get('deviceById', deviceFeature.device_id);
+          await self.device.setValue(device, deviceFeature, deviceFeature.last_value === 0 ? 1 : 0);
+        }
       } catch (e) {
         logger.warn(e);
       }
     });
   },
   [ACTIONS.SWITCH.TURN_ON]: async (self, action, scope) => {
-    await Promise.map(action.devices, async (deviceSelector) => {
+    await Promise.map(action.device_features, async (deviceFeatureSelector) => {
       try {
-        const device = self.stateManager.get('device', deviceSelector);
-        const deviceFeature = getDeviceFeature(
-          device,
-          DEVICE_FEATURE_CATEGORIES.SWITCH,
-          DEVICE_FEATURE_TYPES.SWITCH.BINARY,
-        );
-        await self.device.setValue(device, deviceFeature, 1);
+        const deviceFeature = self.stateManager.get('deviceFeature', deviceFeatureSelector);
+        if (deviceFeature) {
+          const device = self.stateManager.get('deviceById', deviceFeature.device_id);
+          await self.device.setValue(device, deviceFeature, 1);
+        }
       } catch (e) {
         logger.warn(e);
       }
     });
   },
   [ACTIONS.SWITCH.TURN_OFF]: async (self, action, scope) => {
-    await Promise.map(action.devices, async (deviceSelector) => {
+    await Promise.map(action.device_features, async (deviceFeatureSelector) => {
       try {
-        const device = self.stateManager.get('device', deviceSelector);
-        const deviceFeature = getDeviceFeature(
-          device,
-          DEVICE_FEATURE_CATEGORIES.SWITCH,
-          DEVICE_FEATURE_TYPES.SWITCH.BINARY,
-        );
-        await self.device.setValue(device, deviceFeature, 0);
+        const deviceFeature = self.stateManager.get('deviceFeature', deviceFeatureSelector);
+        if (deviceFeature) {
+          const device = self.stateManager.get('deviceById', deviceFeature.device_id);
+          await self.device.setValue(device, deviceFeature, 0);
+        }
       } catch (e) {
         logger.warn(e);
       }
     });
   },
   [ACTIONS.SWITCH.TOGGLE]: async (self, action, scope) => {
-    await Promise.map(action.devices, async (deviceSelector) => {
+    await Promise.map(action.device_features, async (deviceFeatureSelector) => {
       try {
-        const device = self.stateManager.get('device', deviceSelector);
-        const deviceFeature = getDeviceFeature(
-          device,
-          DEVICE_FEATURE_CATEGORIES.SWITCH,
-          DEVICE_FEATURE_TYPES.SWITCH.BINARY,
-        );
-        await self.device.setValue(device, deviceFeature, deviceFeature.last_value === 0 ? 1 : 0);
+        const deviceFeature = self.stateManager.get('deviceFeature', deviceFeatureSelector);
+        if (deviceFeature) {
+          const device = self.stateManager.get('deviceById', deviceFeature.device_id);
+          await self.device.setValue(device, deviceFeature, deviceFeature.last_value === 0 ? 1 : 0);
+        }
       } catch (e) {
         logger.warn(e);
       }