@eohjsc/react-native-smart-city 0.2.98 → 0.3.1

package/src/screens/Sharing/__test__/MemberList2.test.js

@@ -0,0 +1,80 @@
+import React from 'react';
+import { create, act } from 'react-test-renderer';
+
+import MemberList from '../MemberList';
+import { AlertAction } from '../../../commons';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import { TouchableOpacity } from 'react-native';
+import Routes from '../../../utils/Route';
+
+jest.mock('../../../hooks/Common', () => {
+  return {
+    useIsOwnerOfUnit: () => ({ isOwner: false }),
+  };
+});
+
+const mockedNavigate = jest.fn();
+const mockUseIsFocused = jest.fn();
+
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+    }),
+    useIsFocused: () => ({
+      isFocused: mockUseIsFocused,
+    }),
+  };
+});
+
+const wrapComponent = (route, state) => (
+  <SCProvider initState={mockSCStore({})}>
+    <MemberList route={route} />
+  </SCProvider>
+);
+
+describe('test MemberList', () => {
+  let route;
+  let localState = {
+    auth: {
+      account: {
+        user: {
+          id: 2,
+        },
+      },
+    },
+  };
+
+  beforeEach(() => {
+    route = {
+      params: {
+        unitId: 1,
+        unit: {
+          id: 1,
+          user_id: 2,
+          name: '',
+        },
+      },
+    };
+  });
+
+  test('AlertAction rightButtonClick', async () => {
+    let tree;
+    await act(async () => {
+      tree = await create(wrapComponent(route, localState));
+    });
+    const instance = tree.root;
+    const alertAction = instance.findByType(AlertAction);
+    await act(async () => {
+      alertAction.props.rightButtonClick();
+    });
+    const MemberListButtons = instance.findAllByType(TouchableOpacity);
+    await MemberListButtons[1].props.onPress();
+    expect(mockedNavigate).not.toBeCalledWith(Routes.AddMemberStack, {
+      screen: Routes.SharingSelectPermission,
+      params: { unit: { id: 1 } },
+    });
+  });
+});

package/src/screens/Sharing/__test__/SelectPermission.test.js

@@ -2,16 +2,17 @@ import { act } from '@testing-library/react-hooks';
 import React, { useState } from 'react';
 import { FlatList, Text, Platform } from 'react-native';
 import { create } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
+
 import SelectPermission from '../SelectPermission';
-import axios from 'axios';
 import { SensorItem, TitleCheckBox } from '../Components';
 import { ViewButtonBottom } from '../../../commons';
-import Routes from '../../../utils/Route';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import API from '../../../configs/API';
+import api from '../../../utils/Apis/axios';
 
-jest.mock('axios');
+const mock = new MockAdapter(api.axiosInstance);
 
 const mockSetState = jest.fn();
 jest.mock('react', () => {
@@ -63,7 +64,6 @@ describe('Test SelectPermission', () => {
   const mockSetDataStations = jest.fn();
 
   afterEach(() => {
-    axios.mockClear();
     mockSetState.mockClear();
     mockSetTickAllDevice.mockClear();
     mockSetActiveItemId.mockClear();
@@ -92,15 +92,16 @@ describe('Test SelectPermission', () => {
     act(() => {
       tree = create(wrapComponent(route));
     });
-    expect(axios.get).not.toBeCalled();
+    const instance = tree.root;
+    const ViewButtonBottoms = instance.findAllByType(ViewButtonBottom);
+    expect(ViewButtonBottoms).toHaveLength(1);
   });
 
   it('render empty list', () => {
     mockLoading();
     Platform.OS = 'ios';
-
     route.params.unit = 1;
-    axios.get.mockImplementationOnce(() => ({ status: 200, data: [] }));
+    mock.onGet(API.SHARE.UNIT_MEMBER_SHARE_DEVICE(1, 1)).reply(200);
     act(() => {
       tree = create(wrapComponent(route));
     });
@@ -111,9 +112,8 @@ describe('Test SelectPermission', () => {
 
   it('test get unit fail', () => {
     mockLoading();
-
     route.params.unit = 1;
-    axios.get.mockImplementationOnce(() => ({ status: 400, data: [] }));
+    mock.onGet(API.SHARE.UNIT_MEMBER_SHARE_DEVICE(1, 1)).reply(400);
     act(() => {
       tree = create(wrapComponent(route));
     });
@@ -183,27 +183,15 @@ describe('Test SelectPermission', () => {
     act(() => {
       ViewButtonBottomElement[0].props.onRightClick();
     });
-    expect(mockNavigate).toBeCalledWith(Routes.SharingInviteMembers, {
-      permissions: {
-        control_permissions: [{ id: 123, values: [136] }],
-        read_permissions: [{ id: 123, values: [137] }],
-      },
-      unit: 1,
-    });
     act(() => {
       ViewButtonBottomElement[0].props.onLeftClick();
     });
     expect(mockGoBack).toBeCalled();
   });
+
   it('test selectPermission type share_device', () => {
     mocSetdata();
-    const routes = {
-      params: {
-        unit: { id: 1 },
-        type: 'share_device',
-        member: { id: 1, name: 'a', phone_number: '89898888' },
-      },
-    };
+    useState.mockImplementationOnce((init) => [true, mockSetState]);
     const response = {
       status: 200,
       data: [
@@ -223,28 +211,30 @@ describe('Test SelectPermission', () => {
         },
       ],
     };
-    axios.get.mockImplementation(async () => {
-      return response;
-    });
+    mock
+      .onGet(API.SHARE.UNIT_MEMBER_SHARE_DEVICE(1, 1))
+      .reply(200, response.data);
+    const routes = {
+      params: {
+        unit: { id: 1 },
+        type: 'update_shared',
+        member: {
+          id: 1,
+          name: 'a',
+          phone_number: '89898888',
+          email: 'abcderfg@gmail.com',
+        },
+      },
+    };
     act(() => {
       tree = create(wrapComponent(routes));
     });
     const instance = tree.root;
     const ViewButtonBottomElement = instance.findAllByType(ViewButtonBottom);
-    expect(ViewButtonBottomElement).toHaveLength(1);
-    expect(axios.get).toHaveBeenCalledWith(
-      API.SHARE.UNIT_MEMBER_SHARE_DEVICE(1, 1),
-      {}
-    );
     act(() => {
       ViewButtonBottomElement[0].props.onRightClick();
     });
-    expect(mockNavigate).toBeCalledWith(Routes.SharingInviteMembers, {
-      permissions: {
-        control_permissions: [{ id: 123, values: [136] }],
-        read_permissions: [{ id: 123, values: [137] }],
-      },
-      unit: 1,
-    });
+    mock.onPost(API.SHARE.SHARE()).reply(200);
+    expect(mockGoBack).toBeCalled();
   });
 });

package/src/screens/Sharing/__test__/SelectUser.test.js

@@ -1,6 +1,6 @@
 import React from 'react';
 import { create, act } from 'react-test-renderer';
-import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
 
 import SelectUser from '../SelectUser';
 import { TESTID } from '../../../configs/Constants';
@@ -11,6 +11,7 @@ import { API } from '../../../configs';
 import { getTranslate } from '../../../utils/I18n';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
+import api from '../../../utils/Apis/axios';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -18,13 +19,13 @@ const wrapComponent = (route) => (
   </SCProvider>
 );
 
+const mock = new MockAdapter(api.axiosInstance);
+
 const mockedNavigate = jest.fn();
 const mockedGoBack = jest.fn();
 const mockedDangerouslyGetState = jest.fn();
 const mockedDangerouslyGetParentGoBack = jest.fn();
 
-jest.mock('axios');
-
 jest.mock('react-redux', () => {
   return {
     ...jest.requireActual('react-redux'),
@@ -52,7 +53,6 @@ describe('test SelectUser container', () => {
   let route;
 
   beforeEach(() => {
-    axios.post.mockClear();
     route = {
       params: {
         unit: {
@@ -70,12 +70,6 @@ describe('test SelectUser container', () => {
     return instance.find((el) => el.props.testID === id);
   };
 
-  const mockAxiosPost = (response) => {
-    axios.post.mockImplementation(async () => {
-      return await response;
-    });
-  };
-
   test('create', async () => {
     await act(async () => {
       tree = create(wrapComponent(route));
@@ -125,11 +119,7 @@ describe('test SelectUser container', () => {
   });
 
   test('_TextInput onChange phone, invalidate and not call api sharedPermission', async () => {
-    const response = {
-      status: 200,
-    };
-    mockAxiosPost(response);
-
+    mock.onPost(API.SHARE.SHARE()).reply(200);
     await act(async () => {
       tree = create(wrapComponent(route));
     });
@@ -151,48 +141,37 @@ describe('test SelectUser container', () => {
     expect(textInput.props.errorText).toEqual(
       getTranslate('en', 'invalid_phone_number_or_email')
     );
-    expect(axios.post).not.toHaveBeenCalled();
   });
 
   test('_TextInput onChange phone, validated and call api sharedPermission', async () => {
-    const response = {
-      status: 200,
-      data: {
-        user: {
-          id: 2,
-          name: 'user add',
-        },
-      },
-    };
-    mockAxiosPost(response);
-
     await act(async () => {
       tree = create(wrapComponent(route));
     });
     const instance = tree.root;
-
     const textInput = instance.findByType(_TextInput);
     const button = instance.findByType(Button);
-
     let accountList = instance.findAllByType(AccountList);
     expect(accountList).toHaveLength(0);
-
     await act(async () => {
       await textInput.props.onChange('0909123456');
     });
-
+    mock.onPost(API.SHARE.SHARE()).reply(200, {
+      user: {
+        id: 2,
+        name: 'user add',
+        phone_number: '0909123456',
+      },
+    });
     await act(async () => {
       await button.props.onPress();
     });
-
+    await act(async () => {
+      await textInput.props.onChange('test123@gmail.com');
+    });
     expect(textInput.props.errorText).toEqual('');
-    expect(axios.post).toHaveBeenCalledWith(API.SHARE.SHARE(), {
-      phone: '0909123456',
-      email: '',
-      unit: 1,
-      permissions: { controlPermissions: {}, readPermissions: {} },
+    await act(async () => {
+      await button.props.onPress();
     });
-
     accountList = instance.findAllByType(AccountList);
     expect(accountList).toHaveLength(1);
   });

package/src/screens/SideMenuDetail/SideMenuDetailStyles.js

@@ -0,0 +1,28 @@
+import { Colors } from '../../configs';
+import { StyleSheet } from 'react-native';
+import { getBottomSpace } from 'react-native-iphone-x-helper';
+
+export default StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: Colors.White,
+  },
+  scrollview: {
+    flex: 1,
+    marginHorizontal: 16,
+  },
+  wrap: {
+    paddingBottom: 100,
+  },
+  viewBottomFixed: {
+    position: 'absolute',
+    bottom: 0,
+    left: 0,
+    right: 0,
+    paddingBottom: getBottomSpace() > 0 ? getBottomSpace() : 32,
+    paddingTop: 24,
+    backgroundColor: Colors.White,
+    borderColor: Colors.ShadownTransparent,
+    borderTopWidth: 1,
+  },
+});

package/src/screens/SideMenuDetail/__test__/index.test.js

@@ -0,0 +1,154 @@
+import React from 'react';
+import MockAdapter from 'axios-mock-adapter';
+import { act, create } from 'react-test-renderer';
+
+import { TESTID } from '../../../configs/Constants';
+
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import SideMenuDetail from '../index';
+import { API } from '../../../configs';
+import { TouchableOpacity } from 'react-native';
+import { ModalCustom } from '../../../commons/Modal';
+import { ToastBottomHelper } from '../../../utils/Utils';
+import api from '../../../utils/Apis/axios';
+
+const mock = new MockAdapter(api.axiosInstance);
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <SideMenuDetail route={route} />
+  </SCProvider>
+);
+
+describe('Test SideMenuDetail', () => {
+  let tree;
+  const spyToastSuccess = jest.spyOn(ToastBottomHelper, 'success');
+  const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
+
+  afterEach(() => {
+    spyToastSuccess.mockReset();
+    spyToastSuccess.mockRestore();
+  });
+
+  const chooseUser = async (instance) => {
+    const ChooseField = instance.find(
+      (item) =>
+        item.props.testID === TESTID.CHOOSE_FIELD &&
+        item.type === TouchableOpacity
+    );
+    await act(async () => {
+      await ChooseField.props.onPress();
+    });
+
+    const popup = instance.find(
+      (item) =>
+        item.props.testID === TESTID.CHOOSE_POPUP && item.type === ModalCustom
+    );
+    expect(popup.props.isVisible).toBeTruthy();
+
+    const button_choose_done = instance.find(
+      (el) =>
+        el.props.testID === TESTID.CHOOSE_POPUP + TESTID.BOTTOM_VIEW_MAIN &&
+        el.type === TouchableOpacity
+    );
+
+    await act(async () => {
+      await button_choose_done.props.onPress();
+    });
+    expect(popup.props.isVisible).toBeFalsy();
+  };
+
+  const enterPasscode = async (instance) => {
+    const inputPasscode = instance.find(
+      (item) => item.props.testID === TESTID.PASSCODE_FIELD
+    );
+
+    await act(async () => {
+      await inputPasscode.props.onChangeText('123456');
+    });
+  };
+
+  const onPressSubmitData = async (instance) => {
+    const buttonSubmit = instance.find(
+      (el) =>
+        el.props.testID === TESTID.SUBMIT + TESTID.BOTTOM_VIEW_MAIN &&
+        el.type === TouchableOpacity
+    );
+    await act(async () => {
+      await buttonSubmit.props.onPress();
+    });
+  };
+
+  test('render SideMenuDetail template choose field', async () => {
+    const response_side_menu = {
+      status: 200,
+      data: {
+        id: 1,
+        action: '3df74a11-1a95-4a65-8e08-936b88c8b5ca',
+        fields: [
+          {
+            type: 'choose_user',
+            key: 'user_id',
+            action: {
+              type: 'action_zigbee',
+              id: 1,
+            },
+          },
+          {
+            type: 'passcode',
+            key: 'passcode',
+            action: {
+              type: 'action_zigbee',
+              id: 1,
+            },
+          },
+          {
+            type: 'schedule',
+            key: 'schedule',
+            action: {
+              type: 'action_zigbee',
+              id: {
+                always: 2,
+                recurring: 4,
+                temporary: 5,
+              },
+            },
+          },
+        ],
+      },
+    };
+    const response_unit_members = {
+      status: 200,
+      data: [{ id: 1, name: 'Ken' }],
+    };
+
+    mock
+      .onGet(API.DEVICE.SIDE_MENU_DETAIL(1, 1))
+      .reply(200, response_side_menu.data);
+    mock
+      .onGet(API.SHARE.UNITS_MEMBERS(1))
+      .reply(200, response_unit_members.data);
+    mock.onPost(API.DEVICE.TRIGGER_ACTION(1)).reply(200, []);
+
+    const route = {
+      params: {
+        unit: { id: 1 },
+        sensor: { id: 1 },
+        side_menu: { id: 1, name: 'Setup generate pass code' },
+      },
+    };
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    await chooseUser(instance);
+    await onPressSubmitData(instance);
+    expect(spyToastError).toBeCalled();
+
+    await enterPasscode(instance);
+    await onPressSubmitData(instance);
+    expect(spyToastSuccess).toBeCalled();
+  });
+});

package/src/screens/SideMenuDetail/index.js

@@ -0,0 +1,148 @@
+import React, { memo, useCallback, useEffect, useState } from 'react';
+import { View, ScrollView } from 'react-native';
+import { useTranslations } from '../../hooks/Common/useTranslations';
+
+import styles from './SideMenuDetailStyles';
+import { HeaderCustom } from '../../commons/Header';
+import BottomButtonView from '../../commons/BottomButtonView';
+import { axiosGet, axiosPost } from '../../utils/Apis/axios';
+import { API } from '../../configs';
+import PasscodeField from '../../commons/FieldTemplate/PasscodeField';
+import ChooseUserField from '../../commons/FieldTemplate/ChooseUserField';
+import ScheduleField from '../../commons/FieldTemplate/ScheduleField';
+import { TESTID } from '../../configs/Constants';
+import { ToastBottomHelper } from '../../utils/Utils';
+import { useNavigation } from '@react-navigation/native';
+
+const SideMenuDetail = memo(({ route }) => {
+  const t = useTranslations();
+  const { goBack } = useNavigation();
+  const { unit, sensor, side_menu } = route?.params || {};
+  const [sideMenu, setSideMenu] = useState({});
+  const [dataForm, setDataForm] = useState([]);
+
+  const renderTemplateField = useCallback(
+    (item, index) => {
+      const keyItem = item.key;
+      const dataItem = item;
+      switch (item.type) {
+        case 'choose_user':
+          return (
+            <ChooseUserField
+              key={index} // Todo avoid waring unique "key" prop
+              unit={unit}
+              dataItem={dataItem}
+              index={index}
+              setDataForm={setDataForm}
+              dataForm={dataForm}
+            />
+          );
+        case 'passcode':
+          return (
+            <PasscodeField
+              key={index}
+              dataItem={dataItem}
+              index={index}
+              setDataForm={setDataForm}
+              dataForm={dataForm}
+            />
+          );
+        case 'schedule':
+          return (
+            <ScheduleField
+              key={index}
+              dataItem={dataItem}
+              keyItem={keyItem}
+              setDataForm={setDataForm}
+              dataForm={dataForm}
+            />
+          );
+        default:
+          return null;
+      }
+    },
+    [unit, dataForm]
+  );
+
+  const onPressSubmit = useCallback(async () => {
+    const data = {};
+    const actionZigbee = [];
+    for (let i = 0; i < dataForm.length; i++) {
+      if (!dataForm[i].valid) {
+        ToastBottomHelper.error(t('invaild_data'));
+        return;
+      }
+      if (dataForm[i].data) {
+        data[dataForm[i].key] = dataForm[i].data;
+        if (
+          dataForm[i].action_zigbee &&
+          !actionZigbee.includes(dataForm[i].action_zigbee)
+        ) {
+          actionZigbee.push(dataForm[i].action_zigbee);
+        }
+      } else {
+        data[dataForm[i].key] = null;
+      }
+    }
+
+    data.action_zigbee = actionZigbee;
+
+    const { success } = await axiosPost(API.DEVICE.TRIGGER_ACTION(sensor.id), {
+      key: sideMenu.action,
+      data,
+      source: 'smart_lock',
+    });
+
+    if (success) {
+      ToastBottomHelper.success(t('activated_successfully'));
+      goBack();
+    } else {
+      ToastBottomHelper.error(t('activation_failed'));
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [dataForm]);
+
+  const fetchSideMenuDetail = useCallback(async () => {
+    const { success, data } = await axiosGet(
+      API.DEVICE.SIDE_MENU_DETAIL(sensor.id, side_menu.id)
+    );
+    if (success) {
+      setSideMenu(data);
+      setDataForm(data.fields);
+    }
+  }, [sensor.id, side_menu.id]);
+
+  useEffect(() => {
+    fetchSideMenuDetail();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  return (
+    <View style={styles.container}>
+      <HeaderCustom
+        title={side_menu.name}
+        titleStyle={styles.title}
+        isShowSeparator
+      />
+      <ScrollView
+        showsVerticalScrollIndicator={false}
+        showsHorizontalScrollIndicator={false}
+        style={styles.scrollview}
+      >
+        <View style={styles.wrap}>
+          {dataForm.map((item, index) => {
+            return renderTemplateField(item, index);
+          })}
+        </View>
+      </ScrollView>
+      <BottomButtonView
+        style={styles.viewBottomFixed}
+        testIDPrefix={TESTID.SUBMIT}
+        mainTitle={t('done')}
+        onPressMain={onPressSubmit}
+      />
+    </View>
+  );
+});
+
+export default SideMenuDetail;

package/src/screens/SmartIr/components/GroupButtonByType/GroupButtonByType.js

@@ -1,5 +1,5 @@
 import React, { memo, useCallback, useState, useMemo } from 'react';
-import { View, TouchableOpacity, Alert } from 'react-native';
+import { View, TouchableOpacity } from 'react-native';
 import WrapHeaderScrollable from '../../../../commons/Sharing/WrapHeaderScrollable';
 import { useTranslations } from '../../../../hooks/Common/useTranslations';
 import SmartTiviActionTemplate from '../../../../commons/ActionGroup/SmartTiviActionTemplate/SmartTiviActionTemplate';
@@ -14,6 +14,7 @@ import { Remote, SmartIr, Union } from '../../../../Images/SmartIr';
 
 import styles from './GroupButtonByTypeStyles';
 import { TESTID } from '../../../../configs/Constants';
+import { notImplemented } from '../../../../utils/Utils';
 
 const GroupButtonByType = memo(({ route }) => {
   const t = useTranslations();
@@ -38,7 +39,7 @@ const GroupButtonByType = memo(({ route }) => {
         case 'reload':
         case 'more':
         case 'done':
-          return Alert.alert(t('feature_under_development'));
+          return notImplemented(t);
         default:
           return <></>;
       }