@eohjsc/react-native-smart-city 0.7.21 → 0.7.23

package/src/screens/Automate/SetSchedule/index.js

@@ -1,141 +1,27 @@
 import { useNavigation } from '@react-navigation/native';
-import moment from 'moment';
-import React, { memo, useCallback, useState } from 'react';
-import { ScrollView } from 'react-native';
-import Calendar from '../../../commons/Calendar';
-import WheelDateTimePicker from '../../../commons/WheelDateTimePicker';
-import { useBoolean } from '../../../hooks/Common';
-import { useTranslations } from '../../../hooks/Common/useTranslations';
+import React, { useCallback } from 'react';
 import Routes from '../../../utils/Route';
-import NewActionWrapper from '../AddNewAction/NewActionWrapper';
-import RepeatOptionsPopup, {
-  REPEAT_OPTIONS,
-} from './components/RepeatOptionsPopup';
-import RowItem from './components/RowItem';
-import SelectWeekday from './components/SelectWeekday';
-import styles from './styles/indexStyles';
+import EditSchedule from './EditSchedule';
 
 const SetSchedule = ({ route }) => {
-  const t = useTranslations();
   const { automate = {}, closeScreen } = route?.params || {};
   const { navigate } = useNavigation();
-  const [repeat, setRepeat] = useState(automate.repeat || REPEAT_OPTIONS.ONCE);
 
-  const getDateString = (date) => {
-    const today = moment();
-    if (date.isSame(today, 'day')) {
-      return date.format(`[${t('today')}], D MMMM YYYY `);
-    }
-    return date.format('ddd, D MMMM YYYY');
-  };
-
-  const [time, setTime] = useState(
-    automate.time_repeat
-      ? moment(automate.time_repeat, 'HH:mm:ss')
-      : moment().second(0)
-  );
-  const [date, setDate] = useState(
-    automate.date_repeat ? moment(automate.date_repeat, 'YYYY-MM-DD') : moment()
-  );
-  const [weekday, setWeekday] = useState(automate.weekday_repeat || []);
-
-  const [showRepeatOptions, setShowRepeatOptions, setHideRepeatOptions] =
-    useBoolean();
-  const [showTimePicker, setShowTimePicker, setHideTimePicker] = useBoolean();
-  const [showCalendar, setShowCalendar, setHideCalendar] = useBoolean();
-
-  const handleOnSave = useCallback(() => {
-    navigate(Routes.ValueChangeName, {
-      closeScreen: closeScreen,
-      automate: {
-        ...automate,
-        repeat: repeat,
-        time_repeat: time.format('HH:mm:ss'),
-        date_repeat: date.format('YYYY-MM-DD'),
-        weekday_repeat: weekday,
-      },
-      unitId: automate.unit,
-    });
-  }, [navigate, closeScreen, automate, repeat, time, date, weekday]);
-
-  const onSetRepeatOption = useCallback(
-    (value) => {
-      setRepeat(value);
-      setHideRepeatOptions();
+  const handleOnSave = useCallback(
+    (data) => {
+      navigate(Routes.ValueChangeName, {
+        closeScreen: closeScreen,
+        automate: {
+          ...automate,
+          conditions: [data],
+        },
+        unitId: automate.unit,
+      });
     },
-    [setRepeat, setHideRepeatOptions]
+    [navigate, closeScreen, automate]
   );
 
-  const onTimePicked = useCallback(
-    (timeData) => {
-      setTime(moment(timeData));
-    },
-    [setTime]
-  );
-
-  const onDatePicked = useCallback(
-    (datePicked) => {
-      setDate(datePicked);
-    },
-    [setDate]
-  );
-
-  return (
-    <NewActionWrapper
-      name={t('set_schedule')}
-      onNext={handleOnSave}
-      canNext
-      nextTitle={t('save')}
-    >
-      <ScrollView
-        contentContainerStyle={styles.scollView}
-        scrollIndicatorInsets={{ right: 1 }}
-      >
-        <RowItem
-          title={t('set_time')}
-          value={time.format('HH:mm')}
-          icon="clock-circle"
-          onPress={setShowTimePicker}
-        />
-        {repeat === REPEAT_OPTIONS.ONCE && (
-          <RowItem
-            title={t('select_date')}
-            value={getDateString(date)}
-            icon="calendar"
-            onPress={setShowCalendar}
-          />
-        )}
-        {repeat === REPEAT_OPTIONS.EVERYWEEK && (
-          <SelectWeekday weekday={weekday} setWeekday={setWeekday} />
-        )}
-        <RowItem
-          title={t('repeat')}
-          value={t(`${repeat}`)}
-          arrow
-          onPress={setShowRepeatOptions}
-        />
-      </ScrollView>
-      <RepeatOptionsPopup
-        isVisible={showRepeatOptions}
-        onHide={setHideRepeatOptions}
-        onSetRepeat={onSetRepeatOption}
-      />
-      <WheelDateTimePicker
-        mode="time"
-        isVisible={showTimePicker}
-        defaultValue={time.valueOf()}
-        onCancel={setHideTimePicker}
-        onPicked={onTimePicked}
-      />
-      <Calendar
-        isVisible={showCalendar}
-        defaultDate={date}
-        minDate={moment()}
-        onCancel={setHideCalendar}
-        onConfirm={onDatePicked}
-      />
-    </NewActionWrapper>
-  );
+  return <EditSchedule onSave={handleOnSave} />;
 };
 
-export default memo(SetSchedule);
+export default SetSchedule;

package/src/screens/Automate/SetSchedule/styles/indexStyles.js

@@ -20,4 +20,13 @@ export default StyleSheet.create({
     borderTopWidth: 1,
     backgroundColor: Colors.White,
   },
+  inputWrap: {
+    marginTop: 0,
+  },
+  inputNumber: {
+    borderWidth: 1,
+    borderColor: Colors.Gray4,
+    borderStyle: 'solid',
+    borderRadius: 10,
+  },
 });

package/src/screens/Automate/__test__/MultiUnits.test.js

@@ -190,11 +190,16 @@ describe('Test MultiUnits', () => {
     await act(async () => {
       ItemAddNews[0].props.onAddNew();
     });
-    expect(global.mockedNavigate).toBeCalledWith(Routes.UnitStack, {
+    expect(global.mockedNavigate).toHaveBeenCalledWith(Routes.UnitStack, {
       screen: Routes.ScenarioName,
       params: {
         automate: {
           type: AUTOMATE_TYPE.ONE_TAP,
+          conditions: [
+            {
+              type: AUTOMATE_TYPE.ONE_TAP,
+            },
+          ],
           unit: undefined,
         },
         closeScreen: undefined,

package/src/screens/Automate/hooks/useAction.js

@@ -0,0 +1,222 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { API } from '../../../configs';
+import {
+  axiosDelete,
+  axiosGet,
+  axiosPost,
+  axiosPut,
+} from '../../../utils/Apis/axios';
+
+const useAction = (device, scriptItems, activatedScript = {}) => {
+  const {
+    action_script,
+    toggle_script,
+    order = scriptItems.length + 1,
+  } = activatedScript;
+  const [saveActions, setSaveActions] = useState([]);
+  const [displayActions, setDisplayActions] = useState([]);
+
+  const listAction = useMemo(() => {
+    return saveActions
+      .filter((item) => !item.is_toggle)
+      .map((item) => ({
+        action: item.action,
+        data: item.data,
+        order: order + item.index,
+      }));
+  }, [saveActions, order]);
+
+  const listToggle = useMemo(() => {
+    return saveActions
+      .filter((item) => item.is_toggle)
+      .map((item) => ({
+        action_on: item.action_on,
+        action_off: item.action_off,
+        config: item.config,
+        action_on_data: item.action_on_data,
+        action_off_data: item.action_off_data,
+        is_on_values: item.is_on_values,
+        order: order + item.index,
+      }));
+  }, [saveActions, order]);
+
+  const fetchDisplayActions = useCallback(async () => {
+    const { success, data } = await axiosGet(
+      API.DEVICE.DISPLAY_ACTIONS(device.id)
+    );
+
+    success && setDisplayActions(data);
+  }, [device.id]);
+
+  const onSelectAction = useCallback((action) => {
+    setSaveActions((prevActions) => {
+      const index = prevActions.findIndex(
+        (item) => item.index === action.index
+      );
+      if (index !== -1) {
+        const newActions = [...prevActions];
+        newActions[index] = action;
+        return newActions;
+      } else {
+        return [...prevActions, action];
+      }
+    });
+  }, []);
+
+  const onAddAction = useCallback(
+    async (automateId, unitId, startOrder, numberAction) => {
+      if (!listAction.length) {
+        return false;
+      }
+      const { success } = await axiosPost(
+        API.AUTOMATE.ADD_SCRIPT_ACTION(automateId),
+        {
+          list_action: listAction,
+          ...(startOrder && { start_order: startOrder }),
+          ...(numberAction && { number_action: numberAction }),
+          unit: unitId,
+        }
+      );
+      return success;
+    },
+    [listAction]
+  );
+
+  const onAddToggle = useCallback(
+    async (automateId, unitId, startOrder, numberAction) => {
+      if (!listToggle.length) {
+        return false;
+      }
+      const { success } = await axiosPost(
+        API.AUTOMATE.ADD_SCRIPT_TOGGLE(automateId),
+        {
+          list_action: listToggle,
+          ...(startOrder && { start_order: startOrder }),
+          ...(numberAction && { number_action: numberAction }),
+          unit: unitId,
+        }
+      );
+      return success;
+    },
+    [listToggle]
+  );
+
+  const onAddSubmit = useCallback(
+    async (automateId, unitId) => {
+      const actionSuccess = await onAddAction(automateId, unitId);
+      const toggleSuccess = await onAddToggle(automateId, unitId);
+      return actionSuccess || toggleSuccess;
+    },
+    [onAddAction, onAddToggle]
+  );
+
+  const onDeleteScript = useCallback(async (automateId, scriptId) => {
+    const { success } = await axiosDelete(
+      API.AUTOMATE.DELETE_SCRIPT_ITEM(automateId, scriptId)
+    );
+    return success;
+  }, []);
+
+  const onUpdateAction = useCallback(
+    async (automateId, scriptId, unitId) => {
+      if (!action_script) {
+        const success = await onDeleteScript(automateId, scriptId);
+        return (
+          success &&
+          (await onAddAction(
+            automateId,
+            unitId,
+            listAction[0].order,
+            saveActions.length
+          ))
+        );
+      }
+      const { success } = await axiosPut(
+        API.AUTOMATE.UPDATE_SCRIPT_ACTION(automateId),
+        {
+          id: scriptId,
+          list_action: listAction,
+          number_action: saveActions.length,
+          unit: unitId,
+        }
+      );
+      return success;
+    },
+    [action_script, listAction, saveActions.length, onAddAction, onDeleteScript]
+  );
+
+  const onUpdateToggle = useCallback(
+    async (automateId, scriptId, unitId) => {
+      if (!toggle_script) {
+        const success = await onDeleteScript(automateId, scriptId);
+        return (
+          success &&
+          (await onAddToggle(
+            automateId,
+            unitId,
+            listToggle[0].order,
+            saveActions.length
+          ))
+        );
+      }
+      const { success } = await axiosPut(
+        API.AUTOMATE.UPDATE_SCRIPT_TOGGLE(automateId),
+        {
+          id: scriptId,
+          list_action: listToggle,
+          number_action: saveActions.length,
+          unit: unitId,
+        }
+      );
+      return success;
+    },
+    [toggle_script, listToggle, saveActions.length, onAddToggle, onDeleteScript]
+  );
+
+  const onUpdateSubmit = useCallback(
+    async (automateId, scriptId, unitId) => {
+      if (saveActions[0].is_toggle) {
+        const toggleSuccess = await onUpdateToggle(
+          automateId,
+          scriptId,
+          unitId
+        );
+        const actionSuccess = await onAddAction(automateId, unitId);
+        return toggleSuccess || actionSuccess;
+      } else {
+        const actionSuccess = await onUpdateAction(
+          automateId,
+          scriptId,
+          unitId
+        );
+        const toggleSuccess = await onAddToggle(automateId, unitId);
+        return actionSuccess || toggleSuccess;
+      }
+    },
+    [saveActions, onAddAction, onAddToggle, onUpdateAction, onUpdateToggle]
+  );
+
+  useEffect(() => {
+    fetchDisplayActions();
+  }, [fetchDisplayActions]);
+
+  return {
+    displayActions,
+    saveActions,
+
+    setDisplayActions,
+    setSaveActions,
+    onSelectAction,
+
+    onAddAction,
+    onAddToggle,
+    onAddSubmit,
+
+    onUpdateAction,
+    onUpdateToggle,
+    onUpdateSubmit,
+  };
+};
+
+export default useAction;

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

@@ -1,15 +1,18 @@
-import React from 'react';
 import renderer, { act } from 'react-test-renderer';
 
-import { SCProvider } from '../../../context';
-import { mockSCStore } from '../../../context/mockStore';
+import API from '../../../configs/API';
+import { AccessibilityLabel } from '../../../configs/Constants';
+import { Button } from '../../../commons';
 import ConfirmUnitDeletion from '../index';
+import MockAdapter from 'axios-mock-adapter';
+import React from 'react';
+import Routes from '../../../utils/Route';
+import { SCProvider } from '../../../context';
+import { ToastBottomHelper } from '../../../utils/Utils';
 import _TextInput from '../../../commons/Form/TextInput';
-import { TouchableOpacity } from 'react-native';
-import { AccessibilityLabel } from '../../../configs/Constants';
-import API from '../../../configs/API';
 import api from '../../../utils/Apis/axios';
-import MockAdapter from 'axios-mock-adapter';
+import { mockSCStore } from '../../../context/mockStore';
+import { useNavigation } from '@react-navigation/native';
 
 const mock = new MockAdapter(api.axiosInstance);
 const wrapComponent = (route, navigation) => (
@@ -21,7 +24,8 @@ const wrapComponent = (route, navigation) => (
 describe('Test ConfirmUnitDeletion', () => {
   let tree;
   let route;
-
+  const spyToast = jest.spyOn(ToastBottomHelper, 'success');
+  const mockNavigate = useNavigation().navigate;
   beforeAll(() => {
     route = {
       params: {
@@ -31,6 +35,10 @@ describe('Test ConfirmUnitDeletion', () => {
       },
     };
   });
+  beforeEach(() => {
+    spyToast.mockClear();
+    mockNavigate.mockClear();
+  });
 
   it('test render ConfirmUnitDeletion', async () => {
     await act(async () => {
@@ -43,7 +51,8 @@ describe('Test ConfirmUnitDeletion', () => {
       textInput.props.onChange();
     });
   });
-  it('Onpress button ConfirmUnitDeletion ', async () => {
+  it('Onpress button ConfirmUnitDeletion success', async () => {
+    mock.onDelete(API.UNIT.MANAGE_UNIT(10)).reply(204);
     await act(async () => {
       tree = await renderer.create(wrapComponent(route));
     });
@@ -52,16 +61,63 @@ describe('Test ConfirmUnitDeletion', () => {
     const touchableOpacity = instance.find(
       (el) =>
         el.props.accessibilityLabel ===
-          AccessibilityLabel.CONFIRM_UNIT_DELETION_BUTTON &&
-        el.type === TouchableOpacity
+          AccessibilityLabel.CONFIRM_UNIT_DELETION_BUTTON && el.type === Button
     );
     const textInput = instance.findByType(_TextInput);
+    await act(async () => {
+      textInput.props.onChange('YES');
+    });
     await act(async () => {
       touchableOpacity.props.onPress();
     });
+    expect(spyToast).toHaveBeenLastCalledWith('Unit was deleted successfully.');
+    expect(mockNavigate).toHaveBeenCalledWith(Routes.Dashboard);
+  });
+
+  it('Onpress button ConfirmUnitDeletion response error', async () => {
+    mock.onDelete(API.UNIT.MANAGE_UNIT(10)).reply(400);
     await act(async () => {
-      textInput.props.onChange();
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const touchableOpacity = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.CONFIRM_UNIT_DELETION_BUTTON && el.type === Button
+    );
+    const textInput = instance.findByType(_TextInput);
+    await act(async () => {
+      textInput.props.onChange('YES');
+    });
+    await act(async () => {
+      touchableOpacity.props.onPress();
+    });
+    expect(spyToast).not.toHaveBeenCalled();
+    expect(mockNavigate).not.toHaveBeenCalled();
+  });
+
+  it('Onpress button ConfirmUnitDeletion wrong text confirm', async () => {
+    mock.onDelete(API.UNIT.MANAGE_UNIT(10)).reply(204);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const touchableOpacity = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.CONFIRM_UNIT_DELETION_BUTTON && el.type === Button
+    );
+    const textInput = instance.findByType(_TextInput);
+    await act(async () => {
+      textInput.props.onChange('XXX');
+    });
+    await act(async () => {
+      touchableOpacity.props.onPress();
     });
-    mock.onDelete(API.UNIT.MANAGE_UNIT(1)).reply(204);
+    expect(spyToast).not.toHaveBeenCalled();
+    expect(mockNavigate).not.toHaveBeenCalled();
+    expect(textInput.props.errorText).toEqual('Please enter correct');
   });
 });

package/src/screens/ConfirmUnitDeletion/index.js

@@ -1,31 +1,31 @@
+import { API, Colors } from '../../configs';
 import React, { useCallback, useContext, useState } from 'react';
-import { View } from 'react-native';
-import { useNavigation } from '@react-navigation/native';
 
-import { useTranslations } from '../../hooks/Common/useTranslations';
-import styles from './styles';
-import WrapHeaderScrollable from '../../commons/Sharing/WrapHeaderScrollable';
-import Text from '../../commons/Text';
-import { API, Colors } from '../../configs';
-import _TextInput from '../../commons/Form/TextInput';
+import { AccessibilityLabel } from '../../configs/Constants';
+import { Action } from '../../context/actionType';
 import { Button } from '../../commons';
 import Routes from '../../utils/Route';
-import { axiosDelete } from '../../utils/Apis/axios';
-import { ToastBottomHelper } from '../../utils/Utils';
-import { AccessibilityLabel } from '../../configs/Constants';
 import { SCContext } from '../../context';
-import { Action } from '../../context/actionType';
+import Text from '../../commons/Text';
+import { ToastBottomHelper } from '../../utils/Utils';
+import { View } from 'react-native';
+import WrapHeaderScrollable from '../../commons/Sharing/WrapHeaderScrollable';
+import _TextInput from '../../commons/Form/TextInput';
+import { axiosDelete } from '../../utils/Apis/axios';
+import styles from './styles';
+import { useNavigation } from '@react-navigation/native';
+import { useTranslations } from '../../hooks/Common/useTranslations';
 
 const ConfirmUnitDeletion = ({ route }) => {
   const { setAction } = useContext(SCContext);
   const t = useTranslations();
   const { unit } = route?.params || {};
   const navigation = useNavigation();
-  const [confirm, setConfrim] = useState('');
+  const [confirm, setConfirm] = useState('');
   const [errorText, setErrorText] = useState();
 
   const onChangePassword = useCallback((value) => {
-    setConfrim(value);
+    setConfirm(value);
   }, []);
 
   const onSendPress = useCallback(async () => {

package/src/screens/Device/__test__/detail.test.js

@@ -8,6 +8,7 @@ import CurrentRainSensor from '../../../commons/Device/RainningSensor/CurrentRai
 import { AlertSendConfirm } from '../../../commons/EmergencyButton/AlertSendConfirm';
 import { AlertSent } from '../../../commons/EmergencyButton/AlertSent';
 import Text from '../../../commons/Text';
+import { SensorConnectStatusViewHeader } from '../components/SensorConnectStatusViewHeader';
 import { API } from '../../../configs';
 import { AccessibilityLabel } from '../../../configs/Constants';
 import { SCProvider } from '../../../context';
@@ -369,10 +370,19 @@ describe('test DeviceDetail', () => {
     const instance = tree.root;
     const scrollView = instance.findByType(ScrollView);
     const refreshControl = scrollView.props.refreshControl;
+    expect(mock.history.post).toHaveLength(2);
     await act(async () => {
       refreshControl.props.onRefresh();
     });
     expect(scrollView).toBeDefined();
+    expect(mock.history.post).toHaveLength(4);
+    const urls = mock.history.post.map((item) => item.url);
+    expect(
+      urls.filter((url) => url === API.UNIT.END_DEVICES_STATUS(1))
+    ).toHaveLength(2);
+    expect(
+      urls.filter((url) => url === API.HOME_ASSISTANT.CHECK_SEND_EMAIL())
+    ).toHaveLength(2);
   });
 
   it('Should render SensorDisplayItem', async () => {
@@ -760,7 +770,7 @@ describe('test DeviceDetail', () => {
 
   it('Test fetchUnitDetail', async () => {
     const unitId = 1;
-    mock.onGet(API.UNIT.UNIT_DETAIL(unitId)).reply(200);
+    mock.onGet(API.UNIT.UNIT_DETAIL(unitId)).reply(200, { id: unitId });
     await act(async () => {
       await create(
         wrapComponent(store, account, {
@@ -773,6 +783,43 @@ describe('test DeviceDetail', () => {
     expect(urls).toContain(API.UNIT.UNIT_DETAIL(unitId));
   });
 
+  it('Test fetch end device status', async () => {
+    const unitId = 1;
+    mock.onGet(API.UNIT.UNIT_DETAIL(unitId)).reply(200, { id: unitId });
+    mock.onPost(API.UNIT.END_DEVICES_STATUS(unitId)).reply(200, [
+      {
+        id: 1,
+        is_connected: true,
+      },
+    ]);
+    await act(async () => {
+      tree = await create(
+        wrapComponent(store, account, {
+          ...route,
+          params: { ...route.params, unitData: null, unitId: unitId },
+        })
+      );
+    });
+    const instance = tree.root;
+    const sensorConnectStatus = instance.findByType(
+      SensorConnectStatusViewHeader
+    );
+    expect(sensorConnectStatus.props.connectedViaNetwork).toBeTruthy();
+    expect(mock.history.post).toHaveLength(1);
+    expect(mock.history.post[0].url).toEqual(
+      API.UNIT.END_DEVICES_STATUS(unitId)
+    );
+  });
+
+  it('Test not fetch end device status if not managed by backend', async () => {
+    route.params.sensorData.is_managed_by_backend = false;
+    await act(async () => {
+      tree = await create(wrapComponent(store, account, route));
+    });
+    const urls = mock.history.post.map((x) => x.url);
+    expect(urls).not.toContain(API.UNIT.END_DEVICES_STATUS(1));
+  });
+
   it('should render device detail, useWatchConfig value', async () => {
     mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, []);
     const responseDisplay = {