@eohjsc/react-native-smart-city 0.4.53 → 0.4.55

package/README.md

@@ -35,12 +35,35 @@ import {
   AutomateStack,
   NotificationStack,
 } from '@eohjsc/react-native-smart-city';
+import Config from 'react-native-config';
 import { createStackNavigator } from '@react-navigation/stack';
 
 // TODO: What to do with the module?
 const Stack = createStackNavigator();
 
 const YourStack = () => {
+
+
+  useEffect(() => {
+    const config = {
+      apiRoot: Config.API_ROOT,
+      GOOGLE_MAP_API_KEY: Config.GOOGLE_MAP_API_KEY,
+      LG_CLIENT_ID: Config.LG_CLIENT_ID,
+      LG_REDIRECT_URI_APP: Config.LG_REDIRECT_URI_APP,
+      LG_URL: Config.LG_URL,
+      VCONNEX_CLIENT_ID: Config.VCONNEX_CLIENT_ID,
+      VCONNEX_REDIRECT_URI_APP: Config.VCONNEX_REDIRECT_URI,
+      pusherAppKey: Config.PUSHER_APP_KEY,
+      pusherAppCluster: Config.PUSHER_APP_CLUSTER,
+      language,
+      setCurrentSensorDisplay,
+      appName: Config.APP_NAME,
+      packageName: Config.APP_PACKAGE_NAME,  //  Your package name is required
+      versionCode: Config.APP_VERSION_CODE,  //  Your app version is required
+    };
+    initSCConfig(config);
+  }, [language, setCurrentSensorDisplay]);
+
   // Declare yourAuthObject and params
   return (
     <Stack.Navigator>

package/package.json

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

package/src/commons/Action/ItemQuickAction.js

@@ -8,6 +8,16 @@ import IconComponent from '../IconComponent';
 
 const ItemQuickAction = memo(
   ({ sensor, wrapperStyle, setStatus, iconSize = 30 }) => {
+    const { quick_action } = sensor || {};
+    const {
+      config_id,
+      off_action,
+      on_status,
+      on_action,
+      off_status,
+      interval,
+      will_auto_update_status,
+    } = quick_action || {};
     const [action, setAction] = useState(sensor.action);
     // eslint-disable-next-line no-unused-vars
     const [configValues, _] = useConfigGlobalState('configValues');
@@ -17,26 +27,34 @@ const ItemQuickAction = memo(
     const [processing, setProcessing] = useState(false);
 
     useEffect(() => {
-      if (!(sensor.quick_action?.config_id in configValues)) {
+      if (!(config_id in configValues)) {
         return;
       }
-      const configValue = configValues[sensor.quick_action.config_id];
+      const configValue = configValues[config_id];
       setIsOn(configValue?.value);
-    }, [sensor, configValues]);
+    }, [configValues, config_id]);
 
     useEffect(() => {
-      if (!sensor.quick_action) {
+      if (!quick_action) {
         return;
       }
 
       if (isOn) {
-        setAction(sensor.quick_action.off_action);
-        setStatus && setStatus(sensor.quick_action.on_status);
+        setAction(off_action);
+        setStatus && setStatus(on_status);
       } else {
-        setAction(sensor.quick_action.on_action);
-        setStatus && setStatus(sensor.quick_action.off_status);
+        setAction(on_action);
+        setStatus && setStatus(off_status);
       }
-    }, [isOn, setStatus, sensor.quick_action]);
+    }, [
+      isOn,
+      setStatus,
+      quick_action,
+      off_action,
+      on_status,
+      on_action,
+      off_status,
+    ]);
 
     const userId = useSCContextSelector((state) => state?.auth.account.user.id);
     const onActionPress = useCallback(async () => {
@@ -46,9 +64,7 @@ const ItemQuickAction = memo(
       }
       setProcessing(true);
       let data = null;
-      if (
-        action?.allow_config_store_value_id === sensor?.quick_action?.config_id
-      ) {
+      if (action?.allow_config_store_value_id === config_id) {
         if (action?.name?.toLowerCase().includes('off')) {
           data = {
             config_id: action?.allow_config_store_value_id,
@@ -64,13 +80,23 @@ const ItemQuickAction = memo(
       }
       await sendRemoteCommand(sensor, action, data, userId);
 
-      if (!sensor.quick_action.will_auto_update_status) {
+      if (!will_auto_update_status) {
         setTimeout(() => {
-          setIsOn(action.id === sensor.quick_action.on_action.id);
-        }, sensor.quick_action.interval);
+          setIsOn(action.id === on_action.id);
+        }, interval);
       }
       setProcessing(false);
-    }, [processing, action, sensor, sendRemoteCommand, userId]);
+    }, [
+      processing,
+      action,
+      config_id,
+      sendRemoteCommand,
+      sensor,
+      userId,
+      will_auto_update_status,
+      interval,
+      on_action?.id,
+    ]);
 
     if (!action) {
       return <View />;

package/src/iot/Monitor.js

@@ -37,7 +37,7 @@ const watchingConfigs = {};
 
 export const updateGlobalValue = (configId, value) => {
   const configValues = getConfigGlobalState('configValues');
-  const newConfigValues = { ...configValues };
+  let newConfigValues = { ...configValues };
   newConfigValues[configId] = value;
   setConfigGlobalState('configValues', newConfigValues);
 };

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;
 };