@eohjsc/react-native-smart-city 0.2.99 → 0.3.2

package/src/iot/RemoteControl/GoogleHome.js

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

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