@eohjsc/react-native-smart-city 0.3.8 → 0.3.11

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

@@ -1,15 +1,17 @@
 import React from 'react';
 import renderer, { act } from 'react-test-renderer';
 import { TouchableOpacity, Platform } from 'react-native';
-import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
 
 import AddCommonSelectUnit from '../SelectUnit';
 import Text from '../../../commons/Text';
 import { TESTID } from '../../../configs/Constants';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
+import api from '../../../utils/Apis/axios';
+import { API } from '../../../configs';
 
-jest.mock('axios');
+const mock = new MockAdapter(api.axiosInstance);
 
 const mockedGoBack = jest.fn();
 const mockedNavigate = jest.fn();
@@ -86,11 +88,7 @@ describe('Test SelectUnit container', () => {
           { id: 2, name: 'Unit 2' },
         ],
       };
-
-      axios.get.mockImplementation(async () => {
-        return response;
-      });
-
+      mock.onGet(API.SHARE.UNITS()).reply(200, response.data);
       await act(async () => {
         tree = renderer.create(wrapComponent(route));
       });
@@ -151,10 +149,6 @@ describe('Test SelectUnit container', () => {
 describe('test single SelectUnit', () => {
   let tree;
 
-  beforeEach(() => {
-    axios.get.mockClear();
-  });
-
   test('fetch Unit success', async () => {
     Platform.OS = 'android';
     const route = { params: { addType: 'AddSubUnit' } };
@@ -166,15 +160,10 @@ describe('test single SelectUnit', () => {
         { id: 2, name: 'Unit 2' },
       ],
     };
-
-    axios.get.mockImplementation(async () => {
-      return response;
-    });
-
+    mock.onGet(API.SHARE.UNITS()).reply(200, response.data);
     await act(async () => {
       tree = renderer.create(wrapComponent(route));
     });
-
     const instance = tree.root;
     const unitName = instance.findAll(
       (item) =>
@@ -183,35 +172,23 @@ describe('test single SelectUnit', () => {
     const radioButton = instance.findAll(
       (item) => item.props.testID === TESTID.SELECT_UNIT_RADIO_BUTTON
     );
-
     expect(unitName[0].props.children).toBe('Unit 1');
     expect(unitName[1].props.children).toBe('Unit 2');
     expect(radioButton[0].props.active).toBeFalsy();
     expect(radioButton[1].props.active).toBeFalsy();
-
     const selectUnit = instance.findAll(
       (item) => item.props.testID === TESTID.SELECT_UNIT_SELECT
     );
-
     await act(async () => {
       selectUnit[0].props.onPress();
     });
-
     expect(radioButton[0].props.active).toBeTruthy();
   });
 
   test('fetch Unit not success', async () => {
     Platform.OS = 'ios';
     const route = { params: { addType: 'AddSubUnit' } };
-    const response = {
-      status: 500,
-      success: false,
-    };
-
-    axios.get.mockImplementation(async () => {
-      return response;
-    });
-
+    mock.onGet(500);
     await act(async () => {
       tree = renderer.create(wrapComponent(route));
     });
@@ -224,9 +201,8 @@ describe('test single SelectUnit', () => {
     const radioButton = instance.findAll(
       (item) => item.props.testID === TESTID.SELECT_UNIT_RADIO_BUTTON
     );
-
-    expect(unitName).toHaveLength(0);
-    expect(radioButton).toHaveLength(0);
+    expect(unitName).toHaveLength(2);
+    expect(radioButton).toHaveLength(2);
   });
 
   test('click goBack', async () => {

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

@@ -0,0 +1,265 @@
+import React from 'react';
+import { Alert } from 'react-native';
+import { act, create } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
+import RNP from 'react-native-permissions';
+import RNAndroidLocationEnabler from 'react-native-android-location-enabler';
+
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import AddLocationMaps from '../index';
+import { API } from '../../../configs';
+import { TESTID } from '../../../configs/Constants';
+import api from '../../../utils/Apis/axios';
+import {
+  GEOLOCATION_ERROR,
+  OpenSetting,
+} from '../../../utils/Permission/common';
+import { RESULTS } from 'react-native-permissions';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <AddLocationMaps route={route} />
+  </SCProvider>
+);
+
+const mock = new MockAdapter(api.axiosInstance);
+
+const mockNavigate = jest.fn();
+const mockGoBack = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockNavigate,
+      goBack: mockGoBack,
+    }),
+  };
+});
+
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    memo: (x) => x,
+  };
+});
+
+jest.mock('react-native-maps', () => {
+  const { forwardRef } = require('react');
+  const { View } = require('react-native');
+  const MockMapView = forwardRef((props, ref) => (
+    <View refs={ref}>{props.children}</View>
+  ));
+  const MockMarker = (props) => <View>{props.children}</View>;
+  const MockCircle = (props) => <View>{props.children}</View>;
+  return {
+    __esModule: true,
+    default: MockMapView,
+    Marker: MockMarker,
+    Circle: MockCircle,
+    PROVIDER_GOOGLE: 'google',
+  };
+});
+
+jest.mock('react-native-android-location-enabler', () => {
+  return {
+    ...jest.requireActual('react-native-android-location-enabler'),
+    promptForEnableLocationIfNeeded: jest.fn(),
+  };
+});
+
+jest.mock('../../../utils/Permission/common');
+
+const position = {
+  coords: {
+    latitude: 100,
+    longitude: 100,
+  },
+};
+const mockGeolocation = {
+  getCurrentPosition: (onSuccess, onError, options) => {
+    onSuccess(position);
+  },
+};
+global.navigator.geolocation = mockGeolocation;
+
+jest.mock('react-native-permissions', () => {
+  return require('react-native-permissions/mock');
+});
+
+describe('Test SelectAddress', () => {
+  let tree, route, Platform;
+  const mockUpdateLocation = jest.fn();
+
+  beforeAll(() => {
+    Platform = require('react-native').Platform;
+    RNAndroidLocationEnabler.promptForEnableLocationIfNeeded.mockClear();
+    RNP.check.mockClear();
+    route = {
+      params: {
+        updateLocation: mockUpdateLocation,
+      },
+    };
+  });
+
+  test('test get current location success', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) => el.props.testID === TESTID.BUTTON_YOUR_LOCATION
+    );
+
+    const response = {
+      status: 200,
+      data: {
+        results: [
+          {
+            formatted_address: 'address',
+            geometry: {
+              location: {
+                lat: 10,
+                lng: 10,
+              },
+            },
+          },
+        ],
+      },
+    };
+    mock
+      .onGet(API.EXTERNAL.GOOGLE_MAP.GET_LOCATION_FROM_LAT_LNG)
+      .reply(200, response.data);
+    await act(async () => {
+      await button.props.onPress();
+    });
+  });
+
+  test('test get current location failed permission denied', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) => el.props.testID === TESTID.BUTTON_YOUR_LOCATION
+    );
+
+    global.navigator.geolocation = {
+      getCurrentPosition: (onSuccess, onError, options) => {
+        onError({ code: GEOLOCATION_ERROR.PERMISSION_DENIED });
+      },
+    };
+    RNP.check.mockImplementationOnce(() => RESULTS.BLOCKED);
+    OpenSetting.mockImplementationOnce(() => {});
+
+    await act(async () => {
+      await button.props.onPress();
+    });
+    OpenSetting.mockClear();
+  });
+
+  test('test get current location failed location not enabled android', async () => {
+    Platform.OS = 'android';
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) => el.props.testID === TESTID.BUTTON_YOUR_LOCATION
+    );
+
+    global.navigator.geolocation = {
+      getCurrentPosition: (onSuccess, onError, options) => {
+        onError({ code: GEOLOCATION_ERROR.POSITION_UNAVAILABLE });
+      },
+    };
+
+    // cancel
+    RNAndroidLocationEnabler.promptForEnableLocationIfNeeded.mockImplementationOnce(
+      async () => {
+        throw new Error();
+      }
+    );
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(
+      RNAndroidLocationEnabler.promptForEnableLocationIfNeeded
+    ).toBeCalled();
+
+    RNAndroidLocationEnabler.promptForEnableLocationIfNeeded.mockClear();
+
+    // enabled
+    RNAndroidLocationEnabler.promptForEnableLocationIfNeeded.mockImplementationOnce(
+      async () => true
+    );
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(
+      RNAndroidLocationEnabler.promptForEnableLocationIfNeeded
+    ).toBeCalled();
+  });
+
+  test('test get current location failed location not enabled ios', async () => {
+    Platform.OS = 'ios';
+    jest.spyOn(Alert, 'alert');
+
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) => el.props.testID === TESTID.BUTTON_YOUR_LOCATION
+    );
+
+    global.navigator.geolocation = {
+      getCurrentPosition: (onSuccess, onError, options) => {
+        onError({ code: GEOLOCATION_ERROR.POSITION_UNAVAILABLE });
+      },
+    };
+
+    await act(async () => {
+      await button.props.onPress();
+    });
+    // expect AlertAsync is called
+  });
+
+  test('test get current location failed error not handle', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) => el.props.testID === TESTID.BUTTON_YOUR_LOCATION
+    );
+
+    global.navigator.geolocation = {
+      getCurrentPosition: (onSuccess, onError, options) => {
+        onError({ code: GEOLOCATION_ERROR.TIMEOUT });
+      },
+    };
+    RNP.check.mockImplementationOnce(() => RESULTS.DENIED);
+    OpenSetting.mockImplementationOnce(() => {});
+
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(OpenSetting).toBeCalledTimes(0);
+    OpenSetting.mockClear();
+  });
+
+  test('test choose on map', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) => el.props.testID === TESTID.BUTTON_CHOOSE_ON_MAP
+    );
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(mockNavigate).toBeCalled();
+  });
+});

