@eohjsc/react-native-smart-city 0.3.81 → 0.3.82

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eohjsc/react-native-smart-city",
   "title": "React Native Smart Home",
-  "version": "0.3.81",
+  "version": "0.3.82",
   "description": "TODO",
   "main": "index.js",
   "files": [
@@ -162,7 +162,7 @@
     "react-native-credit-card-input": "^0.4.1",
     "react-native-dash": "^0.0.11",
     "react-native-deep-linking": "^2.2.0",
-    "react-native-device-info": "^5.6.3",
+    "react-native-device-info": "^10.3.0",
     "react-native-draggable-flatlist": "^2.6.2",
     "react-native-fast-image": "^8.3.2",
     "react-native-geocoder": "^0.5.0",

package/src/commons/ActionGroup/__test__/OnOffButtonTemplate.test.js

@@ -1,8 +1,16 @@
 import React from 'react';
+import { TouchableOpacity } from 'react-native';
 import { act, create } from 'react-test-renderer';
+
 import OnOffTemplate from '../OnOffTemplate';
 import { mockSCStore } from '../../../context/mockStore';
 import { SCProvider } from '../../../context';
+import Text from '../../Text';
+import { useConfigGlobalState } from '../../../iot/states';
+
+jest.mock('../../../iot/states', () => ({
+  useConfigGlobalState: jest.fn(),
+}));
 
 const wrapComponent = (actionGroup, mockDoAction) => (
   <SCProvider initState={mockSCStore({})}>
@@ -49,45 +57,79 @@ describe('Test OneBigButtonTemplate', () => {
       action_off_data: action_off_data,
       icon_off: 'caret-up',
       text_off: 'OFF',
+      config: 1,
     },
+    template: 'on_off_button_action_template',
+    id: 1,
   };
   let wrapper;
 
-  const assertRender = async () => {
+  beforeEach(() => {
+    useConfigGlobalState.mockClear();
+  });
+
+  const assertRender = async (textValue) => {
     const mockDoAction = jest.fn();
 
     await act(async () => {
       wrapper = create(wrapComponent(actionGroup, mockDoAction));
     });
 
-    const renderJson = wrapper.toJSON();
-
-    expect(renderJson[1].props?.visible).toEqual(false);
-    expect(renderJson[1]?.type).toEqual('Modal');
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts[0].props.children).toEqual(textValue);
   };
 
   it('render state on', async () => {
-    await assertRender(true, 'ON');
+    useConfigGlobalState.mockImplementation(() => [
+      {
+        1: {
+          value: 1,
+        },
+      },
+      jest.fn(),
+    ]);
+    await assertRender('ON');
   });
 
   it('render state off', async () => {
-    await assertRender(false, 'OFF');
+    useConfigGlobalState.mockImplementation(() => [
+      {
+        1: {
+          value: 0,
+        },
+      },
+      jest.fn(),
+    ]);
+    await assertRender('OFF');
   });
 
-  const assertActionCall = async (state, action_data) => {
+  const assertActionCall = async (state, action_data, data2) => {
+    useConfigGlobalState.mockImplementation(() => [
+      {
+        1: {
+          value: state,
+        },
+      },
+      jest.fn(),
+    ]);
     const mockDoAction = jest.fn();
     await act(async () => {
       wrapper = create(wrapComponent(actionGroup, mockDoAction));
     });
-
-    expect(mockDoAction).not.toHaveBeenCalled();
+    const instance = wrapper.root;
+    const button = instance.findByType(TouchableOpacity);
+    await act(async () => {
+      await button.props.onPress();
+    });
+    expect(mockDoAction).toHaveBeenCalledWith(action_data, data2);
   };
 
   it('action state on', async () => {
-    await assertActionCall(true, action_off_data);
+    await assertActionCall(true, action_on_data, { state: 0, value: 0 });
   });
 
   it('action state off', async () => {
-    await assertActionCall(false, action_on_data);
+    await assertActionCall(false, action_off_data, { state: 1, value: 1 });
   });
 });

package/src/commons/Device/ProgressBar/__test__/ProgressBar.test.js

@@ -0,0 +1,49 @@
+/* eslint-disable promise/prefer-await-to-callbacks */
+import React from 'react';
+import { useSelector } from 'react-redux';
+import renderer, { act } from 'react-test-renderer';
+
+import ProgressBar from '..';
+import Text from '../../../Text';
+import { SCProvider } from '../../../../context';
+import { mockSCStore } from '../../../../context/mockStore';
+
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+  useSelector: jest.fn(),
+}));
+
+const wrapComponent = (item, data) => (
+  <SCProvider initState={mockSCStore({})}>
+    <ProgressBar item={item} data={data} />
+  </SCProvider>
+);
+
+describe('Test ProgressBar', () => {
+  let tree;
+  beforeEach(() => {
+    const localState = {
+      language: 'en',
+    };
+    useSelector.mockImplementation((cb) => {
+      return cb(localState);
+    });
+  });
+
+  it('render ProgressBar', async () => {
+    const item = {
+      label: 'Value bar',
+      configuration: { max_value: 100 },
+      value: 8,
+    };
+    const data = [{ value: 10 }];
+    await act(async () => {
+      tree = renderer.create(wrapComponent(item, data));
+    });
+    const instance = tree.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts[0].props.children).toBe('Value bar');
+    expect(texts[1].props.children).toEqual(['Max value', ': ', 100]);
+    expect(texts[2].props.children).toEqual([10, '%']);
+  });
+});

package/src/commons/Device/ProgressBar/index.js

@@ -0,0 +1,45 @@
+import React, { memo, useMemo } from 'react';
+import { View } from 'react-native';
+import * as Progress from 'react-native-progress';
+
+import { Colors } from '../../../configs';
+import { useTranslations } from '../../../hooks/Common/useTranslations';
+import Text from '../../Text';
+import styles from './styles';
+
+const ProgressBar = memo(({ data = [], item }) => {
+  const t = useTranslations();
+
+  const maxValue = useMemo(() => {
+    return Number(item?.configuration?.max_value) || 60;
+  }, [item?.configuration?.max_value]);
+  const value = data.length ? data[0].value : 0;
+  const percent = value / maxValue; // a number between 0 and 1
+
+  return (
+    <View style={styles.container}>
+      <Text size={16} style={styles.textLabel}>
+        {item?.label || 'Label'}
+      </Text>
+
+      <Text size={16} style={styles.textMaxValue}>
+        {t('max_value')}: {maxValue}
+      </Text>
+
+      <View style={styles.wrapProgressBar}>
+        <Progress.Bar
+          progress={percent}
+          height={40}
+          width={200}
+          color={Colors.Blue16}
+          unfilledColor={Colors.Blue15}
+          borderWidth={0}
+          borderRadius={10}
+        />
+        <Text style={styles.textValue}>{value}%</Text>
+      </View>
+    </View>
+  );
+});
+
+export default ProgressBar;

package/src/commons/Device/ProgressBar/styles.js

@@ -0,0 +1,33 @@
+import { StyleSheet } from 'react-native';
+
+import { Colors } from '../../../configs';
+
+export default StyleSheet.create({
+  container: {
+    flex: 1,
+    flexDirection: 'column', //column direction
+    marginRight: 60,
+    marginLeft: 60,
+    borderWidth: 1,
+    padding: 12,
+    borderRadius: 8,
+    borderColor: Colors.Gray4,
+  },
+  textLabel: {
+    paddingHorizontal: 16,
+    paddingTop: 8,
+  },
+  textMaxValue: {
+    textAlign: 'right',
+  },
+  wrapProgressBar: {
+    flex: 1,
+    flexDirection: 'row',
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 8,
+  },
+  textValue: {
+    marginLeft: 8,
+  },
+});

package/src/commons/Popover/__test__/index.test.js

@@ -0,0 +1,31 @@
+import React from 'react';
+import { create, act } from 'react-test-renderer';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import PopoverComponent from '../index';
+import Popover from 'react-native-popover-view';
+
+const wrapComponent = (data) => (
+  <SCProvider initState={mockSCStore({})}>
+    <PopoverComponent {...data} />
+  </SCProvider>
+);
+const mockOnCloseComplete = jest.fn();
+describe('Test PopoverComponent', () => {
+  let tree;
+
+  it('Test Popover', async () => {
+    await act(async () => {
+      tree = await create(
+        wrapComponent({ isVisible: true, onCloseComplete: mockOnCloseComplete })
+      );
+    });
+    const instance = tree.root;
+    const popover = instance.findByType(Popover);
+    await act(async () => {
+      popover.props.onCloseComplete();
+    });
+    expect(popover.props.isVisible).toEqual(true);
+    expect(mockOnCloseComplete).toBeCalled();
+  });
+});

package/src/configs/Colors.js

@@ -120,6 +120,7 @@ export const Colors = {
   Blue13: '#E2F0F8',
   Blue14: '#D9ECFF',
   Blue15: '#99CCFF',
+  Blue16: '#0059B2',
 
   //Range Volcano:
   Volcano3: '#FFBB96',

package/src/configs/IOPinConstants.js

@@ -1,26 +1,29 @@
 export const INTERNAL_DEVICE = {
+  ESP8266: 'esp8266',
   ESP32: 'esp32',
   STM32: 'stm32',
+  STM32_WIFI: 'stm32_wifi',
   RASPBERRY_PI: 'raspberry_pi',
 };
 
 export const TYPE_BOARD = [
+  { value: INTERNAL_DEVICE.ESP8266, text: 'ESP8266' },
   { value: INTERNAL_DEVICE.ESP32, text: 'ESP32' },
-  { value: INTERNAL_DEVICE.STM32, text: 'STM32' },
+  { value: INTERNAL_DEVICE.STM32, text: 'STM32 - Gsm' },
+  { value: INTERNAL_DEVICE.STM32_WIFI, text: 'STM32 - Wifi' },
   { value: INTERNAL_DEVICE.RASPBERRY_PI, text: 'Raspberry Pi' },
 ];
 
 // DEFAULT
 
-export const TYPE_PIN_MODE = {
-  OUTPUT: 'output',
-  INPUT: 'input',
-};
 export const ARDUINO_PIN_CONFIG_TYPE = [
   { key: 'boolean', value: 'Digital' },
   { key: 'integer', value: 'Analog' },
 ];
 
+export const VIRTUAL_TYPE = 'virtual';
+export const VIRTUAL_CONFIG_TYPE = [{ key: VIRTUAL_TYPE, value: 'Virtual' }];
+
 export const READ_DIGITAL_PIN_MODE = [
   { key: 'input', value: 'Input' },
   { key: 'pull_up', value: 'Pullup' },
@@ -36,10 +39,46 @@ export const WRITE_DIGITAL_PIN_MODE = [
 
 export const WRITE_ANALOG_PIN_MODE = [{ key: 'pwm', value: 'PWM' }];
 
+// VIRTUAL_PIN
+export const VIRTUAL_PIN = new Array(256).fill().map((e, i) => {
+  return { key: i.toString(), value: `V${i}` };
+});
+
 export const CONFIG_IS_WRITE_IS_READ_PIN_MODE = [
   { key: 'output', value: 'Input' },
 ];
 
+// ESP8266
+
+export const ESP8266_DIGITAL = [
+  { key: '0', value: 'GPIO 0 - D3' },
+  { key: '1', value: 'GPIO 1 - D10 - UART 0 TX' },
+  { key: '2', value: 'GPIO 2 - D4 - UART 0 TX2' },
+  { key: '3', value: 'GPIO 3 - D9 - UART 0 RX' },
+  { key: '4', value: 'GPIO 4 - D2' },
+  { key: '5', value: 'GPIO 5 - D1' },
+  { key: '12', value: 'GPIO 12 - D6' },
+  { key: '13', value: 'GPIO 13 - D7 - UART 1 RX' },
+  { key: '14', value: 'GPIO 14 - D5' },
+  { key: '15', value: 'GPIO 15 - D8 - UART 1 TX' },
+  { key: '16', value: 'GPIO 16 - D0' },
+];
+
+export const ESP8266_ANALOG_READ = [{ key: '17', value: 'GPIO 17 - A0' }];
+
+export const ESP8266_ANALOG_WRITE = [
+  { key: '0', value: 'GPIO 0 - D3' },
+  { key: '1', value: 'GPIO 1 - D10 - UART 0 TX' },
+  { key: '2', value: 'GPIO 2 - D4 - UART 0 TX2' },
+  { key: '3', value: 'GPIO 3 - D9 - UART 0 RX' },
+  { key: '4', value: 'GPIO 4 - D2' },
+  { key: '5', value: 'GPIO 5 - D1' },
+  { key: '12', value: 'GPIO 12 - D6' },
+  { key: '13', value: 'GPIO 13 - D7 - UART 1 RX' },
+  { key: '14', value: 'GPIO 14 - D5' },
+  { key: '15', value: 'GPIO 15 - D8 - UART 1 TX' },
+];
+
 // ESP32
 
 export const ESP32_DIGITAL = [
@@ -146,172 +185,60 @@ export const RASPBERRY_PI_ANALOG_WRITE = [
   { key: '19', value: 'GPIO 19 - PWM 1' },
 ];
 
-export const STM32_DIGITAL_READ = [
-  { key: '0', value: 'PE1' },
-  { key: '1', value: 'PE0' },
-  { key: '2', value: 'PB9' },
-  { key: '3', value: 'PB8' },
-  { key: '4', value: 'PB7' },
-  { key: '5', value: 'PB6' },
-  { key: '6', value: 'PB5' },
-  { key: '7', value: 'PB3' },
-  { key: '8', value: 'PD7' },
-  { key: '9', value: 'PD6' },
-  { key: '10', value: 'PD5' },
-  { key: '11', value: 'PD4' },
-  { key: '12', value: 'PD3' },
-  { key: '13', value: 'PD2' },
-  { key: '14', value: 'PD1' },
-  { key: '15', value: 'PD0' },
-  { key: '16', value: 'PC12' },
-  { key: '17', value: 'PC11' },
-  { key: '18', value: 'PC10' },
-  { key: '19', value: 'PA15' },
-  { key: '20', value: 'PA12' },
-  { key: '21', value: 'PA11' },
-  { key: '22', value: 'PA10' },
-  { key: '23', value: 'PA9' },
-  { key: '24', value: 'PA8' },
-  { key: '25', value: 'PC9' },
-  { key: '26', value: 'PC8' },
-  { key: '27', value: 'PC7' },
-  { key: '28', value: 'PC6' },
-  { key: '29', value: 'PD15' },
-  { key: '30', value: 'PD14' },
-  { key: '31', value: 'PD13' },
-  { key: '32', value: 'PD12' },
-  { key: '33', value: 'PD11' },
-  { key: '34', value: 'PD10' },
-  { key: '35', value: 'PD9' },
-  { key: '36', value: 'PD8' },
-  { key: '37', value: 'PB15' },
-  { key: '38', value: 'PE2' },
-  { key: '39', value: 'PE3' },
-  { key: '40', value: 'PE4' },
-  { key: '41', value: 'PE5' },
-  { key: '42', value: 'PE6' },
-  { key: '43', value: 'PC13' },
-  { key: '44', value: 'PC0' },
-  { key: '45', value: 'PC1' },
-  { key: '46', value: 'PC2' },
-  { key: '47', value: 'PC3' },
-  { key: '48', value: 'PA0' },
-  { key: '49', value: 'PA1' },
-  { key: '50', value: 'PA2' },
-  { key: '51', value: 'PA3' },
-  { key: '52', value: 'PA4' },
-  { key: '53', value: 'PA5' },
-  { key: '54', value: 'PC4' },
-  { key: '55', value: 'PC5' },
-  { key: '56', value: 'PB0' },
-  { key: '57', value: 'PB1' },
-  { key: '58', value: 'PA6' },
-  { key: '59', value: 'PA7' },
-  { key: '60', value: 'PE7' },
-  { key: '61', value: 'PE8' },
-  { key: '62', value: 'PE9' },
-  { key: '63', value: 'PE10' },
-  { key: '64', value: 'PE11' },
-  { key: '65', value: 'PE12' },
-  { key: '66', value: 'PE13' },
-  { key: '67', value: 'PE14' },
-  { key: '68', value: 'PE15' },
-  { key: '69', value: 'PB10' },
-  { key: '70', value: 'PB11' },
-  { key: '71', value: 'PB12' },
-  { key: '72', value: 'PB13' },
-  { key: '73', value: 'PB14' },
-  { key: '74', value: 'PB4' },
-];
-export const STM32_ANALOG_READ = [
-  { key: '44', value: 'PCO-A0' },
-  { key: '45', value: 'PC1-A1' },
-  { key: '46', value: 'PC2-A2' },
-  { key: '47', value: 'PC3-A3' },
-  { key: '48', value: 'PA0-A4' },
-  { key: '49', value: 'PA1-A5' },
-  { key: '50', value: 'PA2-A6' },
-  { key: '51', value: 'PA3-A7' },
-  { key: '52', value: 'PA4-A8' },
-  { key: '53', value: 'PA5-A9' },
-  { key: '54', value: 'PC4-A10' },
-  { key: '55', value: 'PC5-A11' },
-  { key: '56', value: 'PB0-A12' },
-  { key: '57', value: 'PB1-A13' },
-  { key: '58', value: 'PA6-A14' },
-  { key: '59', value: 'PA7-A15' },
+// STM32
+
+export const APN = {
+  VIETTEL: 'viettel',
+  MOBIPHONE: 'mobiphone',
+  VINAPHONE: 'vinaphone',
+};
+
+export const MODEM = {
+  SIM800: 'sim800',
+  SIM900: 'sim900',
+};
+
+export const STM32_APN = [
+  { key: APN.VIETTEL, value: 'APN_VIETTEL' },
+  { key: APN.MOBIPHONE, value: 'APN_MOBIPHONE' },
+  { key: APN.VINAPHONE, value: 'APN_VINAPHONE' },
 ];
-export const STM32_DIGITAL_WRITE = STM32_DIGITAL_READ;
-export const STM32_ANALOG_WRITE = [
-  { key: '2', value: 'PB9' },
-  { key: '3', value: 'PB8' },
-  { key: '4', value: 'PB7' },
-  { key: '5', value: 'PB6' },
-  { key: '6', value: 'PB5' },
-  { key: '7', value: 'PB3' },
-  { key: '19', value: 'PA15' },
-  { key: '21', value: 'PA11' },
-  { key: '22', value: 'PA10' },
-  { key: '23', value: 'PA9' },
-  { key: '24', value: 'PA8' },
-  { key: '25', value: 'PC8' },
-  { key: '26', value: 'PC8' },
-  { key: '27', value: 'PC7' },
-  { key: '28', value: 'PC6' },
-  { key: '29', value: 'PD15' },
-  { key: '30', value: 'PD14' },
-  { key: '31', value: 'PD13' },
-  { key: '32', value: 'PD12' },
-  { key: '37', value: 'PB15' },
-  { key: '41', value: 'PE5' },
-  { key: '42', value: 'PE6' },
-  { key: '48', value: 'PA0' },
-  { key: '49', value: 'PA1' },
-  { key: '50', value: 'PA2' },
-  { key: '51', value: 'PA3' },
-  { key: '53', value: 'PA5' },
-  { key: '58', value: 'PA6' },
-  { key: '59', value: 'PA7' },
-  { key: '61', value: 'PE9' },
-  { key: '62', value: 'PE9' },
-  { key: '63', value: 'PE10' },
-  { key: '64', value: 'PE11' },
-  { key: '65', value: 'PE12' },
-  { key: '66', value: 'PE13' },
-  { key: '67', value: 'PE14' },
-  { key: '72', value: 'PB13' },
-  { key: '73', value: 'PB14' },
-  { key: '74', value: 'PB4' },
+
+export const STM32_MODEM = [
+  { key: MODEM.SIM800, value: 'TINY_GSM_MODEM_SIM800' },
+  { key: MODEM.SIM900, value: 'TINY_GSM_MODEM_SIM900' },
 ];
 
-export const ESP8266_DIGITAL = [
-  { key: '0', value: 'GPIO 0 - D3' },
-  { key: '1', value: 'GPIO 1 - D10 - UART 0 TX' },
-  { key: '2', value: 'GPIO 2 - D4 - UART 0 TX2' },
-  { key: '3', value: 'GPIO 3 - D9 - UART 0 RX' },
-  { key: '4', value: 'GPIO 4 - D2' },
-  { key: '5', value: 'GPIO 5 - D1' },
-  { key: '12', value: 'GPIO 12 - D6' },
-  { key: '13', value: 'GPIO 13 - D7 - UART 1 RX' },
-  { key: '14', value: 'GPIO 14 - D5' },
-  { key: '15', value: 'GPIO 15 - D8 - UART 1 TX' },
-  { key: '16', value: 'GPIO 16 - D0' },
+// VIRTUAL_PIN
+const STM32_ALPHA = [
+  'A',
+  'B',
+  'C',
+  'D',
+  'E',
+  'F',
+  'G',
+  'H',
+  'I',
+  'J',
+  'K',
+  'Z',
 ];
 
-export const ESP8266_ANALOG_READ = [{ key: '17', value: 'GPIO 17 - A0' }];
+let stm32Index = 0;
 
-export const ESP8266_ANALOG_WRITE = [
-  { key: '0', value: 'GPIO 0 - D3' },
-  { key: '1', value: 'GPIO 1 - D10 - UART 0 TX' },
-  { key: '2', value: 'GPIO 2 - D4 - UART 0 TX2' },
-  { key: '3', value: 'GPIO 3 - D9 - UART 0 RX' },
-  { key: '4', value: 'GPIO 4 - D2' },
-  { key: '5', value: 'GPIO 5 - D1' },
-  { key: '12', value: 'GPIO 12 - D6' },
-  { key: '13', value: 'GPIO 13 - D7 - UART 1 RX' },
-  { key: '14', value: 'GPIO 14 - D5' },
-  { key: '15', value: 'GPIO 15 - D8 - UART 1 TX' },
-];
+export const STM32_PIN = new Array(192).fill().map((e, i) => {
+  const nextPart = (stm32Index + 1) * 15 + stm32Index + 1;
+
+  if (i === nextPart) {
+    stm32Index += 1;
+  }
+
+  const index = i - stm32Index * 15 - stm32Index;
+  const prefix = STM32_ALPHA[stm32Index];
+
+  return { key: i.toString(), value: `P${prefix}${index}` };
+});
 
 export const LANGUAGE = {
   DEFAULT: 'vi',

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

@@ -49,7 +49,7 @@ describe('Test AddNewDevice', () => {
         unit_id: 1,
       },
     };
-    mock.resetHistory();
+    mock.reset();
   });
 
   const getText = (instance, id) => {
@@ -96,6 +96,21 @@ describe('Test AddNewDevice', () => {
     ]);
   });
 
+  it('fetchDetails no stations', async () => {
+    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(200, {
+      id: 1,
+      name: 'Unit name',
+    });
+
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const groupCheckBox = instance.findByType(GroupCheckBox);
+    expect(groupCheckBox.props.data).toEqual([]);
+  });
+
   it('fetchDetails fail', async () => {
     mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(500);
     await act(async () => {
@@ -103,13 +118,7 @@ describe('Test AddNewDevice', () => {
     });
     const instance = tree.root;
     const groupCheckBox = instance.findByType(GroupCheckBox);
-    expect(groupCheckBox.props.data).toEqual([
-      {
-        id: 2,
-        name: 'Station name',
-        title: 'Station name',
-      },
-    ]);
+    expect(groupCheckBox.props.data).toEqual([]);
   });
 
   it('ViewButtonBottom', async () => {

package/src/screens/AddNewDevice/index.js

@@ -43,10 +43,11 @@ const AddNewDevice = memo(({ route }) => {
       });
   }, [navigate, stationId, unit.id, unit.name]);
 
-  const stations = unit.stations.map((item) => ({
-    ...item,
-    title: item.name,
-  }));
+  const stations =
+    unit?.stations?.map((item) => ({
+      ...item,
+      title: item.name,
+    })) || [];
 
   const handleOnSelect = (itemSelect) => {
     if (itemSelect.id !== stationId) {

package/src/screens/AllGateway/DetailConfigActionInternal/__test__/index.test.js

@@ -45,7 +45,7 @@ describe('Test DetailConfigActionInternal', () => {
           id: 1,
           config: { name: 'config1' },
           value_type: 'boolean',
-          pin_number: 0,
+          pin_number: '0',
           pin_mode: 1,
         },
         board: 'stm32',

package/src/screens/AllGateway/DetailConfigActionInternal/index.js

@@ -5,7 +5,7 @@ import { useRoute } from '@react-navigation/native';
 import styles from './styles';
 import DetailConfigAction from '../components/DetailConfigAction';
 import { PIN_MAPPING, PIN_MODE_MAPPING } from '../../../utils/Utils';
-import { INTERNAL_DEVICE } from '../../../configs/IOPinConstants';
+import { INTERNAL_DEVICE, VIRTUAL_PIN } from '../../../configs/IOPinConstants';
 
 const DetailConfigActionInternal = () => {
   const { params = {} } = useRoute();
@@ -17,35 +17,33 @@ const DetailConfigActionInternal = () => {
     isAction,
     isInternal,
     writeConfigPins,
+    virtualConfigPins,
     board,
   } = params;
 
   const readOrWrite = isConfigRead ? 'read' : 'write';
 
-  const formatWritePIN = useMemo(() => {
+  const formatPin = useMemo(() => {
     if (!Object.values(INTERNAL_DEVICE)?.includes(board)) {
       return [];
     }
     const writePin = PIN_MAPPING[board].write;
-    let writePins = writeConfigPins?.map((el) => el.pin_number)?.toString();
-
-    writePins = writePin.boolean
-      .concat(writePin.integer)
-      .filter((el) => writePins?.includes(el.key));
-
-    let writeConfigPinsUsed = [];
-    for (let i = 0; i < writeConfigPins?.length; i++) {
-      let temp = writePins?.find(
-        (el) => el.key === writeConfigPins[i]?.pin_number?.toString()
-      );
-      writeConfigPinsUsed.push({
-        key: writeConfigPins[i]?.id,
-        value: temp?.value,
-      });
-    }
-    return writeConfigPinsUsed?.find((el) => el.key === itemActionConfig?.pin)
-      ?.value;
-  }, [board, itemActionConfig?.pin, writeConfigPins]);
+    const allWritePins = writePin.boolean.concat(writePin.integer);
+    const allWriteVirtualPins = VIRTUAL_PIN;
+
+    const formatWritePIN = writeConfigPins?.map((item) => ({
+      key: item.id,
+      value: allWritePins.find((el) => el?.key === item?.pin_number)?.value,
+    }));
+    const formatVirtualPIN = virtualConfigPins?.map((item) => ({
+      key: item.id,
+      value: allWriteVirtualPins.find((el) => el?.key === item?.pin_number)
+        ?.value,
+    }));
+    return formatWritePIN
+      ?.concat(formatVirtualPIN)
+      ?.find((el) => el?.key === itemActionConfig?.pin)?.value;
+  }, [board, virtualConfigPins, writeConfigPins, itemActionConfig]);
 
   const listPINs = useCallback(() => {
     return PIN_MAPPING[board][readOrWrite][itemActionConfig?.value_type];
@@ -121,7 +119,7 @@ const DetailConfigActionInternal = () => {
         {
           id: 2,
           title: 'pin_number',
-          data: (isInternal ? formatWritePIN : itemActionConfig?.pin) || '0',
+          data: (isInternal ? formatPin : itemActionConfig?.pin) || '0',
         },
         {
           id: 3,
@@ -133,8 +131,8 @@ const DetailConfigActionInternal = () => {
     return [];
   }, [
     formatPIN,
+    formatPin,
     formatPinMode,
-    formatWritePIN,
     isAction,
     isConfigRead,
     isConfigWrite,

package/src/screens/AllGateway/DeviceInternalDetail/__test__/index.test.js

@@ -91,14 +91,14 @@ describe('Test DeviceInternalDetail', () => {
       id: 1,
       config: { name: 'config1', is_write: false, is_read: true },
       value_type: 'boolean',
-      pin_number: 0,
+      pin_number: '0',
       pin_mode: 'input',
     },
     {
       id: 2,
       config: { name: 'config2', is_write: false, is_read: true },
       value_type: 'integer',
-      pin_number: 0,
+      pin_number: '0',
       pin_mode: 'input',
     },
   ];
@@ -107,14 +107,14 @@ describe('Test DeviceInternalDetail', () => {
       id: 1,
       config: { name: 'config1', is_write: true, is_read: false },
       value_type: 'boolean',
-      pin_number: 0,
+      pin_number: '0',
       pin_mode: 'output',
     },
     {
       id: 2,
       config: { name: 'config2', is_write: true, is_read: true },
       value_type: 'integer',
-      pin_number: 0,
+      pin_number: '0',
       pin_mode: 'output',
     },
   ];
@@ -289,6 +289,7 @@ describe('Test DeviceInternalDetail', () => {
       itemActionConfig: 1,
       isInternal: true,
       board: undefined,
+      virtualConfigPins: [],
       writeConfigPins: [
         {
           config: {
@@ -298,7 +299,7 @@ describe('Test DeviceInternalDetail', () => {
           },
           id: 1,
           pin_mode: 'output',
-          pin_number: 0,
+          pin_number: '0',
           value_type: 'boolean',
         },
         {
@@ -309,7 +310,7 @@ describe('Test DeviceInternalDetail', () => {
           },
           id: 2,
           pin_mode: 'output',
-          pin_number: 0,
+          pin_number: '0',
           value_type: 'integer',
         },
       ],
@@ -339,6 +340,7 @@ describe('Test DeviceInternalDetail', () => {
       board: undefined,
       isInternal: true,
       writeConfigPins: [],
+      virtualConfigPins: [],
     });
   });
 

package/src/screens/AllGateway/DeviceInternalDetail/index.js

@@ -147,11 +147,13 @@ const DeviceInternalDetail = () => {
         isInternal,
         board,
         writeConfigPins: detailDeviceInternal?.config_write,
+        virtualConfigPins: detailDeviceInternal?.config_virtual,
       });
     },
     [
       board,
       detailDeviceInternal?.config_write,
+      detailDeviceInternal?.config_virtual,
       device,
       isAction,
       isConfigRead,

package/src/screens/AllGateway/hooks/useGateway.js

@@ -5,6 +5,7 @@ import { ToastBottomHelper } from '../../../utils/Utils';
 import { axiosGet, axiosDelete, axiosPost } from '../../../utils/Apis/axios';
 import API from '../../../configs/API';
 import t from '../../../hooks/Common/useTranslations';
+import { VIRTUAL_TYPE } from '../../../configs/IOPinConstants';
 
 export const useGateway = () => {
   const navigation = useNavigation();
@@ -64,12 +65,39 @@ export const useGateway = () => {
           API.DEV_MODE.ARDUINO.CONFIG_PINS(gatewayId, deviceId)
         );
         if (success) {
-          const config_read = data?.filter((item) => item?.config?.is_read);
-          const config_write = data?.filter((item) => item?.config?.is_write);
+          const config_read = data
+            ?.filter(
+              (item) =>
+                item?.config?.is_read && item?.value_type !== VIRTUAL_TYPE
+            )
+            ?.map((item) => {
+              return {
+                ...item,
+                pin_number: item?.pin_number.toString(),
+              };
+            });
+          const config_write = data
+            ?.filter((item) => item?.config?.is_write)
+            ?.map((item) => {
+              return {
+                ...item,
+                pin_number: item?.pin_number.toString(),
+              };
+            });
+          const config_virtual = data
+            ?.filter((item) => item?.value_type === VIRTUAL_TYPE)
+            ?.map((item) => {
+              return {
+                ...item,
+                pin_number: item?.pin_number.toString(),
+              };
+            });
+
           setDetailDeviceInternal((prev) => ({
             ...prev,
             config_read,
             config_write,
+            config_virtual,
           }));
         }
       } else {

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

@@ -18,32 +18,45 @@ const wrapComponent = (item, sensor) => (
 );
 describe('Test DetailHistoryChart', () => {
   let tree;
+  let item = {
+    id: 10452,
+    order: 0,
+    template: 'history',
+    type: 'history',
+    configuration: {
+      type: 'horizontal_bar_chart',
+      date_format: 'DD.MM',
+      configs: [
+        {
+          id: 9848,
+          title: 'horizontal',
+          color: 'blue',
+        },
+      ],
+    },
+    is_configuration_ready: true,
+  };
+  let sensor = {
+    name: 'Sensor name',
+    is_managed_by_backend: false,
+  };
   it('create DetailHistoryChart', async () => {
     mock
       .onGet(API.VALUE_CONSUME.DISPLAY_HISTORY())
       .reply(200, [{ data: [1, 2, 3] }]);
-    const item = {
-      id: 10452,
-      order: 0,
-      template: 'history',
-      type: 'history',
-      configuration: {
-        type: 'horizontal_bar_chart',
-        date_format: 'DD.MM',
-        configs: [
-          {
-            id: 9848,
-            title: 'horizontal',
-            color: 'blue',
-          },
-        ],
-      },
-      is_configuration_ready: true,
-    };
 
-    const sensor = {
-      name: 'Sensor name',
-      is_managed_by_backend: false,
+    await act(async () => {
+      tree = renderer.create(wrapComponent(item, sensor));
+    });
+    const instance = tree.root;
+    const historyChart = instance.findAllByType(HistoryChart);
+    expect(historyChart).toHaveLength(1);
+  });
+  it('create DetailHistoryChart type line_chart', async () => {
+    mock.onGet(API.DEVICE.DISPLAY_HISTORY()).reply(200, [{ data: [1, 2, 3] }]);
+    item = {
+      ...item,
+      configuration: { ...item?.configuration, type: 'line_chart' },
     };
     await act(async () => {
       tree = renderer.create(wrapComponent(item, sensor));

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

@@ -0,0 +1,34 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+
+import { EmergencyCountdown } from '../components/EmergencyCountdown';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import Text from '../../../commons/Text';
+
+const wrapComponent = (countUpStr, typeEmergency) => (
+  <SCProvider initState={mockSCStore({})}>
+    <EmergencyCountdown countUpStr={countUpStr} typeEmergency={typeEmergency} />
+  </SCProvider>
+);
+describe('Test EmergencyCountdown', () => {
+  let tree;
+  it(' EmergencyCountdown resolved_emergency', async () => {
+    await act(async () => {
+      tree = renderer.create(wrapComponent('stopCount', 'resolved_emergency'));
+    });
+    const instance = tree.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts[1].props.children).toEqual('');
+  });
+  it(' EmergencyCountdown not resolved_emergency', async () => {
+    await act(async () => {
+      tree = renderer.create(
+        wrapComponent('stopCount', 'not_resolve_emergency')
+      );
+    });
+    const instance = tree.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts[1].props.children).toEqual('stopCount');
+  });
+});

package/src/screens/Device/components/SensorDisplayItem.js

@@ -21,6 +21,7 @@ import { useSCContextSelector } from '../../../context';
 import { useRemoteControl } from '../../../hooks/IoT';
 import { useConfigGlobalState } from '../../../iot/states';
 import { useEvaluateValue } from '../hooks/useEvaluateValue';
+import ProgressBar from '../../../commons/Device/ProgressBar';
 
 export const SensorDisplayItem = ({
   item = {},
@@ -127,6 +128,8 @@ export const SensorDisplayItem = ({
           );
         case 'gauge':
           return <Anemometer data={getData(item)} item={item} />;
+        case 'progress_bar':
+          return <ProgressBar data={getData(item)} item={item} />;
         case 'compass':
           return <Compass data={getData(item)} />;
         case 'alert_status':

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

@@ -24,4 +24,26 @@ describe('test EmergencySetting', () => {
 
     expect(dropDownItem.length).toEqual(3);
   });
+  it('test render EmergencySetting onOpen', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent());
+    });
+    const instance = tree.root;
+    const dropDownItem = instance.findAllByType(DropDownItem);
+    expect(dropDownItem[0].props.isOpen).toEqual(false);
+    await act(async () => {
+      dropDownItem[0].props.onOpen();
+    });
+  });
+  it('test render EmergencySetting onSelectItem', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent());
+    });
+    const instance = tree.root;
+    const dropDownItem = instance.findAllByType(DropDownItem);
+    expect(dropDownItem[0].props.isOpen).toEqual(false);
+    await act(async () => {
+      dropDownItem[0].props.onSelectItem();
+    });
+  });
 });

package/src/screens/SyncLGDevice/AddLGDevice.js

@@ -71,10 +71,11 @@ const AddLGDevice = memo(({ route }) => {
     navigate(Routes.Dashboard);
   }, [backend_url, code, navigate, stationId, t]);
 
-  const stations = unit.stations.map((item) => ({
-    ...item,
-    title: item.name,
-  }));
+  const stations =
+    unit?.stations?.map((item) => ({
+      ...item,
+      title: item.name,
+    })) || [];
 
   return (
     <View style={styles.wrap}>

package/src/screens/Unit/Detail.js

@@ -143,16 +143,17 @@ const SubUnitList = ({
   }, [stationId, listStation]);
 
   useEffect(() => {
-    if (unit.stations) {
-      let listMenu = unit.stations.map((item, index) => ({
-        text: item.name,
-        station: item,
-        id: item.id,
-      }));
+    if (unit?.stations) {
+      let listMenu =
+        unit.stations?.map((item, index) => ({
+          text: item.name,
+          station: item,
+          id: item.id,
+        })) || [];
       setListMenuItem(listMenu);
       setListStation(listMenu.concat([{ text: '' }]));
     }
-  }, [unit.stations]);
+  }, [unit?.stations]);
 
   useEffect(() => {
     if (!unit?.stations || !unit.stations[indexStation]) {

package/src/screens/Unit/hook/useFavorites.js

@@ -11,7 +11,7 @@ export const useFavorites = (stations, automatesData) => {
 
   const favoriteDevices = useMemo(() => {
     return []
-      .concat(...stations.map((station) => station.sensors || []))
+      .concat(...stations?.map((station) => station.sensors || []))
       .filter((device) => favoriteDeviceIds.includes(device.id));
   }, [stations, favoriteDeviceIds]);
 

package/src/utils/Converter/__test__/timer.test.js

@@ -2,6 +2,13 @@ import { getDateData, getTitleFromTime, timeDifference } from '../time';
 
 describe('Test timer', () => {
   let result;
+  it('Test timeDifference when elapsed < msPerMinute and second<0', async () => {
+    result = await timeDifference(
+      new Date('2022-08-01T03:24:01'),
+      new Date('2022-08-01T03:24:03')
+    );
+    expect(result).toBe('0 seconds ago');
+  });
   it('Test timeDifference when elapsed < msPerMinute and symbol=false', async () => {
     result = await timeDifference(
       new Date('2022-08-01T03:24:01'),

package/src/utils/Functions/preloadImages.js

@@ -25,7 +25,7 @@ export const preloadImagesFromUnits = async (units, storeKey) => {
       // eslint-disable-next-line promise/prefer-await-to-then
     ).then((results) => {
       const icons = results
-        .map((item) => item?.stations.map((i) => i?.background))
+        .map((item) => item?.stations?.map((i) => i?.background) || [])
         .flat()
         .filter(Boolean);
       FastImage.preload(

package/src/utils/I18n/translations/en.json

@@ -11,6 +11,7 @@
   "add_user_note": "Please note that your personal data including records of your control of the connected devices and services will be shared with other members in the same unit.",
   "add_user_invitation_sent": "Invitation sent",
   "cancel": "Cancel",
+  "max_value": "Max value",
   "text_password": "Password",
   "text_sign_up": "Sign up",
   "text_sign_up_capitalize": "Sign up",

package/src/utils/I18n/translations/vi.json

@@ -717,6 +717,7 @@
   "command_homeassistant_ready": "Home Assistant kết nối thành công",
   "command_homeassistant_lost": "Home Assistant bị mất kết nối. Đang kết nối lại...",
   "confirm": "Xác nhận",
+  "max_value": "Giá trị lớn nhất",
   "pick_a_date": "Chọn ngày",
   "car_validate_warning": "Vui lòng nhập đúng định dạng biển số xe \nVD: %{example}",
   "are_you_sure_this_resolved": "Bạn có chắc tình huống khẩn cấp này đã được xử lý xong? Các thành viên thuộc địa điểm này cũng sẽ nhận được thông báo.",

package/src/utils/Utils.js

@@ -9,18 +9,15 @@ import {
   RASPBERRY_PI_DIGITAL,
   RASPBERRY_PI_ANALOG_WRITE,
   RASPBERRY_PI_ANALOG_READ,
-  STM32_DIGITAL_READ,
-  STM32_ANALOG_READ,
-  STM32_DIGITAL_WRITE,
-  STM32_ANALOG_WRITE,
+  ESP8266_DIGITAL,
+  ESP8266_ANALOG_READ,
+  ESP8266_ANALOG_WRITE,
+  STM32_PIN,
   READ_DIGITAL_PIN_MODE,
   READ_ANALOG_PIN_MODE,
   WRITE_DIGITAL_PIN_MODE,
   WRITE_ANALOG_PIN_MODE,
   LANGUAGE,
-  ESP8266_DIGITAL,
-  ESP8266_ANALOG_READ,
-  ESP8266_ANALOG_WRITE,
 } from '../configs/IOPinConstants';
 
 export const setAxiosDefaultAuthToken = (token) => {
@@ -197,12 +194,22 @@ export const PIN_MAPPING = {
   },
   stm32: {
     read: {
-      boolean: STM32_DIGITAL_READ,
-      integer: STM32_ANALOG_READ,
+      boolean: STM32_PIN,
+      integer: STM32_PIN,
+    },
+    write: {
+      boolean: STM32_PIN,
+      integer: STM32_PIN,
+    },
+  },
+  stm32_wifi: {
+    read: {
+      boolean: STM32_PIN,
+      integer: STM32_PIN,
     },
     write: {
-      boolean: STM32_DIGITAL_WRITE,
-      integer: STM32_ANALOG_WRITE,
+      boolean: STM32_PIN,
+      integer: STM32_PIN,
     },
   },
   raspberry_pi: {