@eohjsc/react-native-smart-city 0.3.4 → 0.3.7

package/src/hooks/useReceiveNotifications.js

@@ -3,23 +3,19 @@ import OneSignal from 'react-native-onesignal';
 
 const useReceiveNotifications = () => {
   const [dataNofitication, setDataNofitication] = useState(null);
+  const [showEmergencyPopup, setShowEmergencyPopup] = useState(false);
 
   const onReceived = useCallback((data) => {
-    const { additionalData } = data;
+    const { additionalData } = data.payload;
     setDataNofitication(additionalData);
+    setShowEmergencyPopup(!!additionalData);
   }, []);
 
   useEffect(() => {
-    OneSignal.setNotificationWillShowInForegroundHandler(
-      (notifReceivedEvent) => {
-        let notif = notifReceivedEvent.getNotification();
-        setTimeout(() => notifReceivedEvent.complete(notif), 0);
-        onReceived(notif);
-      }
-    );
+    OneSignal.addEventListener('received', onReceived);
   }, [onReceived]);
 
-  return { dataNofitication };
+  return { dataNofitication, showEmergencyPopup, setShowEmergencyPopup };
 };
 
 export default useReceiveNotifications;

package/src/iot/Monitor.js

@@ -99,9 +99,8 @@ export const realWatchMultiConfigs = async (configIds) => {
     const configValues = getConfigGlobalState('configValues');
     const newConfigValues = { ...configValues, ...data };
     setConfigGlobalState('configValues', newConfigValues);
-    for (const configId in data) {
-      watchConfig(configId);
-    }
+
+    configIds.map((id) => watchConfig(id));
   }
 };
 

package/src/iot/RemoteControl/Bluetooth.js

@@ -1,3 +1,4 @@
+/* eslint-disable promise/prefer-await-to-then */
 /* eslint-disable promise/prefer-await-to-callbacks */
 import { BLE } from '../../configs';
 import t from '../../hooks/Common/useTranslations';
@@ -81,7 +82,6 @@ const realScanBluetoothDevices = () => {
   setTimeout(() => {
     try {
       bleManager.stopDeviceScan();
-      // eslint-disable-next-line no-empty
     } catch {}
   }, 15000);
 };

package/src/iot/RemoteControl/GoogleHome.js

@@ -5,6 +5,8 @@ import { ToastBottomHelper } from '../../utils/Utils';
 import { API } from '../../configs';
 import { axiosPost } from '../../utils/Apis/axios';
 
+let connections = {};
+
 let configMaps = {};
 
 let attributeMaps = {};
@@ -87,14 +89,14 @@ async function fetchConnectionEntities(connection) {
     const entity = states[i];
     const entityId = entity.entity_id;
 
-    if (Object.prototype.hasOwnProperty.call(configMaps, entityId)) {
+    if (configMaps.hasOwnProperty(entityId)) {
       const [configId, type] = configMaps[entityId];
       const typeConverter = valueTypes[type] || keepValue;
 
       configValues[configId] = typeConverter(entity.state, entityId);
     }
 
-    if (Object.prototype.hasOwnProperty.call(attributeMaps, entityId)) {
+    if (attributeMaps.hasOwnProperty(entityId)) {
       const entityAttributeMaps = attributeMaps[entityId];
       for (const [attributeName, attributeMap] of Object.entries(
         entityAttributeMaps
@@ -116,21 +118,14 @@ async function fetchConnectionEntities(connection) {
   setConfigGlobalState('configValues', { ...configValues });
 }
 
-export const googleHomeConnect = async (
-  oldConnections,
-  options,
-  onEstablished,
-  onDisconnected,
-  onReconnected
-) => {
-  let connections = {};
-
+export const googleHomeConnect = async (options) => {
+  let isConnected = true;
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
 
-    if (option.chip_id in oldConnections && !!oldConnections[option.chip_id]) {
-      connections[option.chip_id] = oldConnections[option.chip_id];
-      continue;
+    if (option.chip_id in connections) {
+      // skip connected
+      return isConnected;
     }
     connections[option.chip_id] = 0; // connecting
 
@@ -157,45 +152,43 @@ export const googleHomeConnect = async (
       }
     });
 
-    try {
-      let auth = new Auth(option.auth);
-      const connection = await createConnection({ auth });
-      await connection.subscribeEvents(stateChangeCallback, 'state_changed');
-
-      connection.addEventListener('disconnected', async () => {
-        await onDisconnected(option);
-        ToastBottomHelper.error(t('command_googlehome_lost'));
-      });
-
-      connection.addEventListener('ready', async (conn, eventData) => {
-        await fetchConnectionEntities(conn);
-        await onReconnected(option, conn);
-        ToastBottomHelper.success(t('command_googlehome_ready'));
-      });
-
-      connections[option.chip_id] = connection;
-      await fetchConnectionEntities(connection);
-    } catch (err) {
-      connections[option.chip_id] = 0;
-    }
+    let auth = new Auth(option.auth);
+    const connection = await createConnection({ auth });
+    await connection.subscribeEvents(stateChangeCallback, 'state_changed');
+
+    connection.addEventListener('disconnected', () => {
+      ToastBottomHelper.error(t('command_googlehome_lost'));
+      isConnected = false;
+    });
+
+    connection.addEventListener('ready', async (conn, eventData) => {
+      await fetchConnectionEntities(conn);
+      ToastBottomHelper.success(t('command_googlehome_ready'));
+      isConnected = true;
+    });
+
+    connections[option.chip_id] = connection;
+    await fetchConnectionEntities(connection);
+    isConnected = true;
   }
-  await onEstablished(connections, options);
-  return connections;
+  return isConnected;
 };
 
-export const googleHomeDisconnect = async (connections, options) => {
+export const googleHomeDisconnect = async (options) => {
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
-    if (option.chip_id in connections) {
-      if (connections[option.chip_id]) {
-        await connections[option.chip_id].close();
-      }
+
+    if (!(option.chip_id in connections)) {
+      return;
     }
+
+    await connections[option.chip_id].close();
+    delete connections[option.chip_id];
   }
 };
 
-function getDeviceConnection(connections, device) {
-  return connections[device.chip_id];
+function getSensorConnection(sensor) {
+  return connections[sensor.chip_id];
 }
 
 function getServiceName(message) {
@@ -216,20 +209,10 @@ async function sendCommandSingleAction(connection, ghAction, data) {
     message.service_data[name] = data;
   }
 
-  try {
-    await connection.sendMessagePromise(message);
-    return true;
-  } catch (err) {
-    ToastBottomHelper.error(t('command_send_fail_googlehome'));
-  }
+  await connection.sendMessagePromise(message);
 }
 
-export async function sendCommandOverGoogleHome(
-  connections,
-  device,
-  action,
-  data
-) {
+export async function sendCommandOverGoogleHome(sensor, action, data) {
   if (
     !(action.googlehome_actions && action.googlehome_actions.length) &&
     !action.googlehome_action
@@ -237,39 +220,30 @@ export async function sendCommandOverGoogleHome(
     return;
   }
 
-  const connection = getDeviceConnection(connections, device);
+  const connection = getSensorConnection(sensor);
   if (!connection) {
     ToastBottomHelper.error(t('command_send_fail_googlehome'));
     return;
   }
 
-  let triggerSuccess;
-
   if (action.googlehome_actions) {
     for (let i = 0; i < action.googlehome_actions.length; i++) {
-      triggerSuccess = await sendCommandSingleAction(
+      await sendCommandSingleAction(
         connection,
         action.googlehome_actions[i],
         data
       );
     }
   } else if (action.googlehome_action) {
-    triggerSuccess = await sendCommandSingleAction(
-      connection,
-      action.googlehome_action,
-      data
-    );
+    await sendCommandSingleAction(connection, action.googlehome_action, data);
   }
 
-  if (triggerSuccess) {
-    const { success } = await axiosPost(API.DEVICE.ACTIVITY_LOG(), {
-      action_id: action.id,
-      message: 'Trigger by user action with google home',
-    });
-    if (success) {
-      ToastBottomHelper.success(t('command_send_success_googlehome'));
-    }
-    return success;
+  const { success } = await axiosPost(API.SENSOR.ACTIVITY_LOG(), {
+    action_id: action.id,
+    message: 'Trigger by user action with google home',
+  });
+  if (success) {
+    ToastBottomHelper.success(t('command_send_success_googlehome'));
   }
-  return false;
+  return success;
 }

package/src/iot/RemoteControl/Internet.js

@@ -17,7 +17,7 @@ export const sendCommandOverInternet = async (
     }
   }
   ToastBottomHelper.success(t('Sending command via internet'));
-  const { success } = await axiosPost(API.DEVICE.TRIGGER_ACTION(sensor.id), {
+  const { success } = await axiosPost(API.SENSOR.QUICK_ACTION(sensor.id), {
     key: action.key,
     data,
     source,

package/src/iot/RemoteControl/__test__/GoogleHome.test.js

@@ -1,6 +1,6 @@
 import { createConnection, getStates } from 'home-assistant-js-websocket';
 import Toast from 'react-native-toast-message';
-import MockAdapter from 'axios-mock-adapter';
+import axios from 'axios';
 import {
   googleHomeConnect,
   googleHomeDisconnect,
@@ -9,9 +9,8 @@ import {
 import { getConfigGlobalState, setConfigGlobalState } from '../../states';
 import { API } from '../../../configs';
 import { getTranslate } from '../../../utils/I18n';
-import api from '../../../utils/Apis/axios';
 
-const mock = new MockAdapter(api.axiosInstance);
+jest.mock('axios');
 jest.mock('home-assistant-js-websocket', () => {
   return {
     Auth: jest.fn(),
@@ -27,10 +26,6 @@ const connection = {
   close: jest.fn(),
 };
 
-const mockEstablished = jest.fn();
-const mockDisconnected = jest.fn();
-const mockReconnected = jest.fn();
-
 getStates.mockImplementation(() => []);
 createConnection.mockImplementation(() => connection);
 
@@ -85,7 +80,13 @@ describe('Remote Control Google Home', () => {
     },
   };
 
+  const response = {
+    status: 200,
+  };
+
   beforeEach(async () => {
+    axios.post.mockClear();
+    await googleHomeDisconnect(options);
     connection.sendMessagePromise.mockClear();
     createConnection.mockClear();
     getStates.mockClear();
@@ -111,13 +112,7 @@ describe('Remote Control Google Home', () => {
     let configValues = getConfigGlobalState('configValues');
     expect(configValues).toEqual({});
 
-    await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
+    await googleHomeConnect(options);
     expect(createConnection).toBeCalledTimes(1);
     expect(getStates).toBeCalledTimes(1);
 
@@ -153,33 +148,15 @@ describe('Remote Control Google Home', () => {
       }
     });
 
-    await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
+    await googleHomeConnect(options);
 
     configValues = getConfigGlobalState('configValues');
     expect(configValues).toEqual({ 1: true });
   });
 
   it('Connect to same google home will be skipped', async () => {
-    const connections = await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
-    await googleHomeConnect(
-      connections,
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
+    await googleHomeConnect(options);
+    await googleHomeConnect(options);
     expect(createConnection).toBeCalledTimes(1);
     expect(getStates).toBeCalledTimes(1);
   });
@@ -190,13 +167,7 @@ describe('Remote Control Google Home', () => {
         listener();
       }
     });
-    await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
+    await googleHomeConnect(options);
     expect(createConnection).toBeCalledTimes(1);
     expect(getStates).toBeCalledTimes(2);
   });
@@ -207,31 +178,21 @@ describe('Remote Control Google Home', () => {
         listener();
       }
     });
-    await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
+    await googleHomeConnect(options);
     expect(Toast.show).toBeCalledWith({
-      type: 'error',
+      type: 'success',
       position: 'bottom',
-      text1: getTranslate('en', 'command_googlehome_lost'),
+      text1: getTranslate('en', 'command_googlehome_ready'),
       visibilityTime: 1000,
     });
   });
 
   it('Send command over google home will send message to chip', async () => {
-    mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
-    const connections = await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
-    await sendCommandOverGoogleHome(connections, sensor, action);
+    axios.post.mockImplementation(async () => {
+      return response;
+    });
+    await googleHomeConnect(options);
+    await sendCommandOverGoogleHome(sensor, action);
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_actions[0].message
     );
@@ -248,19 +209,21 @@ describe('Remote Control Google Home', () => {
       },
       id: 20,
     };
-    mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
-    const connections = await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
-    await sendCommandOverGoogleHome(connections, sensor, action, 19);
+
+    axios.post.mockImplementation(async () => {
+      return response;
+    });
+    await googleHomeConnect(options);
+    await sendCommandOverGoogleHome(sensor, action, 19);
+
     action.googlehome_actions[0].message.service_data.temperature = 19;
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_actions[0].message
     );
+    expect(axios.post).toHaveBeenCalledWith(API.SENSOR.ACTIVITY_LOG(), {
+      action_id: 1,
+      message: 'Trigger by user action with google home',
+    });
   });
 
   it('Send command over google home action googlehome_action one to one', async () => {
@@ -275,48 +238,38 @@ describe('Remote Control Google Home', () => {
       },
       id: 20,
     };
-    mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
-    const connections = await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
-    await sendCommandOverGoogleHome(connections, sensor, action, 19);
+
+    axios.post.mockImplementation(async () => {
+      return response;
+    });
+    await googleHomeConnect(options);
+    await sendCommandOverGoogleHome(sensor, action, 19);
+
     action.googlehome_action.message.service_data.temperature = 19;
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_action.message
     );
+    expect(axios.post).toHaveBeenCalledWith(API.SENSOR.ACTIVITY_LOG(), {
+      action_id: 1,
+      message: 'Trigger by user action with google home',
+    });
   });
 
   it('Send command over google home that not connected', async () => {
-    await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
-    await sendCommandOverGoogleHome({}, { chip_id: 2 }, action);
+    await googleHomeConnect(options);
+    await sendCommandOverGoogleHome({ chip_id: 2 }, action);
     expect(connection.sendMessagePromise).not.toBeCalled();
   });
 
   it('Send command over google home that not a google home', async () => {
-    await googleHomeConnect(
-      {},
-      options,
-      mockEstablished,
-      mockDisconnected,
-      mockReconnected
-    );
-    await sendCommandOverGoogleHome({}, sensor, {});
+    await googleHomeConnect(options);
+    await sendCommandOverGoogleHome(sensor, {});
     expect(connection.sendMessagePromise).not.toBeCalled();
   });
 
   it('Disconnect a not connected gateway', async () => {
     connection.close.mockClear();
-    await googleHomeDisconnect({}, options);
+    await googleHomeDisconnect(options);
     expect(connection.close).not.toBeCalled();
   });
 });

package/src/iot/RemoteControl/__test__/Internet.test.js

@@ -1,37 +1,26 @@
 import Toast from 'react-native-toast-message';
-import MockAdapter from 'axios-mock-adapter';
+import axios from 'axios';
 import { sendCommandOverInternet } from '../Internet';
-import api from '../../../utils/Apis/axios';
-import { API } from '../../../configs';
 
-const mock = new MockAdapter(api.axiosInstance);
+jest.mock('axios');
 
 describe('Test IOT Remote Control Internet', () => {
   beforeEach(() => {
     Toast.show.mockClear();
+    axios.post.mockClear();
   });
 
   test('Trigger action via request POST', async () => {
-    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(200);
+    axios.post.mockImplementation(() => ({ status: 200 }));
     await sendCommandOverInternet({}, {}, 'internet');
-    expect(Toast.show).toBeCalledTimes(2);
-  });
-
-  test('Trigger action via request POST with data isInteger', async () => {
-    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(200);
-    await sendCommandOverInternet({}, {}, 1);
-    expect(Toast.show).toBeCalledTimes(2);
-  });
-
-  test('Trigger action via request POST with data is null', async () => {
-    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(200);
-    await sendCommandOverInternet({}, {}, null);
+    expect(axios.post).toBeCalled();
     expect(Toast.show).toBeCalledTimes(2);
   });
 
   test('Trigger action fail show error', async () => {
-    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(400);
+    axios.post.mockImplementation(() => ({ success: false }));
     await sendCommandOverInternet({}, {}, 'internet');
+    expect(axios.post).toBeCalled();
     expect(Toast.show).toBeCalled();
   });
 });