package/src/screens/AddLocationMaps/index.js

@@ -3,26 +3,30 @@ import { View, ScrollView, TouchableOpacity } from 'react-native';
 import MapView, { Marker, Circle, PROVIDER_GOOGLE } from 'react-native-maps';
 import { useNavigation } from '@react-navigation/native';
 import { IconOutline, IconFill } from '@ant-design/icons-react-native';
+import { check, RESULTS } from 'react-native-permissions';
 import { useTranslations } from '../../hooks/Common/useTranslations';
 
 import Text from '../../commons/Text';
-import { ViewButtonBottom } from '../../commons';
+import { ViewButtonBottom, FullLoading } from '../../commons';
 import SearchBarLocation from '../../commons/SearchLocation';
 import RowLocation from '../../commons/SearchLocation/RowLocation';
 import { axiosGet } from '../../utils/Apis/axios';
 import { API, Colors, SCConfig } from '../../configs';
-import { TESTID } from '../../configs/Constants';
+import {
+  TESTID,
+  MAP_INITIAL_REGION,
+  EOH_LOCATION,
+} from '../../configs/Constants';
 import styles from './indexStyle';
 import Routes from '../../utils/Route';
+import {
+  GEOLOCATION_ERROR,
+  keyPermission,
+  OpenSetting,
+} from '../../utils/Permission/common';
+import { openPromptEnableLocation } from '../../utils/Setting/Location';
 
 export const initialRadius = 250;
