@eohjsc/react-native-smart-city 0.3.58 → 0.3.60

package/src/commons/ModalPopupCT/styles.js

@@ -0,0 +1,95 @@
+import { StyleSheet } from 'react-native';
+import { Colors } from '../../configs';
+
+export default StyleSheet.create({
+  wrap: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  paddingBottom16: {
+    paddingBottom: 16,
+  },
+  modalPopupCT: {
+    backgroundColor: Colors.White,
+    padding: 24,
+    width: 343,
+    height: 'auto',
+    borderRadius: 16,
+  },
+  header: {
+    alignItems: 'flex-start',
+    justifyContent: 'flex-start',
+  },
+  alert: {
+    padding: 16,
+    borderRadius: 8,
+    borderWidth: 2,
+    borderColor: Colors.Orange8,
+    backgroundColor: Colors.Orange9,
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    marginBottom: 16,
+  },
+  viewIconAlert: {
+    paddingRight: 16,
+  },
+  viewTextAlert: {
+    flex: 1,
+    justifyContent: 'flex-start',
+  },
+  understand: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    paddingBottom: 16,
+  },
+  viewCheckboxUnderstand: {
+    alignItems: 'flex-start',
+    paddingRight: 16,
+  },
+  viewTextUnderstand: {
+    flex: 1,
+    justifyContent: 'flex-start',
+  },
+  body: {},
+  footer: {
+    paddingTop: 16,
+    borderTopWidth: 1,
+    borderTopColor: Colors.Neutral.Neutral3,
+  },
+  buttonBottom: {
+    flexDirection: 'row',
+    alignItems: 'flex-end',
+    justifyContent: 'flex-end',
+  },
+  buttonCancel: {
+    alignItems: 'center',
+    borderRadius: 8,
+    paddingVertical: 8,
+    paddingHorizontal: 16,
+    paddingTop: 12,
+    borderColor: Colors.Neutral.Neutral3,
+    borderWidth: 1,
+  },
+  buttonConfirm: {
+    position: 'relative',
+    marginLeft: 8,
+    alignItems: 'center',
+    borderRadius: 8,
+    paddingVertical: 8,
+    paddingHorizontal: 16,
+    paddingTop: 12,
+    backgroundColor: Colors.Red,
+  },
+  disableButton: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: Colors.White,
+    opacity: 0.7,
+  },
+});

package/src/configs/API.js

