@eohjsc/react-native-smart-city 0.2.97 → 0.3.0

package/src/commons/ActionGroup/TimerActionTemplate.js

@@ -14,9 +14,9 @@ import { Colors } from '../../configs';
 import { useConfigGlobalState } from '../../iot/states';
 import BottomScrollPicker from '../BottomScrollPicker';
 
-const TimerActionTemplate = ({ actionGroup, doAction, sensor }) => {
+const TimerActionTemplate = ({ actionGroup = {}, doAction, sensor = {} }) => {
   const t = useTranslations();
-  const { configuration, title } = actionGroup;
+  const { configuration = {}, title } = actionGroup;
   const [showTime, setShowTime] = useState(false);
   const [showHour, setShowHour] = useState(false);
 
@@ -94,6 +94,7 @@ const TimerActionTemplate = ({ actionGroup, doAction, sensor }) => {
       if (sensor.is_managed_by_backend) {
         hour !== undefined &&
           minute !== undefined &&
+          sensor.device_type !== 'GOOGLE_HOME' &&
           watchMultiConfigs([
             configuration.config_hour,
             configuration.config_minute,
@@ -106,13 +107,17 @@ const TimerActionTemplate = ({ actionGroup, doAction, sensor }) => {
       configuration.config_minute,
       doAction,
       sensor.is_managed_by_backend,
+      sensor.device_type,
     ]
   );
 
   const doActionHour = useCallback(
     (hour) => {
       doAction(configuration.action_data, hour);
-      if (sensor.is_managed_by_backend) {
+      if (
+        sensor.is_managed_by_backend &&
+        sensor.device_type !== 'GOOGLE_HOME'
+      ) {
         hour && watchMultiConfigs([configuration.config_hour]);
       }
     },
@@ -121,6 +126,7 @@ const TimerActionTemplate = ({ actionGroup, doAction, sensor }) => {
       configuration.config_hour,
       doAction,
       sensor.is_managed_by_backend,
+      sensor.device_type,
     ]
   );
 
@@ -201,6 +207,8 @@ const TimerActionTemplate = ({ actionGroup, doAction, sensor }) => {
         onConfirm={onConfirmTime}
         onCancel={onHideTime}
         display="spinner"
+        cancelTextIOS={t('cancel')}
+        confirmTextIOS={t('confirm')}
       />
       <BottomScrollPicker
         min={configuration.min}

package/src/commons/ActionGroup/TwoButtonTemplate/index.js

@@ -28,16 +28,18 @@ const TwoButtonTemplate = memo(({ actionGroup, doAction, sensor }) => {
     [actionGroup?.title, sensor?.name]
   );
 
-  const triggerAction1 = useCallback(() => {
+  const triggerAction1 = useCallback(async () => {
     if (button1?.action_on_data && button1?.action_off_data) {
       if (isOn) {
-        doAction(button1?.action_off_data, null, actionName('off'));
+        await doAction(button1?.action_off_data, null, actionName('off'));
       } else {
-        doAction(button1?.action_on_data, null, actionName('on'));
+        await doAction(button1?.action_on_data, null, actionName('on'));
       }
     }
     if (sensor?.is_managed_by_backend) {
-      configuration.config && watchMultiConfigs([configuration.config]);
+      configuration.config &&
+        sensor.device_type !== 'GOOGLE_HOME' &&
+        watchMultiConfigs([configuration.config]);
     }
   }, [
     actionName,
@@ -46,17 +48,18 @@ const TwoButtonTemplate = memo(({ actionGroup, doAction, sensor }) => {
     doAction,
     isOn,
     sensor?.is_managed_by_backend,
+    sensor?.device_type,
   ]);
 
-  const triggerAction2 = useCallback(() => {
+  const triggerAction2 = useCallback(async () => {
     if (button2?.action_on_data && button2?.action_off_data) {
       if (isStart) {
-        doAction(button2?.action_off_data, null, actionName('stop'));
+        await doAction(button2?.action_off_data, null, actionName('stop'));
       } else {
-        doAction(button2?.action_on_data, null, actionName('start'));
+        await doAction(button2?.action_on_data, null, actionName('start'));
       }
     }
-    if (sensor?.is_managed_by_backend) {
+    if (sensor?.is_managed_by_backend && sensor.device_type !== 'GOOGLE_HOME') {
       configuration.config && watchMultiConfigs([configuration.config]);
     }
   }, [
@@ -67,6 +70,7 @@ const TwoButtonTemplate = memo(({ actionGroup, doAction, sensor }) => {
     doAction,
     isStart,
     sensor?.is_managed_by_backend,
+    sensor?.device_type,
   ]);
 
   useEffect(() => {
@@ -98,7 +102,7 @@ const TwoButtonTemplate = memo(({ actionGroup, doAction, sensor }) => {
     if (sensor?.device_type === DEVICE_TYPE.LG_THINQ) {
       return;
     }
-    if (sensor?.is_managed_by_backend) {
+    if (sensor?.is_managed_by_backend && sensor.device_type !== 'GOOGLE_HOME') {
       watchMultiConfigs([configuration.config]);
     }
   }, [sensor, configuration.config]);

package/src/commons/ActionGroup/__test__/CurtainButtonTemplate.test.js

@@ -1,20 +1,37 @@
 import React from 'react';
 import renderer, { act } from 'react-test-renderer';
-import { TouchableOpacity } from 'react-native';
+import { TouchableOpacity, Switch } from 'react-native';
 
 import CurtainButtonTemplate from '../CurtainButtonTemplate';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 
-const wrapComponent = (actionGroup) => (
+const mockDoAction = jest.fn();
+const mockActionOffData = jest.fn();
+const mockActionOnData = jest.fn();
+const mockCloseActionData = jest.fn();
+
+const wrapComponent = (actionGroup = {}, sensor = {}) => (
   <SCProvider initState={mockSCStore({})}>
-    <CurtainButtonTemplate actionGroup={actionGroup} doAction={jest.fn()} />
+    <CurtainButtonTemplate
+      actionGroup={actionGroup}
+      doAction={mockDoAction}
+      sensor={sensor}
+    />
   </SCProvider>
 );
 
 describe('Test CurtainButtonTemplate', () => {
+  const sensor = {
+    name: 'test',
+  };
   const actionGroup = {
     configuration: {
+      text_open: 'open',
+      is_display_lock: true,
+      action_off_data: mockActionOffData,
+      action_on_data: mockActionOnData,
+      close_action_data: mockCloseActionData,
       action1: '2b949045-8e03-4c07-a855-7794ade2e69c',
       action1_data: {
         color: '#00979D',
@@ -61,12 +78,44 @@ describe('Test CurtainButtonTemplate', () => {
 
   let wrapper;
 
+  test('render without params', async () => {
+    await act(() => {
+      wrapper = renderer.create(wrapComponent());
+    });
+    const instance = wrapper.root;
+    const touchableOpacities = instance.findAllByType(TouchableOpacity);
+    expect(touchableOpacities.length).toEqual(3);
+  });
+
   test('render CurtainButtonTemplate', async () => {
     await act(() => {
-      wrapper = renderer.create(wrapComponent(actionGroup));
+      wrapper = renderer.create(wrapComponent(actionGroup, sensor));
     });
     const instance = wrapper.root;
     const touchableOpacities = instance.findAllByType(TouchableOpacity);
     expect(touchableOpacities.length).toEqual(3);
+    await touchableOpacities[0].props.onPress();
+    await touchableOpacities[1].props.onPress();
+    await touchableOpacities[2].props.onPress();
+    expect(mockDoAction).toBeCalledWith(
+      mockCloseActionData,
+      null,
+      sensor?.name + ' undefined'
+    );
+
+    const Switchs = instance.findAllByType(Switch);
+    expect(Switchs).toHaveLength(1);
+    await Switchs[0].props.onValueChange();
+    expect(mockDoAction).toBeCalledWith(
+      mockActionOnData,
+      null,
+      `${sensor.name} lock`
+    );
+    await Switchs[0].props.onValueChange();
+    expect(mockDoAction).toBeCalledWith(
+      mockActionOffData,
+      null,
+      `${sensor.name} unlock`
+    );
   });
 });

package/src/commons/ActionGroup/__test__/OnOffButtonTemplate.test.js

@@ -1,6 +1,14 @@
 import React, { useState } from 'react';
 import { act, create } from 'react-test-renderer';
-import Index from '../OnOffTemplate';
+import OnOffTemplate from '../OnOffTemplate';
+import { mockSCStore } from '../../../context/mockStore';
+import { SCProvider } from '../../../context';
+
+const wrapComponent = (actionGroup, mockDoAction) => (
+  <SCProvider initState={mockSCStore({})}>
+    <OnOffTemplate actionGroup={actionGroup} doAction={mockDoAction} />
+  </SCProvider>
+);
 
 jest.mock('react', () => ({
   ...jest.requireActual('react'),
@@ -49,21 +57,15 @@ describe('Test OneBigButtonTemplate', () => {
   const assertRender = (state, text) => {
     useState.mockImplementationOnce((init) => [state, setState]);
     const mockDoAction = jest.fn();
+
     act(() => {
-      wrapper = create(
-        <Index actionGroup={actionGroup} doAction={mockDoAction} />
-      );
+      wrapper = create(wrapComponent(actionGroup, mockDoAction));
     });
 
     const renderJson = wrapper.toJSON();
 
-    expect(renderJson?.children[0].children[0].children[1].children).toEqual(
-      undefined
-    );
-
-    expect(
-      renderJson?.children[0].children[0].children[1].children
-    ).not.toEqual([text]);
+    expect(renderJson?.props?.visible).toEqual(false);
+    expect(renderJson?.type).toEqual('Modal');
   };
 
   test('render state on', () => {
@@ -78,9 +80,7 @@ describe('Test OneBigButtonTemplate', () => {
     useState.mockImplementationOnce((init) => [state, setState]);
     const mockDoAction = jest.fn();
     act(() => {
-      wrapper = create(
-        <Index actionGroup={actionGroup} doAction={mockDoAction} />
-      );
+      wrapper = create(wrapComponent(actionGroup, mockDoAction));
     });
 
     expect(mockDoAction).not.toHaveBeenCalled();

package/src/commons/ActionGroup/__test__/OnOffTemplate.test.js

@@ -1,11 +1,25 @@
+/* eslint-disable promise/prefer-await-to-callbacks */
 import { TESTID } from '../../../configs/Constants';
 import { watchMultiConfigs } from '../../../iot/Monitor';
 import React from 'react';
 import { View } from 'react-native';
+import { useSelector } from 'react-redux';
 import { act, create } from 'react-test-renderer';
 import OnOffTemplate from '../OnOffTemplate';
 import OnOffButtonTemplate from '../OnOffTemplate/OnOffButtonTemplate';
 import OnOffSimpleTemplate from '../OnOffTemplate/OnOffSimpleTemplate';
+import { mockSCStore } from '../../../context/mockStore';
+import { SCProvider } from '../../../context';
+
+const wrapComponent = (actionGroup, mockDoAction, sensor) => (
+  <SCProvider initState={mockSCStore({})}>
+    <OnOffTemplate
+      actionGroup={actionGroup}
+      doAction={mockDoAction}
+      sensor={sensor}
+    />
+  </SCProvider>
+);
 
 jest.mock('../../../iot/Monitor');
 
@@ -13,9 +27,15 @@ jest.mock('../../../iot/states', () => ({
   useConfigGlobalState: () => [{ 5: 2 }, null],
 }));
 
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+  useSelector: jest.fn(),
+}));
+
 describe('Test OnOffTemplate', () => {
-  let wrapper;
   let actionGroup;
+  let tree;
+  let sensor;
 
   const action_data = {
     color: '#00979D',
@@ -62,20 +82,23 @@ describe('Test OnOffTemplate', () => {
       },
       title: 'Turn on / off',
     };
+
+    sensor = { name: 'Sensor' };
+
+    const localState = {
+      isOnSwich: false,
+    };
+    useSelector.mockImplementation((cb) => {
+      return cb(localState);
+    });
   });
 
   test('render with template OnOffSimpleActionTemplate', async () => {
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{}}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, {}));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findAllByType(OnOffSimpleTemplate);
     expect(template).toHaveLength(1);
   });
@@ -84,15 +107,9 @@ describe('Test OnOffTemplate', () => {
     actionGroup.template = 'on_off_button_action_template';
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{}}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, {}));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findAllByType(OnOffButtonTemplate);
     expect(template).toHaveLength(0);
   });
@@ -101,15 +118,9 @@ describe('Test OnOffTemplate', () => {
     actionGroup.template = 'wrong_template';
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{}}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, {}));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
 
     const templateOnOffButton = instance.findAll(
       (el) =>
@@ -125,32 +136,20 @@ describe('Test OnOffTemplate', () => {
   test('render with template OnOffSimpleActionTemplate with is_managed_by_backend', async () => {
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{ is_managed_by_backend: true }}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, {}));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findAllByType(OnOffSimpleTemplate);
     expect(template).toHaveLength(1);
-    expect(watchMultiConfigs).toBeCalledTimes(1);
+    expect(watchMultiConfigs).toBeCalledTimes(0);
   });
 
   test('template OnOffSimpleActionTemplate doAction with is_on_value, match configValue', async () => {
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{ name: 'Sensor name' }}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, sensor));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findByType(OnOffSimpleTemplate);
     expect(template.props.isOn).toEqual(true);
 
@@ -160,7 +159,7 @@ describe('Test OnOffTemplate', () => {
     expect(mockDoAction).toHaveBeenCalledWith(
       action_off_data,
       null,
-      'Sensor name turn on / off off'
+      'Sensor turn on / off off'
     );
     expect(watchMultiConfigs).toBeCalledTimes(0);
   });
@@ -169,15 +168,9 @@ describe('Test OnOffTemplate', () => {
     actionGroup.configuration.is_on_value = [1];
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{ name: 'Sensor name' }}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, sensor));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findByType(OnOffSimpleTemplate);
     expect(template.props.isOn).toEqual(false);
 
@@ -187,22 +180,16 @@ describe('Test OnOffTemplate', () => {
     expect(mockDoAction).toHaveBeenCalledWith(
       action_on_data,
       null,
-      'Sensor name turn on / off on'
+      'Sensor turn on / off on'
     );
   });
 
   test('template OnOffSimpleActionTemplate doAction with is_on_value and is_managed_by_backend', async () => {
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{ name: 'Sensor name', is_managed_by_backend: true }}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, sensor));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findByType(OnOffSimpleTemplate);
     expect(template.props.isOn).toEqual(true);
 
@@ -212,9 +199,9 @@ describe('Test OnOffTemplate', () => {
     expect(mockDoAction).toHaveBeenCalledWith(
       action_off_data,
       null,
-      'Sensor name turn on / off off'
+      'Sensor turn on / off off'
     );
-    expect(watchMultiConfigs).toBeCalledTimes(2);
+    expect(watchMultiConfigs).toBeCalledTimes(0);
   });
 
   test('render with template OnOffSimpleActionTemplate with just action_data', async () => {
@@ -230,15 +217,9 @@ describe('Test OnOffTemplate', () => {
     };
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{ is_managed_by_backend: true }}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, {}));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findAllByType(OnOffSimpleTemplate);
     expect(template).toHaveLength(1);
     expect(template[0].props.disabled).toBeFalsy();
@@ -261,15 +242,9 @@ describe('Test OnOffTemplate', () => {
     };
     const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(
-        <OnOffTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{ is_managed_by_backend: true }}
-        />
-      );
+      tree = await create(wrapComponent(actionGroup, mockDoAction, {}));
     });
-    const instance = wrapper.root;
+    const instance = tree.root;
     const template = instance.findAllByType(OnOffSimpleTemplate);
     expect(template).toHaveLength(1);
     expect(template[0].props.disabled).toBeTruthy();

package/src/commons/ActionGroup/__test__/OneBigButtonTemplate.test.js

@@ -1,8 +1,27 @@
+/* eslint-disable promise/prefer-await-to-callbacks */
 import React from 'react';
 import { create, act } from 'react-test-renderer';
 import { TouchableOpacity } from 'react-native';
+import { useSelector } from 'react-redux';
 
 import OneBigButtonTemplate from '../OneBigButtonTemplate';
+import { mockSCStore } from '../../../context/mockStore';
+import { SCProvider } from '../../../context';
+
+const wrapComponent = (actionGroup, mockDoAction, sensor) => (
+  <SCProvider initState={mockSCStore({})}>
+    <OneBigButtonTemplate
+      actionGroup={actionGroup}
+      doAction={mockDoAction}
+      sensor={sensor}
+    />
+  </SCProvider>
+);
+
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+  useSelector: jest.fn(),
+}));
 
 describe('Test OneBigButtonTemplate', () => {
   const action_data = {
@@ -23,24 +42,25 @@ describe('Test OneBigButtonTemplate', () => {
       text: 'UP',
     },
   };
-  const sensor = {
-    name: 'Sensor name',
-  };
-  let wrapper;
+  let tree;
+  let sensor;
 
-  test('render OneBigButtonTemplate', () => {
-    const mockDoAction = jest.fn();
-    act(() => {
-      wrapper = create(
-        <OneBigButtonTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={sensor}
-        />
-      );
+  beforeEach(() => {
+    const localState = {
+      isOnSwich: false,
+    };
+    useSelector.mockImplementation((cb) => {
+      return cb(localState);
     });
+    sensor = { name: 'Sensor' };
+  });
 
-    const instance = wrapper.root;
+  test('render OneBigButtonTemplate', async () => {
+    const mockDoAction = jest.fn();
+    await act(async () => {
+      tree = await create(wrapComponent(actionGroup, mockDoAction, sensor));
+    });
+    const instance = tree.root;
     const buttons = instance.findAllByType(TouchableOpacity);
     expect(buttons.length).toEqual(1);
 
@@ -49,10 +69,6 @@ describe('Test OneBigButtonTemplate', () => {
     });
 
     expect(mockDoAction).toHaveBeenCalledTimes(1);
-    expect(mockDoAction).toHaveBeenCalledWith(
-      action_data,
-      null,
-      'Sensor name up'
-    );
+    expect(mockDoAction).toHaveBeenCalledWith(action_data, null, 'Sensor up');
   });
 });

package/src/commons/ActionGroup/__test__/StatesGridActionTemplate.test.js

@@ -0,0 +1,77 @@
+import React from 'react';
+import { TouchableOpacity } from 'react-native';
+import { act, create } from 'react-test-renderer';
+import Text from '../../Text';
+import StatesGridActionTemplate from '../StatesGridActionTemplate';
+
+const mockDoAction = jest.fn();
+const mockActionData = jest.fn();
+
+describe('Test StatesGridActionTemplate', () => {
+  let tree;
+  const actionGroup = {
+    configuration: {
+      options: [
+        {
+          config: true,
+          active: false,
+          text: 'item 1',
+          icon_kit_data: 'icon_kit_data',
+          icon: '123',
+          icon_outlined: 'icon_outlined',
+          action_data: mockActionData,
+        },
+        {
+          config: false,
+          active: true,
+          text: 'item 2',
+          icon_kit_data: 'icon_kit_data',
+          icon: 'icon',
+          icon_outlined: 'icon_outlined',
+          action_data: mockActionData,
+        },
+      ],
+      is_on_value: true,
+    },
+    title: 'Title',
+  };
+  const sensor = {
+    is_managed_by_backend: true,
+    device_type: '',
+    name: 'Sensor name',
+  };
+
+  test('test render without params', async () => {
+    await act(async () => {
+      tree = await create(<StatesGridActionTemplate />);
+    });
+    const instance = tree.root;
+    const Texts = instance.findAllByType(Text);
+    expect(Texts).toHaveLength(1);
+  });
+
+  test('test render with params', async () => {
+    await act(async () => {
+      tree = await create(
+        <StatesGridActionTemplate
+          doAction={mockDoAction}
+          sensor={sensor}
+          actionGroup={actionGroup}
+        />
+      );
+    });
+    const instance = tree.root;
+    const Texts = instance.findAllByType(Text);
+    expect(Texts).toHaveLength(3);
+    const TouchableOpacities = instance.findAllByType(TouchableOpacity);
+    expect(TouchableOpacities).toHaveLength(2);
+    await TouchableOpacities[0].props.onPress();
+    expect(mockDoAction).toBeCalledWith(
+      mockActionData,
+      null,
+      `${sensor.name} ${actionGroup.title.toLowerCase()} ${
+        actionGroup.configuration.options[0].text
+      }`
+    );
+  });
+});