@eohjsc/react-native-smart-city 0.3.91 → 0.3.93

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

@@ -1,4 +1,6 @@
 import { BleManager } from 'react-native-ble-plx';
+import { getTranslate } from '../../../utils/I18n';
+import { ToastBottomHelper } from '../../../utils/Utils';
 import '../Bluetooth';
 import {
   scanBluetoothDevices,
@@ -7,10 +9,18 @@ import {
   clearFoundDevices,
 } from '../Bluetooth';
 
+jest.mock('react-native-crypto-aes-cbc', () => ({
+  ...jest.requireActual('react-native-crypto-aes-cbc'),
+  encryptInBase64: jest.fn().mockReturnValue('af9534b8'),
+}));
+
 const bleManager = new BleManager();
 
 const mockOnDeviceFound = jest.fn();
 
+const spyToastSuccess = jest.spyOn(ToastBottomHelper, 'success');
+const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
+
 describe('Test IOT Bluetooth', () => {
   beforeEach(() => {
     mockOnDeviceFound.mockClear();
@@ -23,11 +33,14 @@ describe('Test IOT Bluetooth', () => {
   afterEach(() => {
     clearFoundDevices();
     clearNeedToScanDevices();
+    spyToastSuccess.mockClear();
+    spyToastError.mockClear();
   });
 
   it('Send command over bluetooth via device success', async () => {
     const device = {
       name: '1234567',
+      password: 'aWZux%Z7EN9J-}ah',
       cancelConnection: jest.fn(),
       connect: async () => ({
         discoverAllServicesAndCharacteristics: async () => ({
@@ -43,16 +56,143 @@ describe('Test IOT Bluetooth', () => {
     );
     await scanBluetoothDevices([device.name], mockOnDeviceFound);
 
+    const result = await sendCommandOverBluetooth(
+      {
+        remote_control_options: {
+          bluetooth: {
+            address: device.name,
+          },
+        },
+      },
+      {}
+    );
+    expect(result).toBeTruthy();
+  });
+
+  it('Send command over bluetooth via device with secret key successfully', async () => {
+    const device = {
+      name: '1234567',
+      cancelConnection: jest.fn(),
+      connect: async () => ({
+        discoverAllServicesAndCharacteristics: async () => ({
+          writeCharacteristicWithResponseForService: async () => ({}),
+          monitorCharacteristicForService: async (_, __, fn) => {
+            fn(null, { value: 'T0s=' }); //  T0s= is OK
+          },
+        }),
+      }),
+      readCharacteristicForService: jest
+        .fn()
+        .mockResolvedValue({ value: 'KaLAVw==' }),
+    };
+    bleManager.startDeviceScan.mockImplementation(
+      (uuids, options, listener) => {
+        listener(null, device);
+      }
+    );
+    await scanBluetoothDevices([device.name], mockOnDeviceFound);
+
     await sendCommandOverBluetooth(
       {
         remote_control_options: {
           bluetooth: {
             address: device.name,
+            password: 'aWZux%Z7EN9J-}ah',
+            user: 1,
+            is_use_secret_key: true,
           },
         },
       },
       {}
     );
+    expect(spyToastSuccess).toBeCalledWith(
+      getTranslate('en', 'control_device_via_bluetooth_successfully')
+    );
+  });
+
+  it('Send command over bluetooth via device with secret key failure', async () => {
+    const device = {
+      name: '1234567',
+      cancelConnection: jest.fn(),
+      connect: async () => ({
+        discoverAllServicesAndCharacteristics: async () => ({
+          writeCharacteristicWithResponseForService: async () => ({}),
+          monitorCharacteristicForService: async (_, __, fn) => {
+            fn({ message: 'FAILED' });
+          },
+        }),
+        cancelConnection: jest.fn(),
+      }),
+      readCharacteristicForService: jest
+        .fn()
+        .mockResolvedValue({ value: 'KaLAVw==' }),
+    };
+    bleManager.startDeviceScan.mockImplementation(
+      (uuids, options, listener) => {
+        listener(null, device);
+      }
+    );
+    await scanBluetoothDevices([device.name], mockOnDeviceFound);
+
+    await sendCommandOverBluetooth(
+      {
+        remote_control_options: {
+          bluetooth: {
+            address: device.name,
+            password: null,
+            user: 1,
+            is_use_secret_key: true,
+          },
+        },
+      },
+      {}
+    );
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'command_is_fail_to_send_via_bluetooth')
+    );
+  });
+
+  it('Send command over bluetooth via device with secret key failure because chip does not response', async () => {
+    jest.useFakeTimers();
+    const device = {
+      name: '1234567',
+      cancelConnection: jest.fn(),
+      connect: async () => ({
+        discoverAllServicesAndCharacteristics: async () => ({
+          writeCharacteristicWithResponseForService: async () => ({}),
+          monitorCharacteristicForService: async (_, __, fn) => {},
+        }),
+        cancelConnection: jest.fn(),
+      }),
+      readCharacteristicForService: jest
+        .fn()
+        .mockResolvedValue({ value: 'KaLAVw==' }),
+    };
+
+    bleManager.startDeviceScan.mockImplementation(
+      (uuids, options, listener) => {
+        listener(null, device);
+      }
+    );
+    await scanBluetoothDevices([device.name], mockOnDeviceFound);
+
+    await sendCommandOverBluetooth(
+      {
+        remote_control_options: {
+          bluetooth: {
+            address: device.name,
+            password: 'aWZux%Z7EN9J-}ah',
+            user: 1,
+            is_use_secret_key: true,
+          },
+        },
+      },
+      {}
+    );
+    jest.runAllTimers();
+    expect(spyToastError).toBeCalledWith(
+      getTranslate('en', 'command_is_fail_to_send_via_bluetooth')
+    );
   });
 
   test('Scan bluetooth device will init hardware scan', async () => {

package/src/iot/mqtt.js

@@ -0,0 +1,233 @@
+import { updateGlobalValue } from './Monitor';
+import { Buffer } from 'buffer';
+
+const int_all = (bytes_str, config_data = null) => {
+  let val;
+  val = Number.parseInt(bytes_str, 16);
+
+  if (val > 32767) {
+    val = val - 65536;
+  }
+
+  return val;
+};
+
+const int_first4 = (bytes_str, config_data = null) => {
+  return Number.parseInt(bytes_str.slice(0, 4), 16);
+};
+
+const int_last4 = (bytes_str, config_data = null) => {
+  return Number.parseInt(bytes_str.slice(4), 16);
+};
+
+const uint_32 = (bytes_str, config_data = null) => {
+  let bits = 32;
+  let value = Number.parseInt(bytes_str, 16);
+
+  if (value & (1 << (bits - 1))) {
+    value -= 1 << bits;
+  }
+
+  return value;
+};
+
+const float_convert = (bytes_str) => {
+  const struct = require('python-struct');
+  let value = null;
+  try {
+    value = struct.unpack('>f', Buffer.from(bytes_str, 'hex'))[0];
+    // eslint-disable-next-line no-empty
+  } catch {}
+  return value;
+};
+
+const float_cdba = (bytes_str, config_data = null) => {
+  const bytes_cdba = bytes_str?.slice(4) + bytes_str?.slice(0, 4);
+  return float_convert(bytes_cdba);
+};
+
+const float_abcd = (bytes_str, config_data = null) => {
+  return float_convert(bytes_str);
+};
+
+const range_value_converting = (
+  raw_value,
+  raw_min,
+  raw_max,
+  value_min,
+  value_max
+) => {
+  const rawValue = parseInt(raw_value, 16);
+  const meaning_range = value_max - value_min;
+  const value_range = raw_max - raw_min;
+  if (!value_range) {
+    return null;
+  }
+
+  const value = rawValue - raw_min;
+  const meaning_value = (value * meaning_range) / value_range;
+  return meaning_value + value_min;
+};
+
+const convert_ai = (bytes_str, config_data = null) => {
+  return range_value_converting(
+    bytes_str,
+    config_data?.ai_trans_min_raw_in,
+    config_data?.ai_trans_max_raw_in,
+    config_data?.ai_trans_min_value,
+    config_data?.ai_trans_max_value
+  );
+};
+
+const mappingTransformer = {
+  int_all: int_all,
+  int_first4: int_first4,
+  int_last4: int_last4,
+  uint_32: uint_32,
+  float_cdba: float_cdba,
+  float_abcd: float_abcd,
+  convert_ai: convert_ai,
+};
+
+const extract_config_value = (register, value_bytes) => {
+  const transformer = mappingTransformer[register?.transformer];
+  if (!transformer) {
+    return null;
+  }
+
+  return transformer(value_bytes, register);
+};
+
+const get_modbus_length = (config) => {
+  const len = config?.len;
+  if ([1, 2].includes(config?.func)) {
+    return len * 2;
+  }
+  return len * 4;
+};
+
+const get_config_value = (register, data) => {
+  const size = get_modbus_length(register);
+  const value_bytes = data?.slice(0, size);
+
+  const value = extract_config_value(register, value_bytes);
+  if (value === undefined || value === null) {
+    return { value: null, data: null };
+  }
+
+  return { value, data: data.slice(size) };
+};
+
+const get_sensor_size = (sensor) => {
+  let size = 0;
+  (sensor?.configs || []).forEach((config) => {
+    size += get_modbus_length(config);
+  });
+  return size;
+};
+
+const get_sensor_data = (sensor, data) => {
+  const size = get_sensor_size(sensor);
+  return { sensor_data: data.slice(0, size), data: data.slice(size) };
+};
+
+const get_scale_value = (value, config) => {
+  value = value && value * (config?.scale || 1);
+  value =
+    config?.decimal_behind || config?.decimal_behind === 0
+      ? value.toFixed(config?.decimal_behind)
+      : value;
+  return value;
+};
+
+const updateGlobalValueMqtt = (config, value) => {
+  if (!config?.id) {
+    return;
+  }
+  if (value === undefined || value === null) {
+    return;
+  }
+
+  value = get_scale_value(value, config);
+  updateGlobalValue(config.id, { value: Number(value) });
+};
+
+export const handleModbusData = (chip, configById, data) => {
+  const modbus_gateway = chip?.modbus_gateway;
+  if (!modbus_gateway) {
+    return;
+  }
+
+  (modbus_gateway?.sensors || []).forEach((device) => {
+    let { sensor_data, data: new_data } = get_sensor_data(device, data);
+    data = new_data;
+
+    (device?.configs || []).forEach((register) => {
+      let { value, data: new_sensor_data } = get_config_value(
+        register,
+        sensor_data
+      );
+      sensor_data = new_sensor_data;
+
+      const configId = register?.config;
+      updateGlobalValueMqtt(configById[configId], value);
+    });
+  });
+};
+
+export const handleChipData = (configById, configId, data) => {
+  updateGlobalValueMqtt(configById[configId], Number(data?.v));
+};
+
+export const handleZigbeeData = (chip, configById, ieee_address, data) => {
+  const zigbee_gateway = chip?.zigbee_gateway;
+  if (!zigbee_gateway) {
+    return;
+  }
+
+  const zigbee_device_by_ieee = {};
+
+  (zigbee_gateway?.sensors || []).forEach((device) => {
+    zigbee_device_by_ieee[device.ieee_address] = device;
+  });
+
+  const device = zigbee_device_by_ieee[ieee_address];
+  if (device) {
+    (device.configs || []).forEach((config_map) => {
+      let value = data?.data[config_map?.key];
+      const configId = config_map?.config;
+      updateGlobalValueMqtt(configById[configId], value);
+    });
+  }
+};
+
+export const handleMqttMessage = (
+  topic,
+  payloadData,
+  code,
+  chip,
+  configById
+) => {
+  if (topic === `eoh/chip/${code}/data`) {
+    // Modbus
+    // topic: eoh/chip/${code}/data
+    // payload: {data: '01aa010a', 'ack':'1', 'chip_temperature':5333, 'rssi':-61}
+    handleModbusData(chip, configById, payloadData.data);
+  }
+
+  const matchArduinoConfigValue = topic.match(/config\/(\d+)\/value/);
+  if (matchArduinoConfigValue) {
+    // Arduino
+    // topic: eoh/chip/{code}/config/127363/value
+    // payload: {v: 2130}
+    handleChipData(configById, matchArduinoConfigValue[1], payloadData);
+  }
+
+  const matchZigbeeConfigValue = topic.match(/zigbee\/(.+)\/data/);
+  if (matchZigbeeConfigValue) {
+    // Zigbee
+    // topic: eoh/chip/code-123/zigbee/IEEE-123/data
+    // payload: {zigbee_data: 'aaa', 'data': {state: 1, state_0: 0}}
+    handleZigbeeData(chip, configById, matchZigbeeConfigValue[1], payloadData);
+  }
+};

package/src/navigations/UnitStack.js

@@ -18,6 +18,7 @@ import { Action } from '../context/actionType';
 
 import AQIGuide from '../screens/AQIGuide';
 import DeviceDetail from '../screens/Device/detail';
+import ChangePosition from '../screens/ChangePosition';
 import SharingMemberList from '../screens/Sharing/MemberList';
 import ManageSubUnit from '../screens/SubUnit/ManageSubUnit';
 import SelectAddress from '../screens/Unit/SelectAddress';
@@ -31,20 +32,20 @@ import UVIndexGuide from '../screens/UVIndexGuide';
 import TDSGuide from '../screens/TDSGuide';
 import WaterQualityGuide from '../screens/WaterQualityGuide';
 import DeviceInfo from '../screens/DeviceInfo';
-import AddNewOneTap from '../screens/AddNewOneTap';
-import AddNewAutoSmart from '../screens/AddNewAutoSmart';
+import AddNewOneTap from '../screens/Automate/OneTap';
+import AddUnknownTypeSmart from '../screens/Automate/AddNewAutoSmart/AddUnknownTypeSmart';
 import PlaybackCamera from '../screens/PlayBackCamera';
 import AllCamera from '../screens/AllCamera';
 import ManageAccessScreen from '../screens/ManageAccess';
 import MoveToAnotherSubUnit from '../screens/MoveToAnotherSubUnit';
 import GuestInfo from '../screens/GuestInfo';
-import ScriptDetail from '../screens/ScriptDetail';
-import EditActionsList from '../screens/EditActionsList';
+import ScriptDetail from '../screens/Automate/ScriptDetail';
+import EditActionsList from '../screens/Automate/EditActionsList';
 import SelectUnit from '../screens/SelectUnit';
-import SetSchedule from '../screens/SetSchedule';
-import SelectMonitorDevices from '../screens/AddNewAction/SelectMonitorDevices';
+import SetSchedule from '../screens/Automate/SetSchedule';
+import SelectMonitorDevices from '../screens/Automate/AddNewAction/SelectMonitorDevices';
 import EditSubUnit from '../screens/SubUnit/EditSubUnit';
-import SetupConfigCondition from '../screens/AddNewAction/SetupConfigCondition';
+import SetupConfigCondition from '../screens/Automate/AddNewAction/SetupConfigCondition';
 import EditDevice from '../screens/Device/EditDevice/index';
 import EmergencySetting from '../screens/EmergencySetting';
 import ConfirmUnitDeletion from '../screens/ConfirmUnitDeletion';
@@ -59,9 +60,12 @@ import { styles } from './UnitStackStyles';
 import { useBluetoothConnection } from '../hooks/IoT';
 import { realScanBluetoothDevices } from '../iot/RemoteControl/Bluetooth';
 import { ToastBottomHelper } from '../utils/Utils';
-import ChooseConfig from '../screens/AddNewAction/ChooseConfig';
-import SelectControlDevices from '../screens/AddNewAction/SelectControlDevices';
-import ChooseAction from '../screens/AddNewAction/ChooseAction';
+import ChooseConfig from '../screens/Automate/AddNewAction/ChooseConfig';
+import SelectControlDevices from '../screens/Automate/AddNewAction/SelectControlDevices';
+import ChooseAction from '../screens/Automate/AddNewAction/ChooseAction';
+import ScenarioName from '../screens/Automate/Scenario/ScenarioName';
+import ValueChangeName from '../screens/Automate/ValueChange/ValueChangeName';
+import AddAutomationTypeSmart from '../screens/Automate/AddNewAutoSmart/AddAutomationTypeSmart';
 
 const Stack = createStackNavigator();
 
@@ -269,6 +273,13 @@ export const UnitStack = memo((props) => {
           headerShown: false,
         }}
       />
+      <Stack.Screen
+        name={Route.ChangePosition}
+        component={ChangePosition}
+        options={{
+          headerShown: false,
+        }}
+      />
       <Stack.Screen
         name={Route.HanetCameraStack}
         component={HanetCameraStack}
@@ -389,8 +400,29 @@ export const UnitStack = memo((props) => {
         }}
       />
       <Stack.Screen
-        name={Route.AddNewAutoSmart}
-        component={AddNewAutoSmart}
+        name={Route.AddUnknownTypeSmart}
+        component={AddUnknownTypeSmart}
+        options={{
+          headerShown: false,
+        }}
+      />
+      <Stack.Screen
+        name={Route.AddAutomationTypeSmart}
+        component={AddAutomationTypeSmart}
+        options={{
+          headerShown: false,
+        }}
+      />
+      <Stack.Screen
+        name={Route.ScenarioName}
+        component={ScenarioName}
+        options={{
+          headerShown: false,
+        }}
+      />
+      <Stack.Screen
+        name={Route.ValueChangeName}
+        component={ValueChangeName}
         options={{
           headerShown: false,
         }}

package/src/screens/AddLocationMaps/index.js

@@ -7,7 +7,7 @@ import { check, RESULTS } from 'react-native-permissions';
 import { useTranslations } from '../../hooks/Common/useTranslations';
 
 import Text from '../../commons/Text';
-import { ViewButtonBottom, FullLoading } from '../../commons';
+import { FullLoading } from '../../commons';
 import SearchBarLocation from '../../commons/SearchLocation';
 import RowLocation from '../../commons/SearchLocation/RowLocation';
 import { axiosGet } from '../../utils/Apis/axios';
@@ -25,8 +25,7 @@ import {
   OpenSetting,
 } from '../../utils/Permission/common';
 import { openPromptEnableLocation } from '../../utils/Setting/Location';
-
-export const initialRadius = 250;
+import BottomButtonView from '../../commons/BottomButtonView';
 
 navigator.geolocation = require('@react-native-community/geolocation');
 
@@ -44,11 +43,7 @@ const AddLocationMaps = memo(() => {
       location: searchedLocation,
       isAddUnit: true,
     });
-  }, [searchedLocation, navigate]);
-
-  const onBack = useCallback(() => {
-    goBack();
-  }, [goBack]);
+  }, [navigate, searchedLocation]);
 
   const onTextInput = useCallback(async (newValue) => {
     setInput(newValue);
@@ -191,7 +186,10 @@ const AddLocationMaps = memo(() => {
           {t('text_explain_add_geolocation')}
         </Text>
         <View style={styles.searchLocation}>
-          <SearchBarLocation input={input} onTextInput={onTextInput} />
+          <SearchBarLocation
+            input={input?.description || input}
+            onTextInput={onTextInput}
+          />
           <ScrollView
             style={styles.searchData}
             scrollIndicatorInsets={{ right: 1 }}
@@ -282,13 +280,17 @@ const AddLocationMaps = memo(() => {
           </MapView>
         </View>
       </View>
-      <ViewButtonBottom
-        leftTitle={t('cancel')}
-        onLeftClick={onBack}
-        rightTitle={t('done')}
-        onRightClick={onDone}
-        rightDisabled={!input}
-        accessibilityLabelPrefix={'LOCATION_'}
+      <BottomButtonView
+        rowButton
+        style={styles.bottomButton}
+        mainTitle={t('done')}
+        onPressMain={onDone}
+        secondaryTitle={t('cancel')}
+        onPressSecondary={goBack}
+        typeMain={input?.description ? 'primaryText' : 'disabled'}
+        typeSecondary="primaryText"
+        accessibilityLabelPrefix="LOCATION_"
+        disableBackgroundMainButton
       />
       {loading && <FullLoading />}
     </View>

package/src/screens/AddLocationMaps/indexStyle.js

@@ -57,4 +57,7 @@ export default StyleSheet.create({
   text: {
     marginLeft: 12,
   },
+  bottomButton: {
+    backgroundColor: Colors.White,
+  },
 });

package/src/screens/AddNewGateway/SelectDeviceSubUnit.js

@@ -1,6 +1,5 @@
-import React from 'react';
+import React, { useCallback } from 'react';
 import SelectSubUnit from '../../commons/SelectSubUnit';
-import { useCallback } from 'react';
 import { useTranslations } from '../../hooks/Common/useTranslations';
 import { useNavigation } from '@react-navigation/native';
 import Routes from '../../utils/Route';

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

@@ -11,6 +11,7 @@ import { getTranslate } from '../../../utils/I18n';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import api from '../../../utils/Apis/axios';
+import { useNavigation } from '@react-navigation/native';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -20,28 +21,15 @@ const wrapComponent = (route) => (
 
 const mock = new MockAdapter(api.axiosInstance);
 
-const mockedNavigate = jest.fn();
-const mockedGoBack = jest.fn();
-
-jest.mock('@react-navigation/native', () => {
-  return {
-    ...jest.requireActual('@react-navigation/native'),
-    useNavigation: () => ({
-      navigate: mockedNavigate,
-      goBack: mockedGoBack,
-    }),
-  };
-});
-
 describe('Test AddNewGateway', () => {
   let tree;
   let route;
-
-  afterEach(() => {
-    mockedNavigate.mockClear();
-  });
+  const mockedGoBack = useNavigation().goBack;
+  const mockedNavigate = useNavigation().navigate;
 
   beforeEach(() => {
+    mockedGoBack.mockClear();
+    mockedNavigate.mockClear();
     route = {
       params: {
         unit_id: 1,

package/src/screens/AddNewGateway/__test__/SelectDeviceSubUnit.test.js

@@ -6,19 +6,11 @@ import { ViewButtonBottom } from '../../../commons';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import { DEVICE_TYPE } from '../../../configs/Constants';
+import { useNavigation } from '@react-navigation/native';
+import MockAdapter from 'axios-mock-adapter';
+import api from '../../../utils/Apis/axios';
 
-const mockedGoBack = jest.fn();
-const mockedNavigate = jest.fn();
-jest.mock('@react-navigation/native', () => {
-  return {
-    ...jest.requireActual('@react-navigation/native'),
-    useNavigation: () => ({
-      navigate: mockedNavigate,
-      goBack: mockedGoBack,
-    }),
-    useIsFocused: () => ({}),
-  };
-});
+new MockAdapter(api.axiosInstance);
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -27,9 +19,9 @@ const wrapComponent = (route) => (
 );
 
 describe('Test SelectSubUnit', () => {
+  const mockedNavigate = useNavigation().navigate;
   beforeEach(() => {
     mockedNavigate.mockClear();
-    mockedGoBack.mockClear();
   });
   let tree;