@@ -208,12 +208,16 @@ const API = {
   },
   // NOTE: DEV MODE
   DEV_MODE: {
-    GET_TEMPLATES: '/property_manager/iot_dashboard/dev_mode/templates/',
-    GET_WIDGETS: (templateId) =>
-      `/property_manager/iot_dashboard/dev_mode/templates/${templateId}/widgets/`,
+    DASHBOARD: {
+      DETAIL: (id) => `/property_manager/iot_dashboard/dev_mode/units/${id}/`,
+      GET_TEMPLATES: '/property_manager/iot_dashboard/dev_mode/units/',
+      GET_WIDGETS: (templateId) =>
+        `/property_manager/iot_dashboard/dev_mode/units/${templateId}/widgets/`,
+    },
     GATEWAY: {
       LIST: () => '/chip_manager/developer_mode_chips/',
       DETAIL: (id) => `/chip_manager/developer_mode_chips/${id}/`,
+      REBOOT: (id) => `/chip_manager/developer_mode_chips/${id}/reboot_chip/`,
     },
     ZIGBEE: {
       SEARCH_DEVICE: (id) => `/iot/modules/zigbee/chips/${id}/search_device/`,

package/src/configs/AccessibilityLabel.js

@@ -666,4 +666,6 @@ export default {
   //devmod
   TAB_PANE_CT_SCROLLVIEW: 'TAB_PANE_CT_SCROLLVIEW',
   ROW_ITEM_DEVMOD: 'ROW_ITEM_DEVMOD',
+  BUTTON_UNDERSTAND: 'BUTTON_UNDERSTAND',
+  MODAL_POPUP_CUSTOM: 'MODAL_POPUP_CUSTOM',
 };

package/src/configs/Colors.js

@@ -82,6 +82,8 @@ export const Colors = {
   Orange4: '#FFC069',
   Orange6: '#FA8C16',
   Orange7: '#FAAD14',
+  Orange8: '#FFCA80',
+  Orange9: '#FFEECC',
 
   //Red
   Red11: '#FFADA6',

package/src/context/actionType.ts

@@ -32,6 +32,7 @@ export const Action = {
   PERCENT_LOADED: 'PERCENT_LOADED',
   REFRESH_PERCENT: 'REFRESH_PERCENT',
   PROCESS_DONE: 'PROCESS_DONE',
+  IS_EMERGENCY_POPUP: 'IS_EMERGENCY_POPUP',
   // NOTE: DEV MODE
   SET_WIDGET_DRAGGING: 'SET_WIDGET_DRAGGING',
   SET_IS_EDITING_TEMPLATE: 'SET_IS_EDITING_TEMPLATE',

package/src/context/reducer.ts

@@ -67,6 +67,7 @@ export const initialState = {
     notificationData: null,
     popoverAnimating: false,
     isLockWhenPickColor: false,
+    isEmergencyPopupScreen: false,
   },
   iot: {
     bluetooth: {
@@ -427,6 +428,15 @@ export const reducer = (currentState: ContextData, action: Action) => {
         },
       };
 
+    case Action.IS_EMERGENCY_POPUP:
+      return {
+        ...currentState,
+        app: {
+          ...currentState.app,
+          isEmergencyPopupScreen: payload,
+        },
+      };
+
     case Action.SET_POPOVER_ANIMATING:
       return {
         ...currentState,

package/src/screens/AddNewGateway/ConnectingWifiDevice.js

@@ -73,8 +73,8 @@ const ConnectingWifiDevice = ({ route }) => {
 
   useEffect(() => {
     const unsubscribe = NetInfo.addEventListener((state) => {
-      if (state.isConnected && channelName) {
-        onReady(channelName);
+      if (state.isConnected) {
+        channelName && onReady(channelName);
       }
     });
     return () => unsubscribe && unsubscribe();

package/src/screens/AddNewGateway/RenameNewDevices.js

@@ -2,6 +2,7 @@ import React, { memo, useCallback, useEffect, useState, useMemo } from 'react';
 import { ScrollView, TouchableOpacity, View } from 'react-native';
 import { IconOutline } from '@ant-design/icons-react-native';
 import { CommonActions, useNavigation } from '@react-navigation/native';
+import debounce from 'lodash.debounce';
 
 import { useTranslations } from '../../hooks/Common/useTranslations';
 import { Colors } from '../../configs';
@@ -49,37 +50,41 @@ const RenameNewDevices = memo(({ route }) => {
     return baseHeight + contentItems * 25;
   }, [addDeviceType, info.sensors]);
 
-  const onPressDone = useCallback(async () => {
-    await axiosPost(API.CHIP.RENAME_DEVICES(info.id), info);
-    const resetAction = CommonActions.reset({
-      index: 0,
-      routes: [
-        {
-          name: Routes.Main,
-          params: {
-            screen: Routes.DashboardStack,
+  const callApiRenameDevices = useCallback(async () => {
+    const { success } = await axiosPost(API.CHIP.RENAME_DEVICES(info.id), info);
+    if (success) {
+      const resetAction = CommonActions.reset({
+        index: 0,
+        routes: [
+          {
+            name: Routes.Main,
             params: {
-              screen: Routes.Dashboard,
+              screen: Routes.DashboardStack,
+              params: {
+                screen: Routes.Dashboard,
+              },
             },
           },
-        },
-        {
-          name: Routes.UnitStack,
-          params: {
-            screen: Routes.UnitDetail,
+          {
+            name: Routes.UnitStack,
             params: {
-              unitId: unit?.id,
-              stationId: subUnit?.id,
-              isSuccessfullyConnected: true,
-              routeName: Routes.DashboardStack,
+              screen: Routes.UnitDetail,
+              params: {
+                unitId: unit?.id,
+                stationId: subUnit?.id,
+                isSuccessfullyConnected: true,
+                routeName: Routes.DashboardStack,
+              },
             },
           },
-        },
-      ],
-    });
-    dispatch(resetAction);
+        ],
+      });
+      dispatch(resetAction);
+    }
   }, [dispatch, info, subUnit?.id, unit?.id]);
 
+  const onPressDone = debounce(() => callApiRenameDevices(), 2000);
+
   useEffect(() => {
     (async () => {
       let params = new URLSearchParams();
@@ -193,7 +198,10 @@ const RenameNewDevices = memo(({ route }) => {
       );
     }
     return (
-      <View style={[styles.devicesWrapper, { height: scrollViewHeight }]}>
+      <View
+        style={[styles.devicesWrapper, { height: scrollViewHeight }]}
+        accessibilityLabel={`${renameLabel}_LIST_ITEM_RENAME`}
+      >
         <ScrollView>
           {(info?.sensors || []).map((sensor, sensor_index) =>
             (sensor?.end_devices || []).map((end_device, end_device_index) => (

package/src/screens/AddNewGateway/SelectDeviceSubUnit.js

@@ -16,19 +16,19 @@ const SelectDeviceSubUnit = ({ route }) => {
         case DEVICE_TYPE.WIFI_DEVICE:
           navigation.navigate(Routes.ScanWifiDeviceQR, {
             unit,
-            chosenSubUnit,
+            subUnit: chosenSubUnit,
           });
           break;
         case DEVICE_TYPE.MODBUS:
           navigation.navigate(Routes.ScanModbusQR, {
             unit,
-            chosenSubUnit,
+            subUnit: chosenSubUnit,
           });
           break;
         case DEVICE_TYPE.ZIGBEE:
           navigation.navigate(Routes.ConnectRouterGuide, {
             unit,
-            chosenSubUnit,
+            subUnit: chosenSubUnit,
           });
           break;
       }

package/src/screens/AddNewGateway/ShareWifiPassword.js

@@ -180,30 +180,26 @@ const ShareWifiPassword = ({ route }) => {
       if (dataGateway?.gateway.length > 0) {
         let currentSSID;
         checkWifiInterval = setInterval(async () => {
-          try {
-            currentSSID = await getCurrentWifiSSID();
-            if (currentSSID !== wifiOrGatewaySSID) {
-              clearInterval(checkWifiInterval);
-              setIsShowPopupPassword(false);
-              setIsDisabled(false);
-              socket?.close();
-              socket = null;
-              navigate(Routes.ConnectingWifiDevice, {
-                unit,
-                subUnit,
-                gateway: dataGateway.gateway[0],
-                qrData: qrData,
-                selectedWifi: {
-                  ssid: selectedWifi,
-                  password: selectedWifiPassword,
-                },
-                addDeviceType,
-              });
-            }
-          } catch (e) {
-            return;
+          currentSSID = await getCurrentWifiSSID();
+          if (currentSSID !== wifiOrGatewaySSID) {
+            clearInterval(checkWifiInterval);
+            setIsShowPopupPassword(false);
+            setIsDisabled(false);
+            socket?.close();
+            socket = null;
+            navigate(Routes.ConnectingWifiDevice, {
+              unit,
+              subUnit: subUnit ? subUnit : { id: stationId },
+              gateway: dataGateway.gateway[0],
+              qrData: qrData,
+              selectedWifi: {
+                ssid: selectedWifi,
+                password: selectedWifiPassword,
+              },
+              addDeviceType,
+            });
           }
-        }, 1000);
+        }, 800);
       }
     }
     return () => {

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

@@ -1,6 +1,8 @@
 import React from 'react';
+import { TouchableOpacity } from 'react-native';
 import { act, create } from 'react-test-renderer';
 import MockAdapter from 'axios-mock-adapter';
+
 import RenameNewDevices from '../RenameNewDevices';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
@@ -8,7 +10,7 @@ import api from '../../../utils/Apis/axios';
 import AccessibilityLabel from '../../../configs/AccessibilityLabel';
 import Text from '../../../commons/Text';
 import _TextInput from '../../../commons/Form/TextInput';
-import { TouchableOpacity } from 'react-native';
+import API from '../../../configs/API';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -20,6 +22,9 @@ const mock = new MockAdapter(api.axiosInstance);
 
 const mockedNavigate = jest.fn();
 const mockedGoBack = jest.fn();
+const mockedDispatch = jest.fn();
+
+jest.mock('lodash.debounce', () => jest.fn((fn) => fn));
 
 jest.mock('@react-navigation/native', () => {
   return {
@@ -27,6 +32,7 @@ jest.mock('@react-navigation/native', () => {
     useNavigation: () => ({
       navigate: mockedNavigate,
       goBack: mockedGoBack,
+      dispatch: mockedDispatch,
     }),
   };
 });
@@ -34,6 +40,13 @@ jest.mock('@react-navigation/native', () => {
 describe('Test rename new devices', () => {
   let tree;
   let route;
+  const listItemComponent = (instance) => {
+    return instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+        `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}_LIST_ITEM_RENAME`
+    );
+  };
   const onPressToRename = async (instance) => {
     const button = instance.findAll(
       (el) =>
@@ -112,10 +125,11 @@ describe('Test rename new devices', () => {
     expect(mock.history.get).toHaveLength(1);
   });
 
-  it('rendering end devices', async () => {
+  it('rendering one end device', async () => {
     route = {
       params: {
         unitId: 1,
+        sensorId: 1,
         stationId: 2,
         chipId: 3,
         qrData: {},
@@ -144,7 +158,91 @@ describe('Test rename new devices', () => {
       tree = await create(wrapComponent(route));
     });
     const instance = tree.root;
-    await onPressToRename(instance);
+    expect(listItemComponent(instance).props.style[1].height).toEqual(90);
+  });
+
+  it('rendering two end device', async () => {
+    route = {
+      params: {
+        unitId: 1,
+        sensorId: 1,
+        stationId: 2,
+        chipId: 3,
+        qrData: {},
+        addDeviceType: 'wifi',
+      },
+    };
+    mock.onGet().reply(200, {
+      id: 1,
+      name: 'chip',
+      can_rename: true,
+      sensors: [
+        {
+          id: 1,
+          name: 'sensor',
+          end_devices: [
+            {
+              id: 1,
+              name: 'end_device',
+            },
+            {
+              id: 2,
+              name: 'end_device',
+            },
+          ],
+        },
+      ],
+    });
+
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    expect(listItemComponent(instance).props.style[1].height).toEqual(180);
+  });
+
+  it('rendering three end device', async () => {
+    route = {
+      params: {
+        unitId: 1,
+        sensorId: 1,
+        stationId: 2,
+        chipId: 3,
+        qrData: {},
+        addDeviceType: 'wifi',
+      },
+    };
+    mock.onGet().reply(200, {
+      id: 1,
+      name: 'chip',
+      can_rename: true,
+      sensors: [
+        {
+          id: 1,
+          name: 'sensor',
+          end_devices: [
+            {
+              id: 1,
+              name: 'end_device',
+            },
+            {
+              id: 2,
+              name: 'end_device',
+            },
+            {
+              id: 3,
+              name: 'end_device',
+            },
+          ],
+        },
+      ],
+    });
+
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    expect(listItemComponent(instance).props.style[1].height).toEqual(270);
   });
 
   it('render rename chip', async () => {
@@ -273,6 +371,7 @@ describe('Test rename new devices', () => {
         el.props.accessibilityLabel === AccessibilityLabel.BUTTON_DONE &&
         el.type === TouchableOpacity
     );
+    mock.onPost(API.CHIP.RENAME_DEVICES(1)).reply(200);
 
     await act(async () => {
       doneButton.props.onPress();
@@ -297,5 +396,32 @@ describe('Test rename new devices', () => {
         ],
       })
     );
+    expect(mockedDispatch).toBeCalledWith({
+      payload: {
+        index: 0,
+        routes: [
+          {
+            name: 'Main',
+            params: {
+              params: { screen: 'Dashboard' },
+              screen: 'DashboardStack',
+            },
+          },
+          {
+            name: 'UnitStack',
+            params: {
+              params: {
+                isSuccessfullyConnected: true,
+                routeName: 'DashboardStack',
+                stationId: undefined,
+                unitId: undefined,
+              },
+              screen: 'UnitDetail',
+            },
+          },
+        ],
+      },
+      type: 'RESET',
+    });
   });
 });

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

@@ -33,7 +33,7 @@ describe('Test SelectSubUnit', () => {
   });
   let tree;
 
-  it('test ViewButtonBottom onRightClick', async () => {
+  it('test ViewButtonBottom onRightClick WIFI_DEVICE', async () => {
     const route = { params: { deviceType: DEVICE_TYPE.WIFI_DEVICE } };
     await act(async () => {
       tree = renderer.create(wrapComponent(route));
@@ -45,4 +45,28 @@ describe('Test SelectSubUnit', () => {
     });
     expect(mockedNavigate).toHaveBeenCalled();
   });
+  it('test ViewButtonBottom onRightClick MODBUS', async () => {
+    const route = { params: { deviceType: DEVICE_TYPE.MODBUS } };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const viewButtonBottom = instance.findByType(ViewButtonBottom);
+    await act(async () => {
+      viewButtonBottom.props.onRightClick();
+    });
+    expect(mockedNavigate).toHaveBeenCalled();
+  });
+  it('test ViewButtonBottom onRightClick ZIGBEE', async () => {
+    const route = { params: { deviceType: DEVICE_TYPE.ZIGBEE } };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const viewButtonBottom = instance.findByType(ViewButtonBottom);
+    await act(async () => {
+      viewButtonBottom.props.onRightClick();
+    });
+    expect(mockedNavigate).toHaveBeenCalled();
+  });
 });

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import renderer, { act } from 'react-test-renderer';
-import { Platform } from 'react-native';
+import { Platform, TouchableOpacity } from 'react-native';
 import dgram from 'react-native-udp';
 import Toast from 'react-native-toast-message';
 import WifiManager from 'react-native-wifi-reborn';
@@ -11,6 +11,8 @@ import { mockSCStore } from '../../../context/mockStore';
 import ButtonPopup from '../../../commons/ButtonPopup';
 import TextInputPassword from '../../../commons/Form/TextInputPassword';
 import Routes from '../../../utils/Route';
+import { AccessibilityLabel } from '../../../configs/Constants';
+import { HeaderCustom } from '../../../commons/Header';
 
 const mockedGoBack = jest.fn();
 const mockedNavigate = jest.fn();
@@ -152,4 +154,81 @@ describe('test share wifi password', () => {
       Routes.ConnectingWifiDevice
     );
   });
+  it('render list wifi onPress item and cancel popup item', async () => {
+    jest.runOnlyPendingTimers();
+    jest.useFakeTimers();
+    Platform.OS = 'android';
+    const route = {
+      params: {
+        prefix: 'robot',
+        wifiList: [{ id: 1, ssid: 'wifi1' }],
+        stationId: 1,
+        subUnit: { id: 1, name: 'subUnit' },
+        unitId: 1,
+      },
+    };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const itemWifi = tree.root.find(
+      (el) =>
+        el.type === TouchableOpacity &&
+        el.props.accessibilityLabel === AccessibilityLabel.SELECT_WIFI + 'wifi1'
+    );
+    const buttonPopup = tree.root.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+        AccessibilityLabel.GATEWAY_WIFI_LIST.BUTTON_POPUP
+    );
+    expect(buttonPopup.props.visible).toEqual(false);
+    await act(async () => {
+      await itemWifi.props.onPress();
+    });
+    expect(buttonPopup.props.visible).toEqual(true);
+    expect(
+      itemWifi.props.children.props.children[0].props.children.props.children
+    ).toEqual('wifi1');
+    await act(async () => {
+      await buttonPopup.props.onPressSecondary();
+    });
+    expect(buttonPopup.props.visible).toEqual(false);
+  });
+
+  it('render headerCustom handle goback', async () => {
+    jest.useFakeTimers();
+    Platform.OS = 'android';
+    const route = {
+      params: { prefix: 'robot', wifiList: [{ id: 1, ssid: 'wifi1' }] },
+    };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const headerCustom = tree.root.find((el) => el.type === HeaderCustom);
+    const buttonPopup = tree.root.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+        AccessibilityLabel.GATEWAY_WIFI_LIST.BUTTON_POPUP
+    );
+    const socket = dgram.createSocket({});
+    socket.on.mockClear();
+    socket.close.mockClear();
+    socket.send.mockClear();
+
+    await act(async () => {
+      await buttonPopup.props.onPressMain();
+    });
+    jest.runOnlyPendingTimers();
+    await act(async () => {
+      await headerCustom.props.onGoBack();
+    });
+    expect(socket.close).toBeCalled();
+    expect(mockedNavigate).toBeCalledWith('ConnectingWifiGuide', {
+      addDeviceType: undefined,
+      isBackFromOtherScreen: true,
+      qrData: undefined,
+      stationId: undefined,
+      subUnit: undefined,
+      unitId: undefined,
+    });
+  });
 });