@eohjsc/react-native-smart-city 0.7.22 → 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/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 = {

package/src/screens/Device/detail.js

@@ -54,7 +54,7 @@ import Routes from '../../utils/Route';
 import { getData as getLocalData } from '../../utils/Storage';
 import { API, Colors, SCConfig } from '../../configs';
 import { DEVICE_TYPE, AccessibilityLabel } from '../../configs/Constants';
-import { axiosGet } from '../../utils/Apis/axios';
+import { axiosGet, axiosPost } from '../../utils/Apis/axios';
 import { notImplemented } from '../../utils/Utils';
 import { useReceiveNotifications } from '../../hooks';
 import useChipJsonConfiguration, {
@@ -482,6 +482,31 @@ const DeviceDetail = ({ route }) => {
     fetchDataDeviceDetail();
   }, [device, isNetworkConnected, fetchDataDeviceDetail]);
 
+  const fetchDeviceStatus = useCallback(async () => {
+    if (
+      !isNetworkConnected ||
+      !device.is_managed_by_backend ||
+      configIdsTemp.current.length
+    ) {
+      return;
+    }
+
+    const { success, data } = await axiosPost(
+      API.UNIT.END_DEVICES_STATUS(unit.id),
+      {
+        end_device_ids: [device.id],
+      }
+    );
+
+    success && setAction(Action.SET_DEVICES_STATUS, data);
+  }, [
+    isNetworkConnected,
+    unit.id,
+    device.id,
+    device.is_managed_by_backend,
+    setAction,
+  ]);
+
   const onRefresh = useCallback(async () => {
     await fetchSensorDetail();
     await fetchDataDeviceDetail();
@@ -495,9 +520,11 @@ const DeviceDetail = ({ route }) => {
       })();
     }
     await checkScanDevicesBLE();
+    await fetchDeviceStatus();
   }, [
     fetchSensorDetail,
     fetchDataDeviceDetail,
+    fetchDeviceStatus,
     unit?.remote_control_options,
     isNetworkConnected,
     checkScanDevicesBLE,
@@ -516,11 +543,20 @@ const DeviceDetail = ({ route }) => {
           return;
         }
 
-        const { configs, options, config, from_config, to_config } =
-          configuration;
+        const {
+          configs,
+          options,
+          config,
+          from_config,
+          to_config,
+          history_configs,
+          realtime_configs,
+        } = configuration;
 
         configs?.forEach((object) => configIdsSet.add(object.id));
         options?.forEach((option) => configIdsSet.add(option.config));
+        history_configs?.forEach((object) => configIdsSet.add(object.id));
+        realtime_configs?.forEach((object) => configIdsSet.add(object.id));
 
         if (config) {
           const configId = config.id || config;
@@ -622,6 +658,13 @@ const DeviceDetail = ({ route }) => {
     }, [display.items, isNetworkConnected, device, mqttConfigs])
   );
 
+  useFocusEffect(
+    useCallback(() => {
+      fetchDeviceStatus();
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [])
+  );
+
   useWatchConfigs(chipFiltered.length ? [] : configIdsTemp.current);
 
   const isShowEmergencyResolve =

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

@@ -20,19 +20,22 @@ const wrapComponent = () => (
 
 describe('Test PlayBackCamera', () => {
   let tree;
-  jest.useFakeTimers();
-  global.mockedUseRoute.mockReturnValue({
-    params: {
-      item: {
-        configuration: {
-          time_zone: 0,
-          playback: '',
-          name: 'name',
-          uri: '',
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    global.mockedUseRoute.mockReturnValue({
+      params: {
+        item: {
+          configuration: {
+            time_zone: 0,
+            playback: 'rtsp://example.com/playback',
+            name: 'name',
+            uri: 'rtsp://example.com/stream',
+          },
         },
+        thumbnail: {},
       },
-      thumbnail: {},
-    },
+    });
   });
 
   it('Test render', async () => {
@@ -129,7 +132,9 @@ describe('Test PlayBackCamera', () => {
         },
       });
     });
-    jest.runAllTimers();
+    await act(async () => {
+      jest.runAllTimers();
+    });
     //NOTE: isFirstTime = false
     await act(async () => {
       timerScroll[0].props.onScroll({
@@ -147,7 +152,37 @@ describe('Test PlayBackCamera', () => {
     });
     const media = instance.findByType(MediaPlayerFull);
     expect(media.props.uri).toEqual(
-      `=${moment().format('YYYYMMDDT003730\\Z')}`
+      `rtsp://example.com/playback=${moment().format('YYYYMMDDT003730\\Z')}`
+    );
+  });
+
+  it('Test render when playback is null', async () => {
+    global.mockedUseRoute.mockReturnValue({
+      params: {
+        item: {
+          configuration: {
+            time_zone: 0,
+            playback: null,
+            name: 'name',
+            uri: 'rtsp://example.com/stream',
+          },
+        },
+        thumbnail: {},
+      },
+    });
+    await act(async () => {
+      tree = await create(wrapComponent());
+    });
+    const instance = tree.root;
+    const buttonAddDate = instance.findAll(
+      (el) =>
+        el.props.accessibilityLabel === AccessibilityLabel.ON_PRESS_ADD_DATE &&
+        el.type === TouchableOpacity
     );
+    await act(async () => {
+      await buttonAddDate[0].props.onPress();
+    });
+    const media = instance.findByType(MediaPlayerFull);
+    expect(media.props.uri).toEqual('rtsp://example.com/stream');
   });
 });

package/src/screens/PlayBackCamera/index.js

@@ -121,7 +121,7 @@ const PlayBackCamera = () => {
         'YYYY-MM-DD HH:mm:SS'
       ).valueOf();
 
-      if (selectedDayTime > currentTime) {
+      if (selectedDayTime > currentTime || !playback) {
         setUriCamera(uri);
       } else {
         if (playback.includes('chID')) {

package/src/utils/Apis/axios.js

@@ -75,6 +75,12 @@ const parseErrorResponse = async (error) => {
     if (message instanceof Array) {
       message = message[0];
     }
+    if (message instanceof Object) {
+      return await parseErrorResponse({
+        ...error,
+        data: message,
+      });
+    }
     if (message?.message) {
       message = message.message;
     }