-const initialRegion = {
-  latitudeDelta: 0.0090222,
-  longitudeDelta: 0.009221,
-};
-
-const DEFAULT_LATITUDE = 10.7974046; // EoH center
-const DEFAULT_LONGITUDE = 106.7035663;
 
 navigator.geolocation = require('@react-native-community/geolocation');
 
@@ -32,7 +36,7 @@ const AddLocationMaps = memo(() => {
   const [input, setInput] = useState('');
   const [searchData, setSearchData] = useState([]);
   const [searchedLocation, setSearchedLocation] = useState(null);
-
+  const [loading, setLoading] = useState(false);
   const mapRef = useRef(null);
 
   const onDone = useCallback(() => {
@@ -45,9 +49,9 @@ const AddLocationMaps = memo(() => {
     goBack();
   }, [goBack]);
 
-  const onTextInput = useCallback(async (input) => {
-    setInput(input);
-    if (!input) {
+  const onTextInput = useCallback(async (newValue) => {
+    setInput(newValue);
+    if (!newValue) {
       setSearchData([]);
       setSearchedLocation(null);
       return;
@@ -55,7 +59,7 @@ const AddLocationMaps = memo(() => {
     try {
       const config = {
         params: {
-          input: input,
+          input: newValue,
           key: SCConfig.GOOGLE_MAP_API_KEY,
           sessiontoken: 123456324,
           strictBounds: false,
@@ -70,6 +74,7 @@ const AddLocationMaps = memo(() => {
       if (success) {
         setSearchData(data.predictions);
       }
+      // eslint-disable-next-line no-empty
     } catch (error) {}
   }, []);
 
@@ -82,7 +87,8 @@ const AddLocationMaps = memo(() => {
       {
         latitude: lat,
         longitude: lng,
-        ...initialRegion,
+        latitudeDelta: MAP_INITIAL_REGION.LAT,
+        longitudeDelta: MAP_INITIAL_REGION.LNG,
       },
       600
     );
@@ -117,6 +123,7 @@ const AddLocationMaps = memo(() => {
       async (position) => {
         const currentLatitude = JSON.stringify(position.coords.latitude);
         const currentLongitude = JSON.stringify(position.coords.longitude);
+        setLoading(true);
         const { success, data } = await axiosGet(
           API.EXTERNAL.GOOGLE_MAP.GET_LOCATION_FROM_LAT_LNG,
           {
@@ -135,11 +142,26 @@ const AddLocationMaps = memo(() => {
             longitude: result.geometry.location.lng,
           });
         }
+        setLoading(false);
+      },
+      async (error) => {
+        if (error.code === GEOLOCATION_ERROR.PERMISSION_DENIED) {
+          const permissionResult = await check(keyPermission.LOCATION);
+          permissionResult === RESULTS.BLOCKED &&
+            OpenSetting(
+              t('location_rationale_title'),
+              t('location_require_message')
+            );
+        } else if (error.code === GEOLOCATION_ERROR.POSITION_UNAVAILABLE) {
+          const locationEnabaled = await openPromptEnableLocation();
+          process.env.NODE_ENV !== 'test' &&
+            locationEnabaled &&
+            getCurrentPosition();
+        }
       },
-      (error) => {},
       {}
     );
-  }, []);
+  }, [t]);
 
   const chooseOnMap = useCallback(() => {
     navigate(Routes.UnitStack, {
@@ -169,7 +191,10 @@ const AddLocationMaps = memo(() => {
         </Text>
         <View style={styles.searchLocation}>
           <SearchBarLocation input={input} onTextInput={onTextInput} />
-          <ScrollView style={styles.searchData}>
+          <ScrollView
+            style={styles.searchData}
+            scrollIndicatorInsets={{ right: 1 }}
+          >
             {searchData.map((item) => (
               <RowLocation item={item} onPress={onPressRowLocation} />
             ))}
@@ -220,9 +245,10 @@ const AddLocationMaps = memo(() => {
             provider={PROVIDER_GOOGLE}
             style={styles.mapView}
             initialRegion={{
-              ...initialRegion,
-              latitude: DEFAULT_LATITUDE,
-              longitude: DEFAULT_LONGITUDE,
+              latitude: EOH_LOCATION.LAT,
+              longitude: EOH_LOCATION.LNG,
+              latitudeDelta: MAP_INITIAL_REGION.LAT,
+              longitudeDelta: MAP_INITIAL_REGION.LNG,
             }}
             followUserLocation={true}
           >
@@ -262,6 +288,7 @@ const AddLocationMaps = memo(() => {
         onRightClick={onDone}
         rightDisabled={!input}
       />
+      {loading && <FullLoading />}
     </View>
   );
 });

package/src/screens/AddNewAction/SelectAction.js

@@ -12,7 +12,11 @@ import OptionsDropdownActionTemplate from '../../commons/OneTapTemplate/OptionsD
 import StatesGridActionTemplate from '../../commons/OneTapTemplate/StatesGridActionTemplate';
 import { axiosGet, axiosPost } from '../../utils/Apis/axios';
 import { API, Images } from '../../configs';
-import { CONDITION_TYPES, TESTID } from '../../configs/Constants';
+import {
+  CONDITION_TYPES,
+  STATE_VALUE_SENSOR_TYPES,
+  TESTID,
+} from '../../configs/Constants';
 import Routes from '../../utils/Route';
 import styles from './Styles/SelectActionStyles';
 import moment from 'moment';
@@ -21,7 +25,7 @@ import { TitleCheckBox } from '../Sharing/Components';
 import WrapHeaderScrollable from '../../commons/Sharing/WrapHeaderScrollable';
 import { popAction } from '../../navigations/utils';
 import { LoadingSelectAction } from './Components';
-import { ToastBottomHelper } from '../../utils/Utils';
+import { notImplemented, ToastBottomHelper } from '../../utils/Utils';
 
 const SelectAction = memo(({ route }) => {
   const t = useTranslations();
@@ -48,10 +52,10 @@ const SelectAction = memo(({ route }) => {
   const fetchData = useCallback(async () => {
     isSelectSensor && setIsLoading(true);
     setIsfetched(true);
-    const { success, data } = await axiosGet(
+    const { success, data: automateData } = await axiosGet(
       isSelectSensor
         ? API.AUTOMATE.GET_SENSOR_CONFIG(device.id)
-        : API.SENSOR.DISPLAY_ACTIONS(device.id),
+        : API.DEVICE.DISPLAY_ACTIONS(device.id),
       isSelectSensor && {},
       isSelectSensor && true
     );
@@ -78,21 +82,21 @@ const SelectAction = memo(({ route }) => {
           const condition = conditionType.find((item) => {
             return item.conditionValue === automate.condition;
           });
-          const updateSensorData = data.map((obj) =>
+          const updateSensorData = automateData.map((obj) =>
             obj.id === automate.config_id
               ? { ...obj, value: automate.value, ...condition }
               : obj
           );
-          let selectSensor = data.find((config) => {
+          let selectSensor = automateData.find((config) => {
             return config.id === automate.config_id;
           });
           setSensorData(updateSensorData);
           setCheckedItem(selectSensor);
         } else {
-          setSensorData(data);
+          setSensorData(automateData);
         }
       } else {
-        setData(data);
+        setData(automateData);
       }
     }
     setIsfetched(false);
@@ -130,6 +134,7 @@ const SelectAction = memo(({ route }) => {
           value: itemTemp?.value,
           config_id: itemTemp?.id,
           config_name: itemTemp?.name,
+          sensor_type: itemTemp?.sensor_type,
         },
         scriptName,
       });
@@ -265,7 +270,7 @@ const SelectAction = memo(({ route }) => {
       dispatch(popAction(3));
       isAutomateTab && goBack();
     } else {
-      alert(t('feature_under_development'));
+      notImplemented(t);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [route.params]);
@@ -286,6 +291,23 @@ const SelectAction = memo(({ route }) => {
     });
   };
 
+  const RenderCondition = useCallback(
+    (item) => {
+      const stateConditionData = STATE_VALUE_SENSOR_TYPES.find(
+        (i) => i.type === item?.sensor_type
+      );
+      const isNumberValue = !stateConditionData;
+
+      if (isNumberValue) {
+        return `${item?.name} ${
+          item?.title ? item.title : t('is_below') + ' (<)'
+        } ${item?.value} ${item?.unit}`;
+      }
+      return t(stateConditionData?.stateValue[item?.value]);
+    },
+    [t]
+  );
+
   const rightComponent = useMemo(
     () => (
       <TouchableOpacity style={styles.closeButton} onPress={handleClose}>
@@ -326,7 +348,7 @@ const SelectAction = memo(({ route }) => {
             <LoadingSelectAction style={styles.container} />
           ) : (
             sensorData.map((item) => {
-              const isHasValue = !!item?.value;
+              const isHasValue = !!item?.value || item?.value === 0;
               return (
                 <View style={styles.wrapItem} key={item?.id}>
                   <TitleCheckBox
@@ -351,9 +373,7 @@ const SelectAction = memo(({ route }) => {
                       style={styles.description}
                     >
                       {isHasValue
-                        ? `${item?.name} ${
-                            item?.title ? item.title : t('is_below') + ' (<)'
-                          } ${item.value} ${item?.unit}`
+                        ? RenderCondition(item)
                         : `${t('no')} ${t('condition')}`}
                     </Text>
                     {isHasValue && (

package/src/screens/AddNewAction/SelectSensorDevices.js

@@ -28,6 +28,7 @@ const SelectSensorDevices = memo(({ route }) => {
     isAutomateTab,
     isCreateNewAction,
     isMultiUnits,
+    oldType,
   } = route.params;
 
   const [listStation, setListStation] = useState([]);
@@ -137,7 +138,7 @@ const SelectSensorDevices = memo(({ route }) => {
       navigate(Routes.ScriptDetail, {
         id: automateId,
         name: scriptName,
-        type: type,
+        type: oldType,
         havePermission: true,
         unit,
         isMultiUnits,
@@ -175,6 +176,7 @@ const SelectSensorDevices = memo(({ route }) => {
       <ScrollView
         style={styles.wrap}
         contentContainerStyle={styles.contentContainerStyle}
+        scrollIndicatorInsets={{ right: 1 }}
       >
         <Text bold type="H2" style={styles.title}>
           {t(title)}
@@ -216,7 +218,11 @@ const SelectSensorDevices = memo(({ route }) => {
         style={styles.bottomButtonView}
         mainTitle={t('continue')}
         onPressMain={onPressContinue}
-        typeMain={selectedDevice ? 'primary' : 'disabled'}
+        typeMain={
+          Object.keys(selectedDevice || {}).length === 0
+            ? 'disabled'
+            : 'primary'
+        }
       />
     </View>
   );