@eohjsc/react-native-smart-city 0.4.54 → 0.4.56

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eohjsc/react-native-smart-city",
   "title": "React Native Smart Home",
-  "version": "0.4.54",
+  "version": "0.4.56",
   "description": "TODO",
   "main": "index.js",
   "files": [

package/src/commons/Action/ItemQuickAction.js

@@ -58,7 +58,7 @@ const ItemQuickAction = memo(
 
     const userId = useSCContextSelector((state) => state?.auth.account.user.id);
     const onActionPress = useCallback(async () => {
-      if (processing) {
+      if (processing || !action) {
         /* istanbul ignore next */
         return;
       }
@@ -98,10 +98,6 @@ const ItemQuickAction = memo(
       on_action?.id,
     ]);
 
-    if (!action) {
-      return <View />;
-    }
-
     return (
       <TouchableOpacity
         accessibilityLabel={`${AccessibilityLabel.ITEM_QUICK_ACTION_PRESS}-${sensor?.id}`}

package/src/commons/Action/__test__/ItemQuickAction.test.js

@@ -7,6 +7,7 @@ import { AccessibilityLabel } from '../../../configs/Constants';
 import { factory } from 'factory-girl';
 import IconComponent from '../../IconComponent';
 import { IconOutline } from '@ant-design/icons-react-native';
+import Toast from 'react-native-toast-message';
 
 class Sensor {}
 
@@ -67,13 +68,16 @@ describe('Test ItemQuickAction', () => {
       tree = await create(<ItemQuickAction sensor={newSensor} />);
     });
     const instance = tree.root;
-    const buttonOnActionPress = instance.findAll(
+    const buttonOnActionPress = instance.find(
       (el) =>
         el.props.accessibilityLabel ===
           `${AccessibilityLabel.ITEM_QUICK_ACTION_PRESS}-${sensor?.id}` &&
         el.type === TouchableOpacity
     );
-    expect(buttonOnActionPress).toHaveLength(0);
+    await act(async () => {
+      await buttonOnActionPress.props.onPress();
+    });
+    expect(Toast.show).not.toBeCalled();
   });
 
   it('click quick action icon down , isSendingCommand = true', async () => {

package/src/screens/Device/components/SensorDisplayItem.js

@@ -36,7 +36,8 @@ export const SensorDisplayItem = ({
 }) => {
   const userId = useSCContextSelector((state) => state.auth.account.user.id);
   const { configuration = {}, id: idTemplate } = item;
-  const { type, template, uri, id, name, title } = configuration;
+  const { type, template, uri, id, name, title, value_evaluation } =
+    configuration;
 
   const sendRemoteCommand = useRemoteControl();
   const [processing, setProcessing] = useState(false);
@@ -52,8 +53,10 @@ export const SensorDisplayItem = ({
 
     const data = (item.configuration.configs || []).map((config) => {
       const configValue = configValues[config.id]?.value;
+
       const configEvaluate = evaluate[config.id] || {};
       let value = {};
+
       if (configValue === null || configValue === undefined) {
         value = {
           id: config.id,
@@ -64,14 +67,21 @@ export const SensorDisplayItem = ({
         value = {
           id: config.id,
           value: configValue,
-          evaluate: evaluateValue(config.id, configValue) || configEvaluate,
+          evaluate:
+            evaluateValue(configValue, value_evaluation) || configEvaluate,
         };
       }
       return { ...config, ...value };
     });
 
     return data.filter(Boolean);
-  }, [configValues, evaluateValue, item, evaluate]);
+  }, [
+    configValues,
+    evaluate,
+    evaluateValue,
+    item.configuration,
+    value_evaluation,
+  ]);
 
   const doAction = useCallback(
     async (action, data) => {

package/src/screens/Device/hooks/__test__/useEvaluateValue.test.js

@@ -1,6 +1,10 @@
-import React from 'react';
 import { renderHook } from '@testing-library/react-hooks';
-import { useEvaluateValue, useGetEvaluateValue } from '../useEvaluateValue';
+import {
+  useEvaluateValue,
+  useGetEvaluateValue,
+  valueEvaluationFuncs,
+} from '../useEvaluateValue';
+import React from 'react';
 import { SCProvider } from '../../../../context';
 import { mockSCStore } from '../../../../context/mockStore';
 import { API } from '../../../../configs';
@@ -24,7 +28,7 @@ const mockUseContext = jest.fn().mockImplementation(() => ({
 
 React.useContext = mockUseContext;
 
-describe('Test useEvaluateValue', () => {
+describe('useEvaluateValue', () => {
   let valueEvaluations = {};
 
   beforeEach(() => {
@@ -58,50 +62,117 @@ describe('Test useEvaluateValue', () => {
     };
   });
 
-  it('test value null or undefined', async () => {
-    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
-      wrapper: wrapper(valueEvaluations),
-    });
+  test('should evaluate range correctly', () => {
+    const value = 1.2;
+    const valueEvaluation = {
+      id: 8662,
+      template: 'range',
+      configuration: {
+        ranges: [
+          {
+            end: 1,
+            start: 1,
+            evaluate: {
+              icon: 'CheckCircleOutlined',
+              text: 'Active',
+              borderColor: '#00d084',
+              backgroundColor: 'rgba(0, 208, 132, 0.3)',
+            },
+            end_condition: '<',
+            start_condition: '>=',
+          },
+          {
+            end: 0,
+            start: 0,
+            evaluate: {
+              icon: 'CheckCircleOutlined',
+              text: 'InActive',
+              borderColor: '#abb8c3',
+              backgroundColor: 'rgba(171, 184, 195, 0.3)',
+            },
+            end_condition: '<',
+            start_condition: '>=',
+          },
+        ],
+      },
+      configs: [28265],
+    };
 
-    expect(evaluateValue.current(1, null).text).toBe('--');
-    expect(evaluateValue.current(1, undefined).text).toBe('--');
-  });
+    const { result } = renderHook(() => useEvaluateValue());
+    const evaluateValue = result.current;
 
-  it('test not found ValueEvaluation', async () => {
-    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
-      wrapper: wrapper(valueEvaluations),
+    const evaluatedResult = evaluateValue(value, valueEvaluation);
+    expect(evaluatedResult).toEqual({
+      backgroundColor: 'rgba(171, 184, 195, 0.3)',
+      borderColor: '#abb8c3',
+      icon: 'CheckCircleOutlined',
+      text: 'InActive',
     });
-
-    expect(evaluateValue.current(3, 1)).toBe(null);
   });
 
-  it('test template not handle', async () => {
-    valueEvaluations[1].template = 'other_template';
-    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
-      wrapper: wrapper(valueEvaluations),
-    });
+  test('should evaluate boolean correctly', () => {
+    const value = 0;
+    const valueEvaluation = {
+      id: 8662,
+      template: 'boolean',
+      configuration: {
+        on: {
+          value: 1,
+          evaluate: {
+            text: 'On',
+          },
+        },
+        off: {
+          value: 0,
+          evaluate: {
+            text: 'Off',
+          },
+        },
+      },
+      configs: [28265],
+    };
+
+    const { result } = renderHook(() => useEvaluateValue());
+    const evaluateValue = result.current;
 
-    expect(evaluateValue.current(1, 1)).toBe(null);
+    const evaluatedResult = evaluateValue(value, valueEvaluation);
+    expect(evaluatedResult).toEqual({ text: 'Off' });
   });
 
-  it('test evaluate range', async () => {
-    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
-      wrapper: wrapper(valueEvaluations),
-    });
+  test('should handle unknown valueEvaluation template', () => {
+    const value = 0;
+    const configuration = {};
+
+    const { result } = renderHook(() => useEvaluateValue());
+    const evaluateValue = result.current;
 
-    expect(evaluateValue.current(1, 1).text).toBe('On');
-    expect(evaluateValue.current(1, 0).text).toBe('Off');
-    expect(evaluateValue.current(1, 100).text).toBe(100);
+    const expectedResult = { text: value };
+    const evaluatedResult = evaluateValue(
+      value,
+      'unknown-template',
+      configuration
+    );
+    expect(evaluatedResult).toEqual(expectedResult);
   });
 
-  it('test evaluate boolean', async () => {
-    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
-      wrapper: wrapper(valueEvaluations),
+  test('should handle error in evaluateFunc', () => {
+    const value = 0;
+    const configuration = {};
+
+    const { result } = renderHook(() => useEvaluateValue());
+    const evaluateValue = result.current;
+
+    // Mocking a faulty evaluateFunc that throws an error
+    valueEvaluationFuncs.range = jest.fn(() => {
+      throw new Error('Evaluation error');
     });
 
-    expect(evaluateValue.current(2, 0).text).toBe('Off');
-    expect(evaluateValue.current(2, 1).text).toBe('On');
-    expect(evaluateValue.current(2, 2).text).toBe(2);
+    const evaluatedResult = evaluateValue(
+      value,
+      valueEvaluationFuncs.range,
+      configuration
+    );
+    expect(evaluatedResult).toEqual({ text: 0 });
   });
 
   it('test evaluate fetch from server if not exists', async () => {

package/src/screens/Device/hooks/useEvaluateValue.js

@@ -13,6 +13,7 @@ const evaluateRange = (value, configuration) => {
     ]
   }
  */
+
   if (!value) {
     value = 0;
   }
@@ -65,34 +66,23 @@ export const valueEvaluationFuncs = {
 };
 
 export const useEvaluateValue = () => {
-  const valueEvaluations = useSCContextSelector((state) => {
-    return state.valueEvaluations;
-  });
-
-  const evaluateValue = useCallback(
-    (configId, value) => {
-      if (value === null || value === undefined) {
-        return { text: '--', color: null };
-      }
+  const evaluateValue = useCallback((value, valueEvaluation) => {
+    if (valueEvaluation === null || valueEvaluation === undefined) {
+      return { text: '--', color: null };
+    }
 
-      const valueEvaluation = valueEvaluations[configId];
-      if (!valueEvaluation) {
-        return null;
-      }
+    const evaluateFunc = valueEvaluationFuncs[valueEvaluation.template];
 
-      const evaluateFunc = valueEvaluationFuncs[valueEvaluation.template];
-      if (!evaluateFunc) {
-        return null;
-      }
+    if (!evaluateFunc) {
+      return { text: value };
+    }
 
-      try {
-        return evaluateFunc(value, valueEvaluation.configuration);
-      } catch (e) {
-        return null;
-      }
-    },
-    [valueEvaluations]
-  );
+    try {
+      return evaluateFunc(value, valueEvaluation.configuration);
+    } catch (e) {
+      return null;
+    }
+  }, []);
 
   return evaluateValue;
 };