chore:过滤无人机无效数据

jinpengyong

2023-09-15 f52e59d2cb5391b6cb46d2d75e4ffa586aa61df1

 screen-manage/src/main/java/com/moral/api/util/AdjustDataUtils.java

@@ -2,21 +2,26 @@

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.googlecode.aviator.AviatorEvaluator;
import com.googlecode.aviator.Expression;
import com.moral.api.entity.DeviceAdjustValue;
import com.moral.api.service.DeviceService;
import com.moral.constant.RedisConstants;
import com.moral.api.mapper.HistoryHourlyMapper;
import com.moral.constant.Constants;
import com.moral.util.DateUtils;

@Slf4j
@@ -24,74 +29,207 @@
public class AdjustDataUtils {

    @Autowired
    private DeviceService deviceService;

    @Autowired
    private RedisTemplate redisTemplate;

    public Map<String, Object> adjust(Map<String, Object> deviceData) {
    private HistoryHourlyMapper historyHourlyMapper;
    /**
     * @param deviceData    设备数据
     * @param adjustFormula 校准公式，包含所有因子校准公式，key为因子code,value为校准公式（各个时间段的公式List）
     * @param aqiMap        与设备绑定的国控站点aqi数据
     * @return Map<String, Object> 校准后数据
     */
    public Map<String, Object> adjust(Map<String, Object> deviceData, Map<String, Object> adjustFormula, Map<String, Object> aqiMap,String code) {
        try {
            Object dataTime = deviceData.get("DataTime");
            String mac = deviceData.get("mac").toString();
            //清除毫秒，四舍五入
            long time = Math.round(new Double((String) dataTime) / 1000) * 1000L;
            long finalTime = DateUtils.dataToTimeStampTime(new Date(time), DateUtils.HH_mm_ss_EN).getTime();
            //设备信息
            Map<String, Object> deviceInfo = deviceService.getDeviceByMac(mac);
            Map<String, Object> monitorPoint = (Map<String, Object>) deviceInfo.get("monitorPoint");
            Object areaCode = monitorPoint.get("areaCode");
            Object cityCode = monitorPoint.get("cityCode");
            Date time = DateUtils.getDate((String) deviceData.remove("DataTime"), DateUtils.yyyyMMddHHmmss_EN);
            String mac = deviceData.remove("mac").toString();
            long finalTime = DateUtils.dataToTimeStampTime(time, DateUtils.HH_mm_ss_EN).getTime();

            //先校准烟气流速，再用流速校准烟气流量
            if (deviceData.get(Constants.SENSOR_CODE_CURRENT_SPEED) != null) {
                deviceData = adjustFlueSpeedAndFlow(deviceData, adjustFormula);
            }

            //硬件没有的传感器，但是需要显示的
            Set<String> dateKey = deviceData.keySet();
            for (String adjustKey : adjustFormula.keySet()) {
                if (!dateKey.contains(adjustKey)) {
                    deviceData.put(adjustKey, "0");
                }
            }

            for (String key : deviceData.keySet()) {
                if (!key.equals("mac") && !key.equals("time") && !key.equals("DataTime") && !key.equals("ver") && !key.contains("Flag")) {
                if (!key.contains("Flag")) {
                    //测量值
                    Object measuredValue = deviceData.get(key);
                    List<DeviceAdjustValue> adjustValues = (List<DeviceAdjustValue>) redisTemplate.opsForHash().get(RedisConstants.ADJUST + "_" + mac, key);
                    if (ObjectUtils.isEmpty(adjustValues)) {
                    //单个因子校准公式
                    List<DeviceAdjustValue> sensorFormulas = (List<DeviceAdjustValue>) adjustFormula.get(key);
                    if (ObjectUtils.isEmpty(sensorFormulas)) {
                        deviceData.put(key, measuredValue);
                        continue;
                    }

                    //根据时间段筛选校准公式
                    DeviceAdjustValue deviceAdjustValue = adjustValues.stream()
                    DeviceAdjustValue deviceAdjustValue = new DeviceAdjustValue();
                    Optional<DeviceAdjustValue> optional = sensorFormulas.stream()
                            .filter(o -> o.getStartTime().getTime() <= finalTime && o.getEndTime().getTime() > finalTime)
                            .findFirst().get();
                    String adjustValue = deviceAdjustValue.getValue();
                    if (ObjectUtils.isEmpty(adjustValue)) {
                            .findFirst();
                    if (optional.isPresent()) {
                        deviceAdjustValue = optional.get();
                    }
                    String formula = deviceAdjustValue.getValue();
                    if (StringUtils.isEmpty(formula)) {
                        deviceData.put(key, measuredValue);
                        continue;
                    }

                    Expression expression = AviatorEvaluator.compile(adjustValue);
                    Expression expression = AviatorEvaluator.compile(formula);
                    Map<String, Object> env = new HashMap<>();
                    if (adjustValue.contains("aqi")) {
                        Object aqiValue = redisTemplate.opsForHash().get("aqi_" + areaCode, key);
                        if (ObjectUtils.isEmpty(aqiValue)) {
                            aqiValue = redisTemplate.opsForHash().get("aqi_" + cityCode, key);
                    if (formula.contains("aqi")) {
                        Object aqiValue = null;
                        if (aqiMap != null) {
                            aqiValue = aqiMap.get(key);
                        }
                        env.put("aqi", ObjectUtils.isEmpty(aqiValue) ? 0F : Float.parseFloat((String) aqiValue));
                        env.put("aqi", ObjectUtils.isEmpty(aqiValue) ? 0F : new BigDecimal(String.valueOf(aqiValue)).floatValue());
                    }
                    if (adjustValue.contains("vocs")) {
                        Object vocsValue = ObjectUtils.isEmpty(deviceData.get("a99054")) ? 0F : deviceData.get("a99054");
                    if (formula.contains("vocs")) {
                        Object vocsValue = ObjectUtils.isEmpty(deviceData.get(Constants.SENSOR_CODE_VOCS)) ? 0F : deviceData.get(Constants.SENSOR_CODE_VOCS);
                        env.put("vocs", vocsValue);
                    }
                    if (adjustValue.contains("cel")) {
                        env.put("cel", Float.parseFloat((String) measuredValue));
                    if (formula.contains("ce1")) {
                        //env.put("cel", Float.parseFloat((String) measuredValue));
                        env.put("ce1", new BigDecimal(String.valueOf(measuredValue)).floatValue());
                    }else if(formula.contains("cel")){
                        env.put("cel", new BigDecimal(String.valueOf(measuredValue)).floatValue());
                    }

                    //校准
                    measuredValue = expression.execute(env);
                    //温度处理
                    if (Float.parseFloat(measuredValue.toString()) < 0 && !"a01001".equals(measuredValue)) {
                    if (!Constants.SENSOR_CODE_TEMP.equals(measuredValue) && Float.parseFloat(measuredValue.toString()) < 0) {
                        measuredValue = 0F;
                    }
                    deviceData.put(key, Double.parseDouble(String.format("%.3f", measuredValue)));

                    deviceData.put(key, Double.parseDouble(String.format("%.4f", measuredValue)));
                }
            }
          if (code.equals("2")){
              HashMap<String, Object> result = new HashMap<>();
              String time1 = deviceData.get("time").toString();
              long l = Long.parseLong(time1);

              SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:00:00");
              String format1 = simpleDateFormat.format(l);
              Date date = DateUtils.getDate(format1, DateUtils.yyyy_MM_dd_HH_mm_ss_EN);

              String yearAndMonth = DateUtils.dateToDateString(DateUtils.addHours(date, -2), DateUtils.yyyyMM_EN);
              String format = simpleDateFormat.format(DateUtils.addHours(date, -2));
              result.put("timeUnits",yearAndMonth);
              result.put("mac",mac);
              result.put("time",format);
              Map<String, Object> map = historyHourlyMapper.selectHistoryHourly(result);
              if (ObjectUtils.isEmpty(map)){
                  return deviceData;
              }
              JSONObject jsonObject = JSONObject.parseObject(map.get("value").toString());
              if (ObjectUtils.isEmpty(aqiMap)){
                  deviceData.put("a21005",Double.parseDouble(jsonObject.get("a21005").toString()));
                  deviceData.put("a21026",Double.parseDouble(jsonObject.get("a21026").toString()));
                  deviceData.put("a21004",Double.parseDouble(jsonObject.get("a21004").toString()));
                  deviceData.put("a34002",Double.parseDouble(jsonObject.get("a34002").toString()));
                  deviceData.put("a34004",Double.parseDouble(jsonObject.get("a34004").toString()));
                  deviceData.put("a05024",Double.parseDouble(jsonObject.get("a05024").toString()));
              }else {
                  if (ObjectUtils.isEmpty(aqiMap.get("a21005"))){

                      String a21005 = jsonObject.get("a21005").toString();
                      deviceData.put("a21005",Double.parseDouble(a21005));
                  }
                  if (ObjectUtils.isEmpty(aqiMap.get("a21026"))){
//                  JSONObject jsonObject = JSONObject.parseObject(map.get("value").toString());
                      String a21026 = jsonObject.get("a21026").toString();
                      deviceData.put("a21026",Double.parseDouble(a21026));
                  }
                  if (ObjectUtils.isEmpty(aqiMap.get("a21004"))){
//                  JSONObject jsonObject = JSONObject.parseObject(map.get("value").toString());
                      String a21004 = jsonObject.get("a21004").toString();
                      deviceData.put("a21004",Double.parseDouble(a21004));
                  }
                  if (ObjectUtils.isEmpty(aqiMap.get("a34002"))){
//                  JSONObject jsonObject = JSONObject.parseObject(map.get("value").toString());
                      String a34002 = jsonObject.get("a34002").toString();
                      deviceData.put("a34002",Double.parseDouble(a34002));
                  }
                  if (ObjectUtils.isEmpty(aqiMap.get("a34004"))){
//                  JSONObject jsonObject = JSONObject.parseObject(map.get("value").toString());
                      String a34004 = jsonObject.get("a34004").toString();
                      deviceData.put("a34004",Double.parseDouble(a34004));
                  }
                  if (ObjectUtils.isEmpty(aqiMap.get("a05024"))){
//                  JSONObject jsonObject = JSONObject.parseObject(map.get("value").toString());
                      String a05024 = jsonObject.get("a05024").toString();
                      deviceData.put("a05024",Double.parseDouble(a05024));
                  }
              }
          }

        } catch (Exception e) {
            log.error("param[0] deviceData:" + JSON.toJSONString(deviceData));
            log.error(e.getMessage());
        }
        return deviceData;
    }

    /**
     * 烟道流速，烟道流量校准
     *
     * @param deviceData    数据，其中包含各传感器值，和数据时间（用于不同时间段不同校准公式校准）
     * @param adjustFormula 该数据所属设备所有因子的校准公式，key为因子code
     */
    public Map<String, Object> adjustFlueSpeedAndFlow(Map<String, Object> deviceData, Map<String, Object> adjustFormula) {
        Date time = DateUtils.getDate((String) deviceData.remove("DataTime"), DateUtils.yyyyMMddHHmmss_EN);
        long finalTime = DateUtils.dataToTimeStampTime(time, DateUtils.HH_mm_ss_EN).getTime();
        //流速测量值
        Object measuredValue = deviceData.get(Constants.SENSOR_CODE_CURRENT_SPEED);


        //流速校准
        List<DeviceAdjustValue> speedFormulas = (List<DeviceAdjustValue>) adjustFormula.get(Constants.SENSOR_CODE_CURRENT_SPEED);
        if (!ObjectUtils.isEmpty(speedFormulas)) {
            //根据时间段筛选校准公式
            DeviceAdjustValue deviceAdjustValue = new DeviceAdjustValue();
            Optional<DeviceAdjustValue> optional = speedFormulas.stream()
                    .filter(o -> o.getStartTime().getTime() <= finalTime && o.getEndTime().getTime() > finalTime)
                    .findFirst();
            if (optional.isPresent()) {
                deviceAdjustValue = optional.get();
            }

            String formula = deviceAdjustValue.getValue();
            if (!StringUtils.isEmpty(formula)) {

                Expression expression = AviatorEvaluator.compile(formula);
                Map<String, Object> env = new HashMap<>();
                env.put("cel", Float.parseFloat((String) measuredValue));
                //校准
                measuredValue = expression.execute(env);
                deviceData.put(Constants.SENSOR_CODE_CURRENT_SPEED, Double.parseDouble(String.format("%.4f", measuredValue)));
            }


            //流量校准
            List<DeviceAdjustValue> flowFormulas = (List<DeviceAdjustValue>) adjustFormula.get(Constants.SENSOR_CODE_CURRENT_FLOW);
            //根据时间段筛选校准公式
            optional = flowFormulas.stream()
                    .filter(o -> o.getStartTime().getTime() <= finalTime && o.getEndTime().getTime() > finalTime)
                    .findFirst();
            if (optional.isPresent()) {
                deviceAdjustValue = optional.get();
            }

            formula = deviceAdjustValue.getValue();
            if (!StringUtils.isEmpty(formula)) {
                Expression expression = AviatorEvaluator.compile(formula);
                Map<String, Object> env = new HashMap<>();
                String currentSpeed = deviceData.get(Constants.SENSOR_CODE_CURRENT_SPEED).toString();
                env.put("currentSpeed", Float.parseFloat(currentSpeed));
                deviceData.put(Constants.SENSOR_CODE_CURRENT_FLOW, Double.parseDouble(String.format("%.4f", expression.execute(env))));
            }
        }
        return deviceData;
    }
}