@eohjsc/react-native-smart-city 0.3.93 → 0.3.94

package/src/screens/AddNewGateway/__test__/SelectDeviceType.test.js

@@ -8,36 +8,30 @@ import Routes from '../../../utils/Route';
 import { TouchableOpacity } from 'react-native';
 import AccessibilityLabel from '../../../configs/AccessibilityLabel';
 import { ViewButtonBottom } from '../../../commons';
-
-const wrapComponent = (route) => (
-  <SCProvider initState={mockSCStore({})}>
+import { useNavigation } from '@react-navigation/native';
+import MockAdapter from 'axios-mock-adapter';
+import api from '../../../utils/Apis/axios';
+import API from '../../../configs/API';
+import { ToastBottomHelper } from '../../../utils/Utils';
+import { getTranslate } from '../../../utils/I18n';
+const wrapComponent = (route, storeData = {}) => (
+  <SCProvider initState={mockSCStore(storeData)}>
     <SelectDeviceType route={route} />
   </SCProvider>
 );
 
-const mockedNavigate = jest.fn();
-const mockedGoBack = jest.fn();
-
-jest.mock('@react-navigation/native', () => {
-  return {
-    ...jest.requireActual('@react-navigation/native'),
-    useNavigation: () => ({
-      navigate: mockedNavigate,
-      goBack: mockedGoBack,
-    }),
-    useIsFocused: () => true,
-  };
-});
+const mock = new MockAdapter(api.axiosInstance);
 
 describe('Test select device type', () => {
   let tree;
   let route;
 
-  afterEach(() => {
-    mockedNavigate.mockClear();
-  });
+  const mockedNavigate = useNavigation().navigate;
+  const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
 
   beforeEach(() => {
+    spyToastError.mockClear();
+    mockedNavigate.mockClear();
     route = {
       params: {
         unitId: 1,
@@ -81,9 +75,9 @@ describe('Test select device type', () => {
     expect(deviceTypeItems).toHaveLength(3);
   });
 
-  const selectDeviceType = async (index) => {
+  const selectDeviceType = async (index, storeData = {}) => {
     await act(async () => {
-      tree = await create(wrapComponent(route));
+      tree = await create(wrapComponent(route, storeData));
     });
     const instance = tree.root;
     const deviceTypeItems = instance.findAll(
@@ -99,24 +93,184 @@ describe('Test select device type', () => {
     await act(async () => {
       submitButton.props.onRightClick();
     });
-
-    expect(mockedNavigate).toBeCalled();
   };
 
   it('select modbus', async () => {
-    await selectDeviceType(0);
-    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.ScanGatewayQR);
+    await selectDeviceType(2, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_modbus: true,
+            },
+          },
+        },
+      },
+    });
+    expect(mockedNavigate).toBeCalled();
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.SelectDeviceSubUnit);
   });
+
   it('select zigbee', async () => {
-    await selectDeviceType(1);
+    await selectDeviceType(3, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_zigbee: true,
+            },
+          },
+        },
+      },
+    });
+    expect(mockedNavigate).toBeCalled();
     expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.SelectDeviceSubUnit);
   });
+
+  it('select zigbee reach limit', async () => {
+    mock.onGet(API.DEV_MODE.GATEWAY.COUNT()).reply(200, {
+      total_chips: 1,
+      total_configs: 1,
+    });
+    await selectDeviceType(3, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              max_chips_per_unit: 1,
+              max_configs_per_unit: 1,
+              plug_and_play_zigbee: true,
+            },
+          },
+        },
+      },
+    });
+    expect(mockedNavigate).not.toBeCalled();
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'reach_max_configs_per_unit')
+    );
+  });
+
   it('select gateway', async () => {
-    await selectDeviceType(2);
-    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.SelectDeviceSubUnit);
+    await selectDeviceType(0, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_gateway: true,
+            },
+          },
+        },
+      },
+    });
+    expect(mockedNavigate).toBeCalled();
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.ScanGatewayQR);
+  });
+
+  it('select gateway reach limit', async () => {
+    mock.onGet(API.DEV_MODE.GATEWAY.COUNT()).reply(200, {
+      total_chips: 1,
+      total_configs: 1,
+    });
+    await selectDeviceType(0, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              max_chips_per_unit: 1,
+              plug_and_play_gateway: true,
+            },
+          },
+        },
+      },
+    });
+    expect(mockedNavigate).not.toBeCalled();
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'reach_max_chips_per_unit')
+    );
+  });
+
+  it('select gateway without permission', async () => {
+    await selectDeviceType(0, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_gateway: false,
+            },
+          },
+        },
+      },
+    });
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'no_permission_plug_and_play_gateway')
+    );
+  });
+
+  it('select zigbee without permission', async () => {
+    await selectDeviceType(3, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_zigbee: false,
+            },
+          },
+        },
+      },
+    });
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'no_permission_plug_and_play_zigbee')
+    );
   });
+
+  it('select wifi without permission', async () => {
+    await selectDeviceType(1, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_wifi: false,
+            },
+          },
+        },
+      },
+    });
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'no_permission_plug_and_play_wifi')
+    );
+  });
+
+  it('select modbus without permission', async () => {
+    await selectDeviceType(2, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_modbus: false,
+            },
+          },
+        },
+      },
+    });
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'no_permission_plug_and_play_modbus')
+    );
+  });
+
   it('select wifi', async () => {
-    await selectDeviceType(3);
+    await selectDeviceType(1, {
+      auth: {
+        account: {
+          user: {
+            permissions: {
+              plug_and_play_wifi: true,
+            },
+          },
+        },
+      },
+    });
+    expect(mockedNavigate).toBeCalled();
     expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.SelectDeviceSubUnit);
   });
 });

package/src/screens/Automate/MultiUnits.js

@@ -17,20 +17,17 @@ import { AUTOMATE_TABS, AUTOMATE_TYPE } from '../../configs/Constants';
 import ItemOneTap from '../../commons/SubUnit/OneTap/ItemOneTap';
 import Routes from '../../utils/Route';
 import ItemAddNew from '../../commons/Device/ItemAddNew';
+import { ToastBottomHelper } from '../../utils/Utils';
+import { useBackendPermission } from '../../utils/Permission/backend';
 
 const MultiUnits = () => {
   const t = useTranslations();
   const isFocused = useIsFocused();
   const { navigate } = useNavigation();
   const { params = {}, name: currentRouteName } = useRoute();
-  const {
-    isMultiUnits = false,
-    unitName = '',
-    unit,
-    isOwner,
-    newAutomate,
-  } = params;
+  const { unit, newAutomate } = params;
   const [data, setData] = useState([]);
+  const permissions = useBackendPermission();
 
   const [tabActive, setTabActive] = useState(AUTOMATE_TABS.SCENARIO);
 
@@ -40,20 +37,20 @@ const MultiUnits = () => {
 
   const getData = useCallback(
     async (fetchParams) => {
-      if (isMultiUnits) {
+      if (unit?.id) {
+        await fetchWithCache(API.UNIT.AUTOMATE(unit?.id), {}, (response) => {
+          const { success, data: automateData } = response;
+          success && setData(automateData);
+        });
+      } else {
         const { success, data: automateData } = await axiosGet(
           API.AUTOMATE.GET_MULTI_UNITS(),
           fetchParams
         );
         success && setData(automateData);
-      } else {
-        await fetchWithCache(API.UNIT.AUTOMATE(unit?.id), {}, (response) => {
-          const { success, data: automateData } = response;
-          success && setData(automateData);
-        });
       }
     },
-    [isMultiUnits, unit?.id]
+    [unit?.id]
   );
 
   const onPressTabName = (tab) => () => {
@@ -79,6 +76,12 @@ const MultiUnits = () => {
   }, [newAutomate, onPressItem]);
 
   const handleOnAddNew = useCallback(() => {
+    if (unit?.id) {
+      if (permissions?.max_automations_per_unit <= data.length) {
+        ToastBottomHelper.error(t('reach_max_automations_per_unit'));
+        return;
+      }
+    }
     if (tabActive === AUTOMATE_TABS.SCENARIO) {
       navigate(Routes.UnitStack, {
         screen: Routes.ScenarioName,
@@ -97,7 +100,15 @@ const MultiUnits = () => {
         closeScreen: currentRouteName,
       },
     });
-  }, [currentRouteName, navigate, tabActive, unit?.id]);
+  }, [
+    currentRouteName,
+    data.length,
+    navigate,
+    permissions?.max_automations_per_unit,
+    t,
+    tabActive,
+    unit?.id,
+  ]);
 
   const renderContent = useMemo(() => {
     const listItems = data.filter((item) =>
@@ -116,11 +127,10 @@ const MultiUnits = () => {
         {sortedListItems.map((item, index) => (
           <ItemOneTap
             key={(item?.id || index).toString()}
-            isOwner={isOwner}
             automate={item}
             wrapSyles={[
               styles.wrapAutomateItem,
-              index % 2 === 0 && styles.marginRigt8,
+              index % 2 === 0 && styles.itemOneTapMargin,
             ]}
             onPressItem={() => onPressItem(item)}
           />
@@ -142,7 +152,7 @@ const MultiUnits = () => {
   return (
     <View style={styles.wrap}>
       <WrapHeaderScrollable
-        title={isMultiUnits ? t('multi_units_automate') : unitName}
+        title={unit?.id ? unit?.name : t('multi_units_automate')}
         headerAniStyle={styles.headerAniStyle}
       >
         <View style={styles.wrapContent}>

package/src/screens/Automate/ScriptDetail/__test__/index.test.js

@@ -24,8 +24,8 @@ import Text from '../../../../commons/Text';
 import { ToastBottomHelper } from '../../../../utils/Utils';
 import { getTranslate } from '../../../../utils/I18n';
 
-const wrapComponent = (route) => (
-  <SCProvider initState={mockSCStore({})}>
+const wrapComponent = (route, storeData = {}) => (
+  <SCProvider initState={mockSCStore(storeData)}>
     <ScriptDetail route={route} />
   </SCProvider>
 );
@@ -241,6 +241,40 @@ describe('Test ScriptDetail', () => {
     });
   });
 
+  it('test press add action reach limit', async () => {
+    mock.onGet(API.AUTOMATE.SCRIPT(1)).reply(200, data);
+    await act(async () => {
+      tree = await create(
+        wrapComponent(route, {
+          auth: {
+            account: {
+              user: {
+                permissions: {
+                  max_actions_per_automation: 0,
+                },
+              },
+            },
+          },
+        })
+      );
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.BUTTON_ADD_SCRIPT_ACTION &&
+        el.type === TouchableOpacity
+    );
+    const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(mockNavigate).not.toBeCalled();
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'reach_max_actions_per_automation')
+    );
+  });
+
   it('test not see add action', async () => {
     route.params.preAutomate.can_edit = false;
     mock.onGet(API.AUTOMATE.SCRIPT(1)).reply(200, data);

package/src/screens/Automate/ScriptDetail/index.js

@@ -30,6 +30,7 @@ import { AccessibilityLabel, AUTOMATE_TYPE } from '../../../configs/Constants';
 import RenameScript from './Components/RenameScript';
 import DeleteScript from './Components/DeleteScript';
 import Images from '../../../configs/Images';
+import { useBackendPermission } from '../../../utils/Permission/backend';
 
 const PreventDoubleTouch = withPreventDoubleClick(TouchableOpacity);
 
@@ -122,9 +123,9 @@ const ScriptDetail = ({ route }) => {
   const handleScriptAction = useCallback(async () => {
     const { success } = await axiosPost(API.AUTOMATE.ACTION_ONE_TAP(id));
     if (success) {
-      ToastBottomHelper.success(t('Activated successfully.'));
+      ToastBottomHelper.success(t('activated_successfully'));
     } else {
-      ToastBottomHelper.error(t('Activation failed.'));
+      ToastBottomHelper.error(t('activation_failed'));
     }
   }, [id, t]);
 
@@ -296,9 +297,14 @@ const Item = ({ item, index }) => {
 const ItemAdd = ({ automate, index }) => {
   const t = useTranslations();
   const { navigate } = useNavigation();
+  const permissions = useBackendPermission();
   const { name: currentScreenName } = useRoute();
 
   const onPressAddAction = useCallback(() => {
+    if (permissions?.max_actions_per_automation <= index) {
+      ToastBottomHelper.error(t('reach_max_actions_per_automation'));
+      return;
+    }
     const navParams = {
       unitId: automate.unit,
       automateId: automate.id,
@@ -309,7 +315,15 @@ const ItemAdd = ({ automate, index }) => {
       automate.unit ? Routes.SelectControlDevices : Routes.SelectUnit,
       navParams
     );
-  }, [automate.unit, automate.id, currentScreenName, navigate]);
+  }, [
+    permissions?.max_actions_per_automation,
+    index,
+    automate.unit,
+    automate.id,
+    currentScreenName,
+    navigate,
+    t,
+  ]);
 
   return (
     <View style={styles.wrapItem}>

package/src/screens/Automate/Styles/MultiUnitsStyles.js

@@ -45,7 +45,7 @@ export default StyleSheet.create({
     flexDirection: 'row',
     flexWrap: 'wrap',
   },
-  marginRigt8: {
+  itemOneTapMargin: {
     marginRight: 8,
   },
   addNewItem: {

package/src/screens/Automate/__test__/MultiUnits.test.js

@@ -15,11 +15,12 @@ import { getTranslate } from '../../../utils/I18n';
 import { AUTOMATE_TYPE } from '../../../configs/Constants';
 import api from '../../../utils/Apis/axios';
 import { API } from '../../../configs';
+import { ToastBottomHelper } from '../../../utils/Utils';
 
 const mock = new MockAdapter(api.axiosInstance);
 
-const wrapComponent = () => (
-  <SCProvider initState={mockSCStore({})}>
+const wrapComponent = (storeData = {}) => (
+  <SCProvider initState={mockSCStore(storeData)}>
     <MultiUnits />
   </SCProvider>
 );
@@ -31,6 +32,7 @@ describe('Test MultiUnits', () => {
   beforeEach(() => {
     mockedNavigate.mockClear();
     useRoute.mockClear();
+    mock.reset();
   });
 
   it('Test is multi unit and current is Automation tab', async () => {
@@ -151,9 +153,7 @@ describe('Test MultiUnits', () => {
     mock.onGet(API.AUTOMATE.GET_MULTI_UNITS()).reply(200, response);
     useRoute.mockReturnValue({
       params: {
-        isMultiUnits: true,
-        unitName: null,
-        unit: null,
+        unit: {},
       },
     });
     await act(async () => {
@@ -180,9 +180,66 @@ describe('Test MultiUnits', () => {
     });
   });
 
+  it('create new smart but reach max', async () => {
+    const response = [
+      {
+        id: 1,
+        user: 223,
+        type: 'one_tap',
+        config: null,
+        value: null,
+        activate_at: '2021-09-22T14:16:54Z',
+        condition: null,
+        script: {
+          id: 1,
+          name: 'Tap to up down up down coc coc coc coc coc',
+          icon: null,
+          icon_kit:
+            'https://eoh-gateway-backend.eoh.io/_Category_Sensors_Type_Garage_door_StyleC_olorful.png',
+        },
+      },
+    ];
+    mock.onGet(API.UNIT.AUTOMATE(1)).reply(200, response);
+    useRoute.mockReturnValue({
+      params: {
+        unit: { id: 1 },
+      },
+    });
+    await act(async () => {
+      tree = await create(
+        wrapComponent({
+          auth: {
+            account: {
+              user: {
+                permissions: {
+                  max_automations_per_unit: 0,
+                },
+              },
+            },
+          },
+        })
+      );
+    });
+    const instance = tree.root;
+    const itemAddNews = instance.findAllByType(ItemAddNew);
+    const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
+    await act(async () => {
+      itemAddNews[0].props.onAddNew();
+    });
+    expect(mockedNavigate).not.toBeCalled();
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'reach_max_automations_per_unit')
+    );
+  });
+
   it('Test is not multi unit', async () => {
     useRoute.mockReturnValue({
-      params: {},
+      params: {
+        unit: {
+          id: 1,
+          name: '',
+        },
+      },
     });
     await act(async () => {
       tree = await create(wrapComponent());

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

@@ -13,11 +13,13 @@ import { AccessibilityLabel } from '../../../configs/Constants';
 import api from '../../../utils/Apis/axios';
 import { API } from '../../../configs';
 import { useNavigation } from '@react-navigation/native';
+import { getTranslate } from '../../../utils/I18n';
+import { ToastBottomHelper } from '../../../utils/Utils';
 
 const mock = new MockAdapter(api.axiosInstance);
 
-const wrapComponent = () => (
-  <SCProvider initState={mockSCStore({})}>
+const wrapComponent = (storeData = {}) => (
+  <SCProvider initState={mockSCStore(storeData)}>
     <Automate />
   </SCProvider>
 );
@@ -100,6 +102,44 @@ describe('Test Automate', () => {
     });
   });
 
+  it('onPress onAddNew but reach limit', async () => {
+    mock.onGet(API.AUTOMATE.GET_SMART()).reply(200, [
+      {
+        type: 'MultiUnit',
+        unit_id: 1,
+        automates: [],
+      },
+    ]);
+
+    await act(async () => {
+      tree = await create(
+        wrapComponent({
+          auth: {
+            account: {
+              user: {
+                permissions: {
+                  max_automations_per_unit: 0,
+                },
+              },
+            },
+          },
+        })
+      );
+    });
+
+    const instance = tree.root;
+
+    const itemAddNew = instance.findByType(ItemAddNew);
+    const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
+    await act(async () => {
+      itemAddNew.props.onAddNew(1, []);
+    });
+    expect(mockedNavigate).not.toBeCalled();
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'reach_max_automations_per_unit')
+    );
+  });
+
   it('Test success get Automate onPressItem to ScriptDetail', async () => {
     const response = {
       status: 200,
@@ -193,10 +233,7 @@ describe('Test Automate', () => {
     });
 
     expect(mockedNavigate).toBeCalledWith(Routes.MultiUnits, {
-      isMultiUnits: true,
-      unitName: '',
-      unit: { id: undefined },
-      isOwner: true,
+      unit: { id: undefined, name: '' },
     });
 
     mockedNavigate.mockClear();
@@ -205,10 +242,7 @@ describe('Test Automate', () => {
     });
 
     expect(mockedNavigate).toBeCalledWith(Routes.MultiUnits, {
-      isMultiUnits: false,
-      unitName: 'La Vida',
-      unit: { id: 3 },
-      isOwner: false,
+      unit: { id: 3, name: 'La Vida' },
     });
   });
 });