@eohjsc/react-native-smart-city 0.2.84 → 0.2.87

package/src/screens/AddCommon/SelectSubUnit.js

@@ -26,6 +26,11 @@ const AddCommonSelectSubUnit = ({ route }) => {
     smart_account_id_from_backend,
     username,
     brand,
+    scan_sensor_data,
+    gateway,
+    devicePrefixName,
+    wifi_ssid,
+    wifi_pass,
   } = route.params;
   const [selectedIndex, setSelectedIndex] = useState(-1);
   const [unit, setUnit] = useState([]);
@@ -45,6 +50,10 @@ const AddCommonSelectSubUnit = ({ route }) => {
       case 'AddVconnexDevice':
         setTitle(t('select_a_sub_unit'));
         break;
+      case 'AddDeviceNewFlow':
+        setTitle(t('text_select_sub_unit'));
+        setSubTitle(t('select_a_sub_unit_want_add_device'));
+        break;
       default:
         setTitle(t('add_new_gateway'));
         setSubTitle(t('select_a_sub_unit'));
@@ -98,10 +107,22 @@ const AddCommonSelectSubUnit = ({ route }) => {
             SCConfig.VCONNEX_CLIENT_ID,
             SCConfig.VCONNEX_REDIRECT_URI_APP,
             unit.user_id,
+            unit_id,
             subUnits[selectedIndex]?.id
           ),
         });
         break;
+      case 'AddDeviceNewFlow':
+        navigation.navigate(Routes.ConnectingProcess, {
+          station: subUnits[selectedIndex],
+          unit: unit,
+          scan_sensor_data: scan_sensor_data,
+          gateway: gateway,
+          devicePrefixName: devicePrefixName,
+          wifi_ssid: wifi_ssid,
+          wifi_pass: wifi_pass,
+        });
+        break;
       default:
         break;
     }
@@ -110,8 +131,7 @@ const AddCommonSelectSubUnit = ({ route }) => {
     navigation,
     subUnits,
     selectedIndex,
-    unit?.name,
-    unit.user_id,
+    unit,
     route.params,
     nameSubUnit,
     sensor_data,
@@ -121,6 +141,11 @@ const AddCommonSelectSubUnit = ({ route }) => {
     smart_account_id_from_backend,
     username,
     brand,
+    scan_sensor_data,
+    gateway,
+    devicePrefixName,
+    wifi_ssid,
+    wifi_pass,
   ]);
 
   const handleSelectIndex = (index) => {
@@ -131,7 +156,6 @@ const AddCommonSelectSubUnit = ({ route }) => {
       setSelectedIndex(-1);
     }
   };
-
   const addSubUnit = useCallback(() => {
     navigation.navigate(Routes.AddSubUnitStack, {
       screen: Routes.AddSubUnit,
@@ -159,14 +183,14 @@ const AddCommonSelectSubUnit = ({ route }) => {
               >
                 <RadioCircle
                   active={selectedIndex === index}
-                  testID={TESTID.SELECT_UNIT_RADIO_BUTTON}
+                  testID={TESTID.SELECT_SUBUNIT_RADIO_BUTTON}
                 />
                 <TouchableOpacity
                   style={styles.row}
                   onPress={() => handleSelectIndex(index)}
-                  testID={TESTID.SELECT_UNIT_SELECT}
+                  testID={TESTID.SELECT_SUBUNIT_SELECT}
                 >
-                  <Text style={styles.text} testID={TESTID.SELECT_UNIT_NAME}>
+                  <Text style={styles.text} testID={TESTID.SELECT_SUBUNIT_NAME}>
                     {item.name}
                   </Text>
                 </TouchableOpacity>

package/src/screens/AddCommon/SelectUnit.js

@@ -21,7 +21,7 @@ import { TESTID } from '../../configs/Constants';
 const AddCommonSelectUnit = ({ route }) => {
   const t = useTranslations();
   const navigation = useNavigation();
-  const { addType } = route.params;
+  const { addType, scan_sensor_data } = route.params;
   const [selectedIndex, setSelectedIndex] = useState(-1);
   const [units, setUnits] = useState([]);
   const [title, setTitle] = useState('');
@@ -51,6 +51,10 @@ const AddCommonSelectUnit = ({ route }) => {
       case 'AddVconnexDevice':
         setTitle(t('text_select_a_unit'));
         break;
+      case 'AddDeviceNewFlow':
+        setTitle(t('text_select_a_unit'));
+        setSubTitle(t('text_select_a_unit_have_device'));
+        break;
       default:
         setTitle(t('add_new_sub_unit'));
         setSubTitle(t('add_new_subunit_select_unit'));
@@ -114,10 +118,28 @@ const AddCommonSelectUnit = ({ route }) => {
           },
         });
         break;
+      case 'AddDeviceNewFlow':
+        navigation.navigate(Routes.AddGatewaySelectGateway, {
+          unit_id: units[selectedIndex].id,
+          addType: 'AddDeviceNewFlow',
+          scan_sensor_data,
+        });
+        break;
       default:
         break;
     }
-  }, [addType, navigation, units, selectedIndex, route.params]);
+  }, [
+    addType,
+    navigation,
+    units,
+    selectedIndex,
+    route.params.code,
+    route.params.backend_url,
+    route.params.username,
+    route.params.password,
+    route.params.brand,
+    scan_sensor_data,
+  ]);
 
   const handleSelectIndex = (index) => {
     if (index !== selectedIndex) {

package/src/screens/AddCommon/__test__/SelectSubUnit.test.js

@@ -1,10 +1,13 @@
 import React from 'react';
 import renderer, { act } from 'react-test-renderer';
-
+import { TouchableOpacity } from 'react-native';
 import AddCommonSelectSubUnit from '../SelectSubUnit';
 import { ViewButtonBottom } from '../../../commons';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
+import Text from '../../../commons/Text';
+import axios from 'axios';
+import { TESTID } from '../../../configs/Constants';
 
 jest.mock('axios');
 
@@ -59,3 +62,119 @@ describe('Test SelectSubUnit', () => {
     expect(mockedNavigate).toHaveBeenCalled();
   });
 });
+describe('Test SelectSubUnit container', () => {
+  beforeEach(() => {
+    mockedNavigate.mockClear();
+    mockedGoBack.mockClear();
+  });
+  let tree;
+  const list_type = [
+    'AddNewGateway',
+    'AddHassiDevice',
+    'AddVconnexDevice',
+    'AddDeviceNewFlow',
+  ];
+  const result = [
+    'Select a sub-unit that you want to add this gateway',
+    '',
+    '',
+    'Then, select a sub-unit that you want to add this device in',
+  ];
+
+  list_type.forEach(function (type, i) {
+    test(`create SelectSubUnit ${type} container`, () => {
+      const route = { params: { addType: type } };
+      act(() => {
+        tree = renderer.create(wrapComponent(route));
+      });
+      const instance = tree.root;
+      const button = instance.findAllByType(TouchableOpacity);
+      expect(button.length).toBe(3);
+      const button1 = instance.findAllByType(Text);
+      expect(button1[1].props.children).toEqual(result[i]);
+    });
+    test(`press next to navigate ${type}`, async () => {
+      const route = { params: { addType: type } };
+      const response = {
+        status: 200,
+        success: true,
+        data: [
+          { id: 1, name: 'Unit 1' },
+          { id: 2, name: 'Unit 2' },
+        ],
+      };
+
+      axios.get.mockImplementation(async () => {
+        return response;
+      });
+
+      await act(async () => {
+        tree = renderer.create(wrapComponent(route));
+      });
+
+      const instance = tree.root;
+      const selectSubUnit = instance.findAllByType(TouchableOpacity);
+      await act(async () => {
+        selectSubUnit[1].props.onPress();
+      });
+
+      const next = instance.find(
+        (item) =>
+          item.props.testID ===
+          `${TESTID.PREFIX.SELECT_UNIT}${TESTID.VIEW_BUTTON_BOTTOM_RIGHT_BUTTON}`
+      );
+
+      await act(async () => {
+        next.props.onPress();
+      });
+
+      switch (type) {
+        case 'AddNewGateway':
+          expect(mockedNavigate).toBeCalledWith('ScanChipQR', {
+            addType: 'AddNewGateway',
+            station: undefined,
+          });
+          break;
+        case 'AddHassiDevice':
+          expect(mockedNavigate).toBeCalledWith('SmartAccountConnecting', {
+            unit_id: undefined,
+            brand: undefined,
+            listSelectDevice: undefined,
+            listSensorIds: undefined,
+            nameSubUnit: '',
+            sensor_data: undefined,
+            smart_account_id: undefined,
+            smart_account_id_from_backend: undefined,
+            station: undefined,
+            username: undefined,
+          });
+          break;
+        case 'AddVconnexDevice':
+          expect(mockedNavigate).toBeCalledWith('Browser', {
+            // eslint-disable-next-line max-len
+            link: 'https://partner-api.vconnex.vn/oauth/authorize?client_id=&redirect_uri=&response_type=code&scope=SYNCH&scope=CONTROL&scope=QUERY&state=undefined@undefined@undefined',
+          });
+          break;
+        case 'AddDeviceNewFlow':
+          expect(mockedNavigate).toBeCalledWith('ConnectingProcess', {
+            gateway: undefined,
+            scan_sensor_data: undefined,
+            station: undefined,
+            unit: [
+              {
+                id: 1,
+                name: 'Unit 1',
+              },
+              {
+                id: 2,
+                name: 'Unit 2',
+              },
+            ],
+          });
+          break;
+        default:
+          break;
+      }
+    });
+  });
+});

package/src/screens/AddCommon/__test__/SelectUnit.test.js

@@ -35,13 +35,21 @@ describe('Test SelectUnit container', () => {
     mockedGoBack.mockClear();
   });
   let tree;
-  const list_type = ['AddSubUnit', 'AddDevice', 'AddMember', 'AddLGDevice', ''];
+  const list_type = [
+    'AddSubUnit',
+    'AddDevice',
+    'AddMember',
+    'AddLGDevice',
+    '',
+    'AddDeviceNewFlow',
+  ];
   const result = [
     'Add new sub-unit',
     'Add new device',
     'Select a unit',
     'Select a unit',
     'Add new sub-unit',
+    'Select a unit',
   ];
   list_type.forEach(function (type, i) {
     test(`create SelectUnit ${type} container`, () => {
@@ -126,6 +134,13 @@ describe('Test SelectUnit container', () => {
             unit_id: 1,
           });
           break;
+        case 'AddDeviceNewFlow':
+          expect(mockedNavigate).toBeCalledWith('AddGatewaySelectGateway', {
+            unit_id: 1,
+            addType: 'AddDeviceNewFlow',
+            scan_sensor_data: undefined,
+          });
+          break;
         default:
           break;
       }

package/src/screens/AddNewAction/SelectSensorDevices.js

@@ -175,7 +175,7 @@ const SelectSensorDevices = memo(({ route }) => {
           {t(title)}
         </Text>
 
-        {!!listStation.length > 0 ? (
+        {listStation ? (
           <NavBar
             listStation={listStation}
             listMenuItem={listMenuItem}
@@ -185,7 +185,9 @@ const SelectSensorDevices = memo(({ route }) => {
           />
         ) : (
           <View style={styles.noneData}>
-            <Text center>{t('text_sub_unit_not_have_device')}</Text>
+            <Text center>
+              {t('you_do_not_have_the_device_or_have_share_control_device')}
+            </Text>
           </View>
         )}
 

package/src/screens/AddNewGateway/PlugAndPlay/ConnectWifiWarning.js

@@ -1,4 +1,10 @@
-import React, { memo, useEffect, useState, useCallback } from 'react';
+import React, {
+  memo,
+  useEffect,
+  useState,
+  useCallback,
+  useContext,
+} from 'react';
 import {
   View,
   StyleSheet,
@@ -16,15 +22,28 @@ import ScanQrGateway from '../../../../assets/images/scan-qr-gateway.svg';
 import { useTranslations } from '../../../hooks/Common/useTranslations';
 import { getBottomSpace } from 'react-native-iphone-x-helper';
 import BottomButtonView from '../../../commons/BottomButtonView';
-import { Colors, API } from '../../../configs';
-import { axiosPost } from '../../../utils/Apis/axios';
+import { Colors } from '../../../configs';
 import Routes from '../../../utils/Route';
+import { SCContext } from '../../../context';
+import { Action } from '../../../context/actionType';
+
+const isIos = Platform.OS === 'ios';
+const isAndroid = Platform.OS === 'android';
 
 const ConnectWifiWarning = memo(({ route }) => {
-  const { wifi_ssid, wifi_pass, unit_id, chip_id } = route.params;
+  const {
+    wifi_ssid,
+    wifi_pass,
+    unit_id,
+    chip_id,
+    devicePrefixName,
+    body,
+    unit_name,
+  } = route.params;
   const t = useTranslations();
   const { navigate, goBack } = useNavigation();
   const [isLoading, setIsLoading] = useState(false);
+  const { setAction } = useContext(SCContext);
 
   const getPermissionWifiAndroid = useCallback(async () => {
     const granted = await PermissionsAndroid.request(
@@ -44,57 +63,98 @@ const ConnectWifiWarning = memo(({ route }) => {
   }, [t]);
 
   useEffect(() => {
-    Platform.OS === 'android' && getPermissionWifiAndroid();
+    isAndroid && getPermissionWifiAndroid();
   }, [getPermissionWifiAndroid]);
 
-  const handleSend = () => {
+  const handleSend = async () => {
     const socket = dgram.createSocket({ type: 'udp4' });
-    socket.bind(54321);
-    socket.once('listening', function () {
-      socket.send(
-        JSON.stringify({ type: 'scan', data: { wifi: '' } }),
-        undefined,
-        undefined,
-        54321,
-        '192.168.27.1',
-        undefined
-      );
-    });
-    socket.on('message', (msg, rinfo) => {
+    await socket.bind(54321);
+    let intervalSend = null;
+    if (isIos) {
+      intervalSend = setInterval(() => {
+        socket.send(
+          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
+          undefined,
+          undefined,
+          54321,
+          '192.168.27.1',
+          undefined
+        );
+      }, 1000);
+    } else {
+      await socket.once('listening', async () => {
+        await socket.send(
+          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
+          undefined,
+          undefined,
+          54321,
+          '192.168.27.1',
+          undefined
+        );
+      });
+    }
+
+    await socket.on('message', (msg, rinfo) => {
+      isIos && clearInterval(intervalSend);
       const data = JSON.parse(msg.toString());
       if (data.hasOwnProperty('wifi')) {
         navigate(Routes.GatewayWifiList, {
           list_wifi: data.wifi,
           unit_id: unit_id,
           chip_id: chip_id,
+          scan_sensor_data: { ...body },
+          wifi_ssid: wifi_ssid,
+          wifi_pass: wifi_pass,
+          unit_name: unit_name,
+          devicePrefixName: devicePrefixName,
           socket: socket,
         });
       }
-      if (data.hasOwnProperty('gateway')) {
-        const checkWifiInterval = setInterval(() => {
-          // eslint-disable-next-line promise/prefer-await-to-then
-          WifiManager.getCurrentWifiSSID().then(async (ssid) => {
-            if (ssid !== wifi_ssid) {
-              const { success } = await axiosPost(
-                API.UNIT.ADD_GATEWAY(unit_id),
-                {
-                  chip: chip_id,
-                  imei: data.gateway.imei,
-                  chip_name: data.gateway.model,
+      if (isIos) {
+        if (data.hasOwnProperty('gateway')) {
+          const checkWifiInterval = setInterval(() => {
+            WifiManager.getCurrentWifiSSID().then((ssid) => {
+              if (ssid !== wifi_ssid) {
+                const IsRobot = devicePrefixName === 'ROBOT';
+                if (IsRobot) {
+                  setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+                  navigate(Routes.AddDeviceStack, {
+                    screen: Routes.AddCommonSelectSubUnit,
+                    params: {
+                      scan_sensor_data: { ...body },
+                      addType: 'AddDeviceNewFlow',
+                      gateway: data?.gateway,
+                      unit_id: unit_id,
+                      devicePrefixName: devicePrefixName,
+                      wifi_ssid: wifi_ssid,
+                      wifi_pass: wifi_pass,
+                    },
+                  });
+                  clearInterval(checkWifiInterval);
+                } else {
+                  setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+                  navigate(Routes.AddDeviceStack, {
+                    screen: Routes.ConnectingProcess,
+                    params: {
+                      unit_id: unit_id,
+                      unit_name: unit_name,
+                      scan_sensor_data: { ...body },
+                      gateway: data?.gateway,
+                      devicePrefixName: devicePrefixName,
+                      chip_id: chip_id,
+                    },
+                  });
+                  clearInterval(checkWifiInterval);
                 }
-              );
-              if (success) {
-                navigate(Routes.Dashboard);
-                ToastBottomHelper.success(t('add_gateway_success'));
-                clearInterval(checkWifiInterval);
               }
-            }
-          });
-        }, 3000);
+            });
+          }, 3000);
+        }
       }
     });
     socket.on('error', () => {
       ToastBottomHelper.error(t('server_error'));
+      setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
       goBack();
     });
   };

package/src/screens/AddNewGateway/PlugAndPlay/FirstWarning.js

@@ -9,15 +9,17 @@ import { ViewButtonBottom } from '../../../commons';
 import { Colors } from '../../../configs';
 
 const FirstWarning = memo(({ route }) => {
-  const { unit_id } = route.params;
+  const { unit_id, unit_name } = route.params;
   const t = useTranslations();
   const { goBack, navigate } = useNavigation();
 
   const onRight = useCallback(() => {
     navigate(Routes.ScanChipQR, {
       unit_id: unit_id,
+      unit_name: unit_name,
+      isNewFlow: true,
     });
-  }, [navigate, unit_id]);
+  }, [navigate, unit_name, unit_id]);
 
   return (
     <View style={styles.screen}>