@eohjsc/react-native-smart-city 0.2.82 → 0.2.85

package/src/iot/RemoteControl/Internet.js

@@ -4,7 +4,13 @@ import { ToastBottomHelper } from '../../utils/Utils';
 import { axiosPost } from '../../utils/Apis/axios';
 import { API } from '../../configs';
 
-export const sendCommandOverInternet = async (sensor, action, data, source) => {
+export const sendCommandOverInternet = async (
+  sensor,
+  action,
+  data,
+  source,
+  actionName
+) => {
   if (data !== null) {
     if (Number.isInteger(data)) {
       data = data.toString(16).toUpperCase();
@@ -15,6 +21,7 @@ export const sendCommandOverInternet = async (sensor, action, data, source) => {
     key: action.key,
     data,
     source,
+    action_name: actionName,
   });
   if (success) {
     ToastBottomHelper.success(t('Command is sent to device via internet'));

package/src/iot/RemoteControl/index.js

@@ -12,7 +12,8 @@ export const sendRemoteCommand = async (
   sensor,
   action,
   data,
-  userId = null
+  userId = null,
+  actionName
 ) => {
   // No action, raise not authorized
   let result = false;
@@ -31,7 +32,8 @@ export const sendRemoteCommand = async (
           sensor,
           action,
           data,
-          'bluetooth'
+          'bluetooth',
+          actionName
         );
       } else {
         throw err;

package/src/navigations/AddDeviceStack.js

@@ -3,9 +3,11 @@ import React, { memo } from 'react';
 
 import AddCommonSelectUnit from '../screens/AddCommon/SelectUnit';
 import AddCommonSelectSubUnit from '../screens/AddCommon/SelectSubUnit';
+import AddGatewaySelectGateway from '../screens/AddNewGateway/SelectGateway';
 import AddNewDevice from '../screens/AddNewDevice';
 import ConnectDevices from '../screens/AddNewDevice/ConnectDevices';
 import ConnectingDevices from '../screens/AddNewDevice/ConnectingDevices';
+import ConnectingProcess from '../commons/ConnectingProcess';
 import ScanSensorQR from '../screens/ScanSensorQR';
 import Route from '../utils/Route';
 import { screenOptions } from './utils';
@@ -28,6 +30,14 @@ export const AddDeviceStack = memo(() => {
         name={Route.AddCommonSelectSubUnit}
         component={AddCommonSelectSubUnit}
       />
+      <Stack.Screen
+        name={Route.AddGatewaySelectGateway}
+        component={AddGatewaySelectGateway}
+      />
+      <Stack.Screen
+        name={Route.ConnectingProcess}
+        component={ConnectingProcess}
+      />
       <Stack.Screen name={Route.AddNewDevice} component={AddNewDevice} />
       <Stack.Screen name={Route.ScanSensorQR} component={ScanSensorQR} />
       <Stack.Screen

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'));
@@ -102,6 +111,17 @@ const AddCommonSelectSubUnit = ({ route }) => {
           ),
         });
         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 +130,7 @@ const AddCommonSelectSubUnit = ({ route }) => {
     navigation,
     subUnits,
     selectedIndex,
-    unit?.name,
-    unit.user_id,
+    unit,
     route.params,
     nameSubUnit,
     sensor_data,
@@ -121,6 +140,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 +155,6 @@ const AddCommonSelectSubUnit = ({ route }) => {
       setSelectedIndex(-1);
     }
   };
-
   const addSubUnit = useCallback(() => {
     navigation.navigate(Routes.AddSubUnitStack, {
       screen: Routes.AddSubUnit,
@@ -159,14 +182,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-stg.vconnex.vn/oauth/authorize?client_id=&redirect_uri=&response_type=code&scope=SYNCH&scope=CONTROL&scope=QUERY&state=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/SelectAction.js

@@ -148,38 +148,56 @@ const SelectAction = memo(({ route }) => {
     checkedItem,
     t,
   ]);
-
   const onSave = useCallback(async () => {
     if (isSelectSensor) {
       await checkConditionToContinue();
     } else {
-      let list_action = [...actions];
-      list_action = list_action.map((item) => ({
-        action: item.action,
-        data: item.data,
-      }));
-      const { success } = await axiosPost(
-        API.AUTOMATE.ADD_SCRIPT_ACTION(automateId),
-        {
-          list_action,
-          unit: unit.id,
+      if (automateId) {
+        let list_action = [...actions];
+        list_action = list_action.map((item) => ({
+          action: item.action,
+          data: item.data,
+        }));
+        const { success } = await axiosPost(
+          API.AUTOMATE.ADD_SCRIPT_ACTION(automateId),
+          {
+            list_action,
+            unit: unit.id,
+          }
+        );
+        if (!success) {
+          ToastBottomHelper.error(t('not_permission'));
         }
-      );
-      if (!success) {
-        ToastBottomHelper.error(t('not_permission'));
+        navigate(Routes.ScriptDetail, {
+          id: automateId,
+          name: scriptName,
+          havePermission: true,
+          unit,
+          saveAt: moment().valueOf(),
+          type: type,
+          isAutomateTab,
+          isCreateNewAction,
+          isMultiUnits,
+          automate,
+        });
+      } else {
+        navigate(Routes.AddNewOneTap, {
+          automateData: {
+            action: actions[0].action,
+          },
+          type,
+          unit,
+          isAutomateTab,
+          isSelectSensor,
+          isMultiUnits,
+          automateId,
+          automate: {
+            ...automate,
+            action: actions[0].action,
+          },
+          scriptName,
+        });
       }
-      navigate(Routes.ScriptDetail, {
-        id: automateId,
-        name: scriptName,
-        havePermission: true,
-        unit,
-        saveAt: moment().valueOf(),
-        type: type,
-        isAutomateTab,
-        isCreateNewAction,
-        isMultiUnits,
-        automate,
-      });
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
@@ -284,14 +302,14 @@ const SelectAction = memo(({ route }) => {
     () => (
       <BottomButtonView
         style={styles.bottomButtonView}
-        mainTitle={t(isSelectSensor ? 'continue' : 'save')}
+        mainTitle={t(automateId ? 'save' : 'continue')}
         onPressMain={onSave}
         typeMain={
           actions.length > 0 || !!checkedItem?.id ? 'primary' : 'disabled'
         }
       />
     ),
-    [onSave, actions, checkedItem, isSelectSensor, t]
+    [t, automateId, onSave, actions.length, checkedItem?.id]
   );
 
   useEffect(() => {

package/src/screens/AddNewAutoSmart/__test__/AddNewAutoSmart.test.js

@@ -3,7 +3,7 @@ import { act, create } from 'react-test-renderer';
 import AddNewAutoSmart from '..';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
-import { TESTID } from '../../../configs/Constants';
+import { AUTOMATE_TYPE, TESTID } from '../../../configs/Constants';
 import ItemAutomate from '../../../commons/Automate/ItemAutomate';
 import Routes from '../../../utils/Route';
 
@@ -34,7 +34,7 @@ describe('test AddNewAutoSmart', () => {
   let tree;
   let route = {
     params: {
-      type: 'value_change',
+      type: AUTOMATE_TYPE.VALUE_CHANGE,
       unit: { id: 1 },
     },
   };
@@ -49,7 +49,7 @@ describe('test AddNewAutoSmart', () => {
     });
     const instance = tree.root;
     const items = instance.findAllByType(ItemAutomate);
-    expect(items).toHaveLength(2);
+    expect(items).toHaveLength(3);
 
     await act(async () => {
       await items[0].props.onPress();

package/src/screens/AddNewAutoSmart/index.js

@@ -42,6 +42,13 @@ const AddNewAutoSmart = memo(({ route }) => {
         type: AUTOMATE_TYPE.SCHEDULE,
         route: Routes.SetSchedule,
       },
+      {
+        type: AUTOMATE_TYPE.EVENT,
+        route: Routes.SelectSensorDevices,
+        data: {
+          title: AUTOMATE_SELECT.SELECT_DEVICE,
+        },
+      },
     ],
     [AUTOMATE_TYPE.VALUE_CHANGE]: [
       {
@@ -55,6 +62,13 @@ const AddNewAutoSmart = memo(({ route }) => {
         type: AUTOMATE_TYPE.SCHEDULE,
         route: Routes.SetSchedule,
       },
+      {
+        type: AUTOMATE_TYPE.EVENT,
+        route: Routes.SelectSensorDevices,
+        data: {
+          title: AUTOMATE_SELECT.SELECT_DEVICE,
+        },
+      },
     ],
     [AUTOMATE_TYPE.ONE_TAP_ONLY]: [
       {
@@ -84,7 +98,10 @@ const AddNewAutoSmart = memo(({ route }) => {
       scriptName,
     };
 
-    if (dataAutomate.type === AUTOMATE_TYPE.VALUE_CHANGE && isMultiUnits) {
+    if (
+      (dataAutomate.type === AUTOMATE_TYPE.VALUE_CHANGE && isMultiUnits) ||
+      (dataAutomate.type === AUTOMATE_TYPE.EVENT && isMultiUnits)
+    ) {
       navigate(Routes.SelectUnit, params);
     } else {
       navigate(dataAutomate.route, params);

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,18 @@ 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 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 } =
+    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(
@@ -60,7 +69,7 @@ const ConnectWifiWarning = memo(({ route }) => {
         undefined
       );
     });
-    socket.on('message', function (msg, rinfo) {
+    socket.on('message', (msg, rinfo) => {
       const data = JSON.parse(msg.toString());
       if (data.hasOwnProperty('wifi')) {
         navigate(Routes.GatewayWifiList, {
@@ -70,28 +79,58 @@ const ConnectWifiWarning = memo(({ route }) => {
           socket: socket,
         });
       }
+    });
+    socket.on('message', (msg, rinfo) => {
+      const data = JSON.parse(msg.toString());
       if (data.hasOwnProperty('gateway')) {
-        navigate(Routes.Dashboard);
-        ToastBottomHelper.success(t('completed'));
+        const checkWifiInterval = setInterval(() => {
+          // eslint-disable-next-line promise/prefer-await-to-then
+          WifiManager.getCurrentWifiSSID().then(async (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,
+                    scan_sensor_data: { ...body },
+                    gateway: data?.gateway,
+                    devicePrefixName: devicePrefixName,
+                    chip_id: chip_id,
+                  },
+                });
+                clearInterval(checkWifiInterval);
+              }
+            }
+          });
+        }, 3000);
       }
     });
     socket.on('error', () => {
       ToastBottomHelper.error(t('server_error'));
+      setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
       goBack();
     });
-    return () => {
-      socket.close();
-    };
   };
 
   const handleConnectWifiGateway = async () => {
     setIsLoading(true);
-    const { success } = await axiosPost(API.UNIT.ADD_GATEWAY(unit_id), {
-      chip: chip_id,
-    });
-    if (success) {
-      ToastBottomHelper.success(t('add_gateway_success'));
-    }
     // eslint-disable-next-line promise/prefer-await-to-then
     WifiManager.connectToProtectedSSID(wifi_ssid, wifi_pass, false).then(
       () => {