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

package/src/screens/AddNewGateway/SelectDeviceType.js

@@ -14,13 +14,19 @@ import AddZigbeeDeviceIcon from '../../../assets/images/AddNewDevice/add-zigbee-
 import styles from './SelectDeviceTypeStyles';
 import AccessibilityLabel from '../../configs/AccessibilityLabel';
 import { DEVICE_TYPE } from '../../configs/Constants';
+import { useBackendPermission } from '../../utils/Permission/backend';
+import { axiosGet } from '../../utils/Apis/axios';
+import API from '../../configs/API';
+import { ToastBottomHelper } from '../../utils/Utils';
 
 const SelectDeviceGrid = ({ options, onSelect }) => {
   const [selectIndexes, setSelectIndexes] = useState();
   const onSelectOption = useCallback(
     (value) => () => {
+      if (onSelect(value) === false) {
+        return;
+      }
       setSelectIndexes(value);
-      onSelect(value);
     },
     [onSelect]
   );
@@ -51,17 +57,33 @@ const SelectDeviceGrid = ({ options, onSelect }) => {
   );
 };
 
+const getPermissionCode = (deviceType) => {
+  switch (deviceType) {
+    case 'gateway_qr':
+      return 'plug_and_play_gateway';
+    case 'wifi_device_qr':
+      return 'plug_and_play_wifi';
+    case 'modbus_device_qr':
+      return 'plug_and_play_modbus';
+    case 'zigbee':
+    default:
+      return 'plug_and_play_zigbee';
+  }
+};
+
 const SelectDeviceType = ({ route }) => {
   const t = useTranslations();
   const { unit, subUnit } = route?.params || {};
   const { navigate, goBack } = useNavigation();
+  const [unitCountSummary, setUnitCountSummary] = useState();
   const [addType, setAddType] = useState();
   const [selectedAddType, setSelectedAddType] = useState();
+  const permissions = useBackendPermission();
 
   const listDeviceType = useMemo(() => {
     const list = [
       {
-        id: 1,
+        id: 'gateway_qr',
         image: <AddGatewayIcon width={60} height={60} />,
         route: Routes.ScanGatewayQR,
         data: {
@@ -71,7 +93,7 @@ const SelectDeviceType = ({ route }) => {
         subtitle: t('central_controller'),
       },
       {
-        id: 2,
+        id: 'wifi_device_qr',
         image: <AddWifiDeviceIcon width={60} height={60} />,
         route: subUnit?.id
           ? Routes.ScanWifiDeviceQR
@@ -85,7 +107,7 @@ const SelectDeviceType = ({ route }) => {
         subtitle: t('device_connect_without_gateway'),
       },
       {
-        id: 3,
+        id: 'modbus_device_qr',
         image: <AddModbusDeviceIcon width={60} height={60} />,
         route: subUnit?.id ? Routes.ScanModbusQR : Routes.SelectDeviceSubUnit,
         data: {
@@ -97,7 +119,7 @@ const SelectDeviceType = ({ route }) => {
         subtitle: t('device_connect_directly_to_the_gateway'),
       },
       {
-        id: 4,
+        id: 'zigbee',
         image: <AddZigbeeDeviceIcon width={60} height={60} />,
         route: subUnit?.id
           ? Routes.ConnectRouterGuide
@@ -111,19 +133,43 @@ const SelectDeviceType = ({ route }) => {
         subtitle: t('device_connect_remotely_to_the_gateway'),
       },
     ];
-    if (!!subUnit?.id) {
+    if (subUnit?.id) {
       list.shift();
     }
     return list;
   }, [unit, t, subUnit]);
 
   const onRight = useCallback(() => {
-    if (selectedAddType?.route && selectedAddType?.data) {
-      navigate(selectedAddType?.route, selectedAddType?.data);
+    if (!selectedAddType?.route) {
+      return;
     }
+
+    navigate(selectedAddType?.route, selectedAddType?.data);
   }, [navigate, selectedAddType?.data, selectedAddType?.route]);
 
   const handleOnSelect = (itemSelect) => {
+    const needPermission = getPermissionCode(itemSelect);
+    if (!permissions?.[needPermission]) {
+      ToastBottomHelper.error(t(`no_permission_${needPermission}`));
+      return false;
+    }
+
+    if (['gateway_qr', 'wifi_device_qr'].includes(itemSelect)) {
+      if (permissions?.max_chips_per_unit <= unitCountSummary?.total_chips) {
+        ToastBottomHelper.error(t('reach_max_chips_per_unit'));
+        return false;
+      }
+    }
+
+    if (['wifi_device_qr', 'modbus_device_qr', 'zigbee'].includes(itemSelect)) {
+      if (
+        permissions?.max_configs_per_unit <= unitCountSummary?.total_configs
+      ) {
+        ToastBottomHelper.error(t('reach_max_configs_per_unit'));
+        return false;
+      }
+    }
+
     setAddType(itemSelect);
   };
 
@@ -131,6 +177,18 @@ const SelectDeviceType = ({ route }) => {
     setSelectedAddType(listDeviceType.find((item) => item.id === addType));
   }, [addType, listDeviceType]);
 
+  useEffect(() => {
+    const fetchCountSummary = async () => {
+      const { success, data } = await axiosGet(API.DEV_MODE.GATEWAY.COUNT(), {
+        unit: unit?.id,
+      });
+      if (success) {
+        setUnitCountSummary(data);
+      }
+    };
+    fetchCountSummary();
+  }, [unit?.id]);
+
   return (
     <View style={styles.container}>
       <HeaderCustom title={t('choose_type_of_device')} isShowSeparator />
@@ -141,7 +199,7 @@ const SelectDeviceType = ({ route }) => {
         leftTitle={t('cancel')}
         onLeftClick={goBack}
         rightTitle={t('text_next')}
-        rightDisabled={!addType}
+        rightDisabled={!unitCountSummary || !addType}
         onRightClick={onRight}
       />
     </View>

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

@@ -121,4 +121,39 @@ describe('Test connecting modbus device', () => {
       sensorId: 1,
     });
   });
+
+  it('receive sensor from channel after rejoin zigbee', async () => {
+    mock.onPost().reply(200, {});
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const channels = getPusher().channels;
+    let channel;
+    for (const key in channels) {
+      if (key.indexOf('cache-') === 0) {
+        channel = channels[key];
+      }
+    }
+    await act(async () => {
+      await channel.trigger('progress', {
+        data: { sensor: { id: 1, name: 'sensor' }, type: 'rejoin' },
+      });
+    });
+    await act(async () => {
+      await channel.trigger('progress', { success: 1 });
+    });
+    expect(mockedNavigate).toHaveBeenCalledWith(Routes.RenameNewDevices, {
+      addDeviceType: undefined,
+      unit: {
+        id: 1,
+      },
+      subUnit: {
+        id: 2,
+        station: 'Station 2',
+      },
+      chipId: 3,
+      sensorId: 1,
+      isRejoin: true,
+    });
+  });
 });

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/AddNewAction/NewActionWrapper.js

@@ -1,5 +1,5 @@
 import React, { useCallback, useMemo } from 'react';
-import { KeyboardAvoidingView, Platform, TouchableOpacity } from 'react-native';
+import { TouchableOpacity, View } from 'react-native';
 
 import styles from './Styles/SelectActionStyles';
 import WrapHeaderScrollable from '../../../commons/Sharing/WrapHeaderScrollable';
@@ -32,10 +32,7 @@ const NewActionWrapper = ({ name, children, canNext, onNext, nextTitle }) => {
   );
 
   return (
-    <KeyboardAvoidingView
-      behavior={Platform.OS === 'ios' ? 'padding' : 'height'}
-      style={styles.wrap}
-    >
+    <View style={styles.wrap}>
       <WrapHeaderScrollable
         title={name}
         headerAniStyle={styles.headerAniStyle}
@@ -49,7 +46,7 @@ const NewActionWrapper = ({ name, children, canNext, onNext, nextTitle }) => {
         onPressMain={onNext}
         typeMain={canNext ? 'primary' : 'disabled'}
       />
-    </KeyboardAvoidingView>
+    </View>
   );
 };
 

package/src/screens/Automate/AddNewAction/SetupConfigCondition.js

@@ -7,11 +7,11 @@ import { Colors, Images } from '../../../configs';
 import { useTranslations } from '../../../hooks/Common/useTranslations';
 import { ModalCustom } from '../../../commons/Modal';
 import Text from '../../../commons/Text';
-import { HorizontalPicker } from '../../../commons';
 import { setStatusBarPreview } from '../../../hooks/Common/useStatusBar';
 import Routes from '../../../utils/Route';
 import NewActionWrapper from './NewActionWrapper';
 import _TextInput from '../../../commons/Form/TextInput';
+import { ToastBottomHelper } from '../../../utils/Utils';
 
 const SetupConfigCondition = () => {
   const t = useTranslations();
@@ -22,7 +22,7 @@ const SetupConfigCondition = () => {
 
   const [isShowModal, setIsShowModal] = useState(false);
   const [itemActiveModal, setItemActiveModal] = useState(defaultCondition);
-  const [value, setValue] = useState(defaultCondition?.value);
+  const [value, setValue] = useState(defaultCondition?.value || '');
 
   const hasNoValueEvaluation = !item?.evaluate_configuration;
 
@@ -68,6 +68,27 @@ const SetupConfigCondition = () => {
   };
 
   const onSave = useCallback(() => {
+    const conditionValue = parseFloat(itemActiveModal?.value);
+    if (isNaN(conditionValue)) {
+      ToastBottomHelper.error(t('value_must_be_a_number'));
+      return;
+    }
+
+    if (['<', '>', '='].includes(itemActiveModal?.condition)) {
+      if (item.range_min !== null && conditionValue < item.range_min) {
+        ToastBottomHelper.error(
+          t('value_must_be_greater_than_min', { min: item.range_min })
+        );
+        return;
+      }
+      if (item.range_max !== null && conditionValue > item.range_max) {
+        ToastBottomHelper.error(
+          t('value_must_be_less_than_max', { max: item.range_max })
+        );
+        return;
+      }
+    }
+
     navigate({
       name: Routes.ChooseConfig,
       merge: true,
@@ -78,7 +99,7 @@ const SetupConfigCondition = () => {
         },
       },
     });
-  }, [item.id, itemActiveModal, navigate]);
+  }, [item.id, item.range_max, item.range_min, itemActiveModal, navigate, t]);
 
   useEffect(() => {
     !hasNoValueEvaluation && setValue(1);
@@ -98,12 +119,9 @@ const SetupConfigCondition = () => {
     );
   }, [isShowModal]);
 
-  const onChangeValue = useCallback((v) => {
-    const newValue = parseInt(v, 10);
-    if (!isNaN(newValue)) {
-      setValue(newValue);
-      setItemActiveModal((prev) => ({ ...prev, value: newValue }));
-    }
+  const onChangeValue = useCallback((newValue) => {
+    setValue(newValue);
+    setItemActiveModal((prev) => ({ ...prev, value: newValue }));
   }, []);
 
   return (
@@ -136,7 +154,8 @@ const SetupConfigCondition = () => {
                 <_TextInput
                   textInputStyle={styles.value}
                   wrapStyle={styles.wrapValue}
-                  value={value?.toString()}
+                  value={value}
+                  keyboardType={'numeric'}
                   onChange={onChangeValue}
                 />
               </View>
@@ -144,25 +163,6 @@ const SetupConfigCondition = () => {
                 {item?.unit}
               </Text>
             </View>
-            <HorizontalPicker
-              minimum={item?.range_min}
-              maximum={item?.range_max}
-              segmentSpacing={8}
-              segmentWidth={8}
-              step={
-                item?.decimal_behind
-                  ? 1 / Math.pow(10, item?.decimal_behind)
-                  : 1
-              }
-              normalHeight={4}
-              normalWidth={4}
-              stepHeight={12}
-              stepWidth={12}
-              stepColor={Colors.Gray6}
-              normalColor={Colors.Gray6}
-              onChangeValue={onChangeValue}
-              value={value}
-            />
           </>
         )}
       </NewActionWrapper>