package com.moral.api.service.impl; 
 | 
  
 | 
import com.alibaba.excel.util.StringUtils; 
 | 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; 
 | 
import com.moral.api.entity.SysTest; 
 | 
import com.moral.api.mapper.SysTestMapper; 
 | 
import com.moral.api.service.SysTestService; 
 | 
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; 
 | 
import com.moral.api.utils.AqiUtils; 
 | 
import com.moral.util.DateUtils; 
 | 
import org.apache.commons.collections4.CollectionUtils; 
 | 
import org.springframework.stereotype.Service; 
 | 
  
 | 
import java.math.BigDecimal; 
 | 
import java.util.*; 
 | 
import java.util.stream.Collectors; 
 | 
  
 | 
/** 
 | 
 * <p> 
 | 
 *  服务实现类 
 | 
 * </p> 
 | 
 * 
 | 
 * @author moral 
 | 
 * @since 2023-08-01 
 | 
 */ 
 | 
@Service 
 | 
public class SysTestServiceImpl extends ServiceImpl<SysTestMapper, SysTest> implements SysTestService { 
 | 
  
 | 
    @Override 
 | 
    public List<SysTest> listAll(String startTime,String endTime, String mac) { 
 | 
        QueryWrapper<SysTest> queryWrapper = new QueryWrapper<>(); 
 | 
        if(!StringUtils.isEmpty(startTime)&&!StringUtils.isEmpty(endTime)){ 
 | 
            queryWrapper.between(!StringUtils.isEmpty(startTime)&&!StringUtils.isEmpty(endTime),"time",DateUtils.convertDate(startTime),DateUtils.convertDate(endTime)); 
 | 
        }else if(!StringUtils.isEmpty(startTime)){ 
 | 
            queryWrapper.eq(!StringUtils.isEmpty(startTime),"time", DateUtils.convertDate(startTime)); 
 | 
        } 
 | 
        queryWrapper.eq(!StringUtils.isEmpty(mac),"mac",mac); 
 | 
        queryWrapper.orderByAsc("time","mac"); 
 | 
        List<SysTest> listAll = this.baseMapper.selectList(queryWrapper); 
 | 
        for(SysTest s : listAll){ 
 | 
            Map<String,Object> map = new HashMap<>(); 
 | 
            map.put("PM2_5",s.getPm25()); 
 | 
            map.put("PM10",s.getPm10()); 
 | 
            map.put("CO",s.getCo()); 
 | 
            map.put("SO2",s.getSo2()); 
 | 
            map.put("NO2",s.getNo2()); 
 | 
            map.put("O3",s.getO3()); 
 | 
            Map<String,Object> getAqi = AqiUtils.getAqi(map); 
 | 
            s.setSu(getAqi.get("SU").toString()); 
 | 
            s.setAqi(getAqi.get("AQI").toString()); 
 | 
        } 
 | 
        return listAll; 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<SysTest> listAllAvg(String startTime, String endTime, String mac) { 
 | 
        Date time = DateUtils.convertDate(startTime); 
 | 
        QueryWrapper<SysTest> queryWrapper = new QueryWrapper<>(); 
 | 
        if(!StringUtils.isEmpty(startTime)&&!StringUtils.isEmpty(endTime)){ 
 | 
            queryWrapper.between(!StringUtils.isEmpty(startTime)&&!StringUtils.isEmpty(endTime),"time",DateUtils.convertDate(startTime),DateUtils.convertDate(endTime)); 
 | 
        }else if(!StringUtils.isEmpty(startTime)){ 
 | 
            queryWrapper.eq(!StringUtils.isEmpty(startTime),"time", DateUtils.convertDate(startTime)); 
 | 
        } 
 | 
        queryWrapper.eq(!StringUtils.isEmpty(mac),"mac",mac); 
 | 
        queryWrapper.orderByAsc("time","mac"); 
 | 
        List<SysTest> listAll = this.baseMapper.selectList(queryWrapper); 
 | 
        return resultList(listAll,time); 
 | 
    } 
 | 
  
 | 
    private List<SysTest> resultList(List<SysTest> listAll,Date time){ 
 | 
        List<SysTest> list = new ArrayList<>(); 
 | 
        if(CollectionUtils.isEmpty(listAll)) { 
 | 
            return list; 
 | 
        } 
 | 
        String mon = DateUtils.dateToDateString(time,DateUtils.yyyy_MM_EN); 
 | 
        List<String> nameList = new ArrayList<>(); 
 | 
        Map<String, ArrayList<Double>> map = new HashMap<>(); 
 | 
        for(SysTest s : listAll) { 
 | 
            if(nameList.size()<4 && !nameList.contains(s.getName())){ 
 | 
                nameList.add(s.getName()); 
 | 
                SysTest sysTest = new SysTest(); 
 | 
                sysTest.setName(s.getName()); 
 | 
                sysTest.setMon(mon); 
 | 
                list.add(sysTest); 
 | 
            } 
 | 
            String pm10 = s.getName()+"_pm10"; 
 | 
            ArrayList<Double> pm10D = Objects.nonNull(map.get(pm10))?map.get(pm10):new ArrayList<>(); 
 | 
            pm10D.add(Double.parseDouble(s.getPm10())); 
 | 
            map.put(pm10,pm10D); 
 | 
  
 | 
            String pm25 = s.getName()+"_pm25"; 
 | 
            ArrayList<Double> pm25D = Objects.nonNull(map.get(pm25))?map.get(pm25):new ArrayList<>(); 
 | 
            pm25D.add(Double.parseDouble(s.getPm25())); 
 | 
            map.put(pm25,pm25D); 
 | 
  
 | 
            String o2 = s.getName()+"_o2"; 
 | 
            ArrayList<Double> o2D = Objects.nonNull(map.get(o2))?map.get(o2):new ArrayList<>(); 
 | 
            o2D.add(Double.parseDouble(s.getSo2())); 
 | 
            map.put(o2,o2D); 
 | 
  
 | 
            String no = s.getName()+"_no"; 
 | 
            ArrayList<Double> noD = Objects.nonNull(map.get(no))?map.get(no):new ArrayList<>(); 
 | 
            noD.add(Double.parseDouble(s.getNo2())); 
 | 
            map.put(no,noD); 
 | 
  
 | 
            String co = s.getName()+"_co"; 
 | 
            ArrayList<Double> coD = Objects.nonNull(map.get(co))?map.get(co):new ArrayList<>(); 
 | 
            coD.add(Double.parseDouble(s.getCo())); 
 | 
            map.put(co,coD); 
 | 
  
 | 
            String o3 = s.getName()+"_o3"; 
 | 
            ArrayList<Double> o3D = Objects.nonNull(map.get(o3))?map.get(o3):new ArrayList<>(); 
 | 
            o3D.add(Double.parseDouble(s.getO3())); 
 | 
            map.put(o3,o3D); 
 | 
  
 | 
            String tv = s.getName()+"_tv"; 
 | 
            ArrayList<Double> tvD = Objects.nonNull(map.get(tv))?map.get(tv):new ArrayList<>(); 
 | 
            tvD.add(Double.parseDouble(s.getVoc())); 
 | 
            map.put(tv,tvD); 
 | 
        } 
 | 
        for(SysTest s : list){ 
 | 
            String name = s.getName(); 
 | 
            if(map.containsKey(name+"_pm10")){ 
 | 
                Double ListAvg = map.get(name+"_pm10").stream().collect(Collectors.averagingDouble(Double::doubleValue)); 
 | 
                double rsAvg = new BigDecimal(ListAvg).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue(); 
 | 
                s.setPm10(String.valueOf(rsAvg)); 
 | 
            } 
 | 
            if(map.containsKey(name+"_pm25")){ 
 | 
                Double ListAvg = map.get(name+"_pm25").stream().collect(Collectors.averagingDouble(Double::doubleValue)); 
 | 
                double rsAvg = new BigDecimal(ListAvg).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue(); 
 | 
                s.setPm25(String.valueOf(rsAvg)); 
 | 
            } 
 | 
            if(map.containsKey(name+"_o2")){ 
 | 
                Double ListAvg = map.get(name+"_o2").stream().collect(Collectors.averagingDouble(Double::doubleValue)); 
 | 
                double rsAvg = new BigDecimal(ListAvg).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue(); 
 | 
                s.setSo2(String.valueOf(rsAvg)); 
 | 
            } 
 | 
            if(map.containsKey(name+"_no")){ 
 | 
                Double ListAvg = map.get(name+"_no").stream().collect(Collectors.averagingDouble(Double::doubleValue)); 
 | 
                double rsAvg = new BigDecimal(ListAvg).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue(); 
 | 
                s.setNo2(String.valueOf(rsAvg)); 
 | 
            } 
 | 
            if(map.containsKey(name+"_tv")){ 
 | 
                Double ListAvg = map.get(name+"_tv").stream().collect(Collectors.averagingDouble(Double::doubleValue)); 
 | 
                double rsAvg = new BigDecimal(ListAvg).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue(); 
 | 
                s.setVoc(String.valueOf(rsAvg)); 
 | 
            } 
 | 
            if(map.containsKey(name+"_co")){ 
 | 
                double rsAvg = percentile(map.get(name+"_co"),95d); 
 | 
                s.setCo(String.valueOf(rsAvg)); 
 | 
            } 
 | 
  
 | 
            if(map.containsKey(name+"_o3")){ 
 | 
                double rsAvg = percentile(map.get(name+"_o3"),90d); 
 | 
                s.setO3(String.valueOf(rsAvg)); 
 | 
            } 
 | 
        } 
 | 
        return list; 
 | 
    } 
 | 
  
 | 
    private Double percentile(List<Double> date,double num){ 
 | 
        Collections.sort(date); 
 | 
        double position = (num / 100) * (date.size() - 1); 
 | 
        int index = (int) position; 
 | 
        // 获取小数部分的位置索引 
 | 
        double fraction = position - index; 
 | 
  
 | 
        // 获取百分位值 
 | 
        double percentileValue = date.get(index) + fraction * (date.get(index + 1) - date.get(index)); 
 | 
        return new BigDecimal(percentileValue).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue(); 
 | 
    } 
 | 
} 
 |