@eohjsc/react-native-smart-city 0.7.24 → 0.7.25

package/src/iot/mqtt.js

@@ -1,8 +1,11 @@
 import moment from 'moment';
+import { getObject, storeObject } from '../utils/Storage';
 import { updateGlobalValue } from './Monitor';
 import { Buffer } from 'buffer';
 
-const int_all = (bytes_str, config_data = null) => {
+const struct = require('python-struct');
+
+const int_all = (bytes_str) => {
   let val;
   val = Number.parseInt(bytes_str, 16);
 
@@ -13,44 +16,75 @@ const int_all = (bytes_str, config_data = null) => {
   return val;
 };
 
-const int_first4 = (bytes_str, config_data = null) => {
-  return Number.parseInt(bytes_str.slice(0, 4), 16);
+const int_first4 = (bytes_str) => {
+  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 int_last4 = (bytes_str) => {
+  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);
-
-  // eslint-disable-next-line no-bitwise
-  if (value & (1 << (bits - 1))) {
-    // eslint-disable-next-line no-bitwise
-    value -= 1 << bits;
-  }
-
-  return value;
-};
-
-const float_convert = (bytes_str) => {
-  const struct = require('python-struct');
+const value_unpacked = (format, bytes_str) => {
   let value = null;
   try {
-    value = struct.unpack('>f', Buffer.from(bytes_str, 'hex'))[0];
+    value = struct.unpack(format, 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 uint_32_abcd = (bytes_str) => {
+  return value_unpacked('>I', bytes_str?.slice(0, 8));
+};
+
+const uint_32_dcba = (bytes_str) => {
+  return value_unpacked('<I', bytes_str?.slice(0, 8));
+};
+
+const uint_32_badc = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('<I', swapped);
+};
+
+const uint_32_cdab = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('>I', swapped);
+};
+
+const int_32_abcd = (bytes_str) => {
+  return value_unpacked('>i', bytes_str?.slice(0, 8));
+};
+
+const int_32_dcba = (bytes_str) => {
+  return value_unpacked('<i', bytes_str?.slice(0, 8));
 };
 
-const float_abcd = (bytes_str, config_data = null) => {
-  return float_convert(bytes_str);
+const int_32_badc = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('<i', swapped);
+};
+
+const int_32_cdab = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('>i', swapped);
+};
+
+const float_abcd = (bytes_str) => {
+  return value_unpacked('>f', bytes_str?.slice(0, 8));
+};
+
+const float_dcba = (bytes_str) => {
+  return value_unpacked('<f', bytes_str?.slice(0, 8));
+};
+
+const float_badc = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('<f', swapped);
+};
+
+const float_cdab = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('>f', swapped);
 };
 
 const range_value_converting = (
@@ -84,12 +118,21 @@ const convert_ai = (bytes_str, config_data = null) => {
 
 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,
+  float_dcba: float_dcba,
+  float_badc: float_badc,
+  float_cdab: float_cdab,
+  uint_32_abcd: uint_32_abcd,
+  uint_32_dcba: uint_32_dcba,
+  uint_32_badc: uint_32_badc,
+  uint_32_cdab: uint_32_cdab,
+  int_32_abcd: int_32_abcd,
+  int_32_dcba: int_32_dcba,
+  int_32_badc: int_32_badc,
+  int_32_cdab: int_32_cdab,
   convert_ai: convert_ai,
+  int_first4: int_first4,
+  int_last4: int_last4,
 };
 
 const extract_config_value = (register, value_bytes) => {
@@ -135,19 +178,56 @@ const get_sensor_data = (sensor, data) => {
 };
 
 const get_scale_value = (value, config) => {
-  if (!value || typeof value === 'string') {
+  if (!value) {
     return value;
   }
-  const { decimal_behind, scale } = config;
-  let scaledValue = value * (scale || 1);
+  const scale = config?.scale || 1;
+  return value * scale;
+};
+
+const get_decimal_value = (value, config) => {
+  if (config?.decimal_behind || config?.decimal_behind === 0) {
+    value = value.toFixed(config.decimal_behind);
+  }
+  return value;
+};
 
-  if (decimal_behind || decimal_behind === 0) {
-    scaledValue = scaledValue.toFixed(decimal_behind);
+const get_offset_sample_value = async (value, config) => {
+  const offset = parseFloat(config?.ai_trans_offset_value) || 0;
+  const sample = config?.ai_trans_average_sample || 1;
+  value += offset;
+  if (sample <= 1) {
+    return Number(get_decimal_value(value, config));
   }
-  return Number(scaledValue);
+
+  const cacheKey = `last_values_${config?.id}`;
+  let values = await getObject(cacheKey, []);
+
+  values = [value, ...values];
+  values = values.slice(0, sample);
+
+  value = values.reduce((a, b) => a + b) / values.length;
+  value = Number(get_decimal_value(value, config));
+
+  values[0] = value;
+  await storeObject(cacheKey, values);
+  return value;
 };
 
-const updateGlobalValueMqtt = (config, value) => {
+const check_filter = (value, config) => {
+  if (!config?.active_filter) {
+    return false;
+  }
+  if (config?.active_filter === 'zero') {
+    return !value;
+  }
+
+  const low = config?.low_level || 0;
+  const high = config?.high_level || 0;
+  return value < low || value > high;
+};
+
+const updateGlobalValueMqtt = async (config, value) => {
   if (!config?.id) {
     return;
   }
@@ -155,13 +235,20 @@ const updateGlobalValueMqtt = (config, value) => {
     return;
   }
 
-  value = get_scale_value(value, config);
-  updateGlobalValue(config.id, { value: value });
-};
+  const last_updated = moment().format('YYYY-MM-DDTHH:mm:ss.SSSSSS');
+  if (typeof value === 'string') {
+    updateGlobalValue(config.id, { value, last_updated });
+    return;
+  }
 
-const arduinoUpdateGlobalValueMqtt = (config, value, last_updated) => {
   value = get_scale_value(value, config);
-  updateGlobalValue(config.id, { value: value, last_updated: last_updated });
+  value = await get_offset_sample_value(value, config);
+
+  if (check_filter(value, config)) {
+    return;
+  }
+
+  updateGlobalValue(config.id, { value, last_updated });
 };
 
 export const handleModbusData = (chip, configById, data) => {
@@ -188,11 +275,7 @@ export const handleModbusData = (chip, configById, data) => {
 };
 
 export const handleChipData = (configById, configId, data) => {
-  arduinoUpdateGlobalValueMqtt(
-    configById[configId],
-    data?.v,
-    moment().format('YYYY-MM-DDTHH:mm:ss.SSSSSS')
-  );
+  updateGlobalValueMqtt(configById[configId], data?.v);
 };
 
 export const handleZigbeeData = (chip, configById, ieee_address, data) => {
@@ -217,6 +300,26 @@ export const handleZigbeeData = (chip, configById, ieee_address, data) => {
   }
 };
 
+export const handleThirdPartyData = (chip, configById, device_uid, data) => {
+  const third_party_gateway = chip?.third_party_gateway;
+  if (!third_party_gateway) {
+    return;
+  }
+
+  const third_party_device_by_uid = {};
+
+  third_party_gateway?.sensors?.forEach((device) => {
+    third_party_device_by_uid[device.device_uid] = device;
+  });
+
+  const device = third_party_device_by_uid[device_uid];
+  device?.configs?.forEach((config_map) => {
+    const value = data[config_map?.key];
+    const configId = config_map?.config;
+    updateGlobalValueMqtt(configById[configId], value);
+  });
+};
+
 export const handleMqttMessage = (
   topic,
   payloadData,
@@ -246,4 +349,17 @@ export const handleMqttMessage = (
     // payload: {zigbee_data: 'aaa', 'data': {state: 1, state_0: 0}}
     handleZigbeeData(chip, configById, matchZigbeeConfigValue[1], payloadData);
   }
+
+  const matchThirdPartyConfigValue = topic.match(/third_party\/(.+)\/data/);
+  if (matchThirdPartyConfigValue) {
+    // ThirdParty
+    // topic: eoh/chip/code-123/third_party/UID-123/data
+    // payload: {state: 1, temperature: 27.6}
+    handleThirdPartyData(
+      chip,
+      configById,
+      matchThirdPartyConfigValue[1],
+      payloadData
+    );
+  }
 };

package/src/navigations/UnitStack.js

@@ -124,6 +124,19 @@ export const UnitStack = memo((props) => {
   }, [isBluetoothEnabled, bluetoothPermGranted, onDeviceFound]);
 
   useEffect(() => {
+    const fetchDashboardDevices = async () => {
+      const id = unitId || unitData?.id;
+      if (!id) {
+        return;
+      }
+      await fetchWithCache(
+        API.UNIT.DASHBOARD_DEVICES(id),
+        {},
+        ({ success, data }) => {
+          success && setAction(Action.SET_DASHBOARD_DEVICES, data);
+        }
+      );
+    };
     const fetchFavoriteDevices = async () => {
       const id = unitId || unitData?.id;
       if (!id) {
@@ -137,6 +150,7 @@ export const UnitStack = memo((props) => {
         }
       );
     };
+    fetchDashboardDevices();
     fetchFavoriteDevices();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);

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

@@ -661,6 +661,47 @@ describe('test DeviceDetail', () => {
     expect(menu.props.isVisible).toBe(true);
   });
 
+  it('Add device to Dashboard', async () => {
+    const sensor = route?.params?.sensorData;
+    mock.onPost(API.DEVICE.ADD_TO_DASHBOARD(sensor.id)).reply(200);
+
+    await act(async () => {
+      tree = await create(wrapComponent(store, account, route));
+    });
+    const instance = tree.root;
+    const buttonPin = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+        AccessibilityLabel.HEADER_DEVICE_BUTTON_PIN
+    );
+    await act(async () => {
+      await buttonPin.props.onPress();
+    });
+    const urls = mock.history.post.map(({ url }) => url);
+    expect(urls).toContain(API.DEVICE.ADD_TO_DASHBOARD(sensor.id));
+  });
+
+  it('Remove device from Dashboard', async () => {
+    const sensor = route?.params?.sensorData;
+    store.unit.dashboardDeviceIds = [sensor.id];
+    mock.onPost(API.DEVICE.REMOVE_FROM_DASHBOARD(sensor.id)).reply(200);
+
+    await act(async () => {
+      tree = await create(wrapComponent(store, account, route));
+    });
+    const instance = tree.root;
+    const buttonPin = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+        AccessibilityLabel.HEADER_DEVICE_BUTTON_PIN
+    );
+    await act(async () => {
+      await buttonPin.props.onPress();
+    });
+    const urls = mock.history.post.map(({ url }) => url);
+    expect(urls).toContain(API.DEVICE.REMOVE_FROM_DASHBOARD(sensor.id));
+  });
+
   it('Add device to Favourites', async () => {
     const sensor = route?.params?.sensorData;
     sensor.is_favourite = false;
@@ -733,7 +774,7 @@ describe('test DeviceDetail', () => {
     });
     const instance = tree.root;
     const menu = instance.findByType(MenuActionMore);
-    const gotoActivityLog = menu.props.listMenuItem[1];
+    const gotoActivityLog = menu.props.listMenuItem[2];
 
     await act(async () => {
       await menu.props.onItemClick(gotoActivityLog);