From 28923b3d67c58b032bc4ff128aa1d5e62d73dba1 Mon Sep 17 00:00:00 2001
From: jinpengyong <jpy123456>
Date: Fri, 02 Feb 2024 10:07:58 +0800
Subject: [PATCH] fix:提交实时在线率接口

---
 screen-api/src/main/java/com/moral/api/service/impl/CityAqiDailyServiceImpl.java |  803 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 files changed, 763 insertions(+), 40 deletions(-)

diff --git a/screen-api/src/main/java/com/moral/api/service/impl/CityAqiDailyServiceImpl.java b/screen-api/src/main/java/com/moral/api/service/impl/CityAqiDailyServiceImpl.java
index d4c1c90..e17da0d 100644
--- a/screen-api/src/main/java/com/moral/api/service/impl/CityAqiDailyServiceImpl.java
+++ b/screen-api/src/main/java/com/moral/api/service/impl/CityAqiDailyServiceImpl.java
@@ -1,18 +1,36 @@
 package com.moral.api.service.impl;
 
 import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.moral.api.config.properties.BulletinProperties;
+import com.moral.api.config.properties.SpecialCitiesProperties;
 import com.moral.api.entity.CityAqiDaily;
+import com.moral.api.entity.CityAqiMonthly;
+import com.moral.api.entity.CityAqiYearly;
+import com.moral.api.entity.SysArea;
 import com.moral.api.mapper.CityAqiDailyMapper;
-import com.moral.api.pojo.dto.dataDisplay.PollutionLevelProportionDTO;
+import com.moral.api.mapper.CityAqiMonthlyMapper;
+import com.moral.api.pojo.dto.cityAQI.CityPollutionLevel;
+import com.moral.api.pojo.dto.cityAQI.ConcentrationAndPercent;
+import com.moral.api.pojo.dto.cityAQI.MonthlyPollutionLevel;
+import com.moral.api.pojo.dto.cityAQI.PollutionDaysAndProportion;
+import com.moral.api.pojo.form.aqi.*;
+import com.moral.api.pojo.vo.cityAQI.CityAreaRangeVO;
+import com.moral.api.pojo.vo.cityAQI.PieChartOfPollutionLevelVO;
 import com.moral.api.service.CityAqiDailyService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.moral.util.AQIUtils;
-import com.moral.util.DateUtils;
-import com.moral.util.MathUtils;
+import com.moral.api.service.CityAqiMonthlyService;
+import com.moral.api.service.CityAqiYearlyService;
+import com.moral.api.service.SysAreaService;
+import com.moral.constant.Constants;
+import com.moral.util.*;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.util.ObjectUtils;
 
+import java.text.DecimalFormat;
+import java.text.SimpleDateFormat;
 import java.util.*;
 
 /**
@@ -28,67 +46,772 @@
 
     @Autowired
     CityAqiDailyMapper cityAqiDailyMapper;
+    @Autowired
+    SysAreaService sysAreaService;
+    @Autowired
+    SpecialCitiesProperties specialCitiesProperties;
+    @Autowired
+    BulletinProperties bulletinProperties;
+    @Autowired
+    CityAqiMonthlyService cityAqiMonthlyService;
+    @Autowired
+    CityAqiYearlyService cityAqiYearlyService;
 
     @Override
-    public PollutionLevelProportionDTO queryPollutionLevelsForThisYear(Integer regionCode) {
-        //������������  ��������������� ���
-        Date startDate = DateUtils.getFirstDayOfCurrYear();
-        Date endDate = DateUtils.getYesterdayDate();
+    public List<CityAqiDaily> getCityAqiDailyByRegionCodeAndTime(Integer regionCode, Date startDate, Date endDate) {
+        QueryWrapper<CityAqiDaily> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("city_code", regionCode);
+        queryWrapper.between("time", startDate, endDate);
+        return cityAqiDailyMapper.selectList(queryWrapper);
+    }
+
+    @Override
+    public PieChartOfPollutionLevelVO queryPieChartOfPollutionLevels(ChartOfPollutionLevelForm form) {
+        //������
+        Integer regionCode = form.getRegionCode();
+        Date startDate = form.getStartDate();
+        Date endDate = form.getEndDate();
         //������������
         QueryWrapper<CityAqiDaily> wrapper = new QueryWrapper<>();
-        wrapper.eq("city_code",regionCode);
-        wrapper.between("time",startDate,endDate);
+        wrapper.eq("city_code", regionCode);
+        wrapper.between("time", startDate, endDate);
         List<CityAqiDaily> cityAqiDailies = cityAqiDailyMapper.selectList(wrapper);
         //���������������������,������������time
-        if(cityAqiDailies.size()==0)
+        if (cityAqiDailies.size() == 0)
             return null;
-        String startTime = DateUtils.dateToDateString(cityAqiDailies.get(0).getTime(),"yyyy-MM-dd");
-        String endTime = DateUtils.dateToDateString(cityAqiDailies.get(cityAqiDailies.size()-1).getTime(),"yyyy-MM-dd");
-        String time = startTime+" ��� "+endTime;
-        //������������������������������
-        Map<String,CityAqiDaily> tmpMap = new HashMap<>();
+        String startTime = DateUtils.dateToDateString(cityAqiDailies.get(0).getTime(), "yyyy-MM-dd");
+        String endTime = DateUtils.dateToDateString(cityAqiDailies.get(cityAqiDailies.size() - 1).getTime(), "yyyy-MM-dd");
+        String time = startTime + " ��� " + endTime;
+        //���������������������������������������
+        Map<String, CityAqiDaily> tmpMap = new HashMap<>();
         for (CityAqiDaily cityAqiDaily : cityAqiDailies) {
-            String tmpTime = DateUtils.dateToDateString(cityAqiDaily.getTime(),"yyyy-MM-dd");
-            tmpMap.put(tmpTime,cityAqiDaily);
+            String tmpTime = DateUtils.dateToDateString(cityAqiDaily.getTime(), "yyyy-MM-dd");
+            tmpMap.put(tmpTime, cityAqiDaily);
         }
         cityAqiDailies = new ArrayList<CityAqiDaily>(tmpMap.values());
         //������������������������������
-        Map<String,Integer> pollutionDaysMap = new HashMap<>();
+        Map<String, Integer> pollutionDaysMap = new LinkedHashMap<>();
+        pollutionDaysMap.put(Constants.EXCELLENT_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.GOOD_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.MILD_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.MIDDLE_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.SERIOUS_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.SERVER_WEATHER_CODE, 0);
         for (CityAqiDaily cityAqiDaily : cityAqiDailies) {
-            Map<String,Object> valueMap = JSON.parseObject(cityAqiDaily.getValue(),Map.class);
-            if(valueMap.get("AQI")==null)
+            Map<String, Object> valueMap = JSON.parseObject(cityAqiDaily.getValue(), Map.class);
+            if (valueMap.get("AQI") == null)
                 continue;
             Integer aqi = Integer.valueOf(valueMap.get("AQI").toString());
             //������AQI������������
-            String pollutionClass = AQIUtils.classOfPollutionByAqi(aqi);
+            String pollutionClass = AQIUtils.classCodeOfPollutionByAqi(aqi);
             Integer days = pollutionDaysMap.get(pollutionClass);
-            if(days==null){
-                pollutionDaysMap.put(pollutionClass,1);
-            }else{
-                pollutionDaysMap.put(pollutionClass,days+1);
-            }
+            pollutionDaysMap.put(pollutionClass, days + 1);
         }
         //������������
-        List<Map<String,Object>> valueMap = new ArrayList<>();
+        List<Map<String, Object>> valueMap = new ArrayList<>();
         Set<Map.Entry<String, Integer>> entries = pollutionDaysMap.entrySet();
         Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
-        while(iterator.hasNext()){
+        Integer totalDays = 0;
+        while (iterator.hasNext()) {
             Map.Entry<String, Integer> entry = iterator.next();
-            Map<String,Object> pollutionMap = new HashMap<>();
+            Map<String, Object> pollutionMap = new HashMap<>();
             String pollution = entry.getKey();
             Integer days = entry.getValue();
-            Double proportionTmp = MathUtils.division(Double.valueOf(days),Double.valueOf(cityAqiDailies.size()),3);
-            Double proprtionD = MathUtils.mul(proportionTmp,100);
-            String proportion = proprtionD.toString()+"%";
-            pollutionMap.put("proportion",proportion);
-            pollutionMap.put("pollution",pollution);
-            pollutionMap.put("days",days);
+            Double proportionTmp = MathUtils.division(Double.valueOf(days), Double.valueOf(cityAqiDailies.size()), 3);
+            Double proportionD = MathUtils.mul(proportionTmp, 100);
+            String proportion = proportionD.toString() + "%";
+            pollutionMap.put("proportion", proportion);
+            pollutionMap.put("pollution", pollution);
+            pollutionMap.put("days", days);
             valueMap.add(pollutionMap);
+            totalDays += days;
         }
         //������������������
-        PollutionLevelProportionDTO dto = new PollutionLevelProportionDTO();
-        dto.setTime(time);
-        dto.setValues(valueMap);
-        return dto;
+        PieChartOfPollutionLevelVO VO = new PieChartOfPollutionLevelVO();
+        VO.setTime(time);
+        VO.setValues(valueMap);
+        VO.setTotalDays(totalDays);
+        return VO;
     }
+
+    @Override
+    public List<MonthlyPollutionLevel> queryBarChartOfPollutionLevels(ChartOfPollutionLevelForm form) {
+        //������
+        Integer regionCode = form.getRegionCode();
+        Date startDate = form.getStartDate();
+        Date endDate = form.getEndDate();
+        //������������
+        QueryWrapper<CityAqiDaily> wrapper = new QueryWrapper<>();
+        wrapper.eq("city_code", regionCode);
+        wrapper.between("time", startDate, endDate);
+        wrapper.orderByAsc("time");
+        List<CityAqiDaily> cityAqiDailies = cityAqiDailyMapper.selectList(wrapper);
+        //���������������������������������������
+        Map<String, CityAqiDaily> tmpMap = new LinkedHashMap<>();
+        for (CityAqiDaily cityAqiDaily : cityAqiDailies) {
+            String tmpTime = DateUtils.dateToDateString(cityAqiDaily.getTime(), "yyyy-MM-dd");
+            tmpMap.put(tmpTime, cityAqiDaily);
+        }
+        cityAqiDailies = new ArrayList<CityAqiDaily>(tmpMap.values());
+        //���������������������������������
+        Map<String, List<CityAqiDaily>> monthlyDataMap = new LinkedHashMap<>();
+        cityAqiDailies.forEach(value -> {
+            String month = DateUtils.dateToDateString(value.getTime(), "yyyy-MM");
+            List<CityAqiDaily> dataList = monthlyDataMap.get(month);
+            if (ObjectUtils.isEmpty(dataList))
+                dataList = new ArrayList<>();
+            dataList.add(value);
+            monthlyDataMap.put(month, dataList);
+        });
+        //���������������������������
+        List<MonthlyPollutionLevel> monthlyPollutionLevels = new ArrayList<>();
+        Set<Map.Entry<String, List<CityAqiDaily>>> monthlyEntries = monthlyDataMap.entrySet();
+        Iterator<Map.Entry<String, List<CityAqiDaily>>> monthlyIterator = monthlyEntries.iterator();
+        while (monthlyIterator.hasNext()) {
+            Map.Entry<String, List<CityAqiDaily>> monthlyEntry = monthlyIterator.next();
+            List<CityAqiDaily> monthlyValues = monthlyEntry.getValue();
+            //���������������������������������������
+            Map<String, Integer> pollutionDaysMap = new LinkedHashMap<>();
+            pollutionDaysMap.put(Constants.EXCELLENT_WEATHER_CODE, 0);
+            pollutionDaysMap.put(Constants.GOOD_WEATHER_CODE, 0);
+            pollutionDaysMap.put(Constants.MILD_WEATHER_CODE, 0);
+            pollutionDaysMap.put(Constants.MIDDLE_WEATHER_CODE, 0);
+            pollutionDaysMap.put(Constants.SERIOUS_WEATHER_CODE, 0);
+            pollutionDaysMap.put(Constants.SERVER_WEATHER_CODE, 0);
+            for (CityAqiDaily cityAqiDaily : monthlyValues) {
+                Map<String, Object> valueMap = JSON.parseObject(cityAqiDaily.getValue(), Map.class);
+                if (valueMap.get("AQI") == null)
+                    continue;
+                Integer aqi = Integer.valueOf(valueMap.get("AQI").toString());
+                //������AQI������������
+                String pollutionClass = AQIUtils.classCodeOfPollutionByAqi(aqi);
+                Integer days = pollutionDaysMap.get(pollutionClass);
+                pollutionDaysMap.put(pollutionClass, days + 1);
+            }
+
+            //������������
+            List<PollutionDaysAndProportion> pollutionDaysAndProportions = new ArrayList<>();
+            Set<Map.Entry<String, Integer>> entries = pollutionDaysMap.entrySet();
+            Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
+            while (iterator.hasNext()) {
+                Map.Entry<String, Integer> entry = iterator.next();
+                String pollution = entry.getKey();
+                Integer days = entry.getValue();
+                Double proportionTmp = MathUtils.division(Double.valueOf(days), Double.valueOf(monthlyValues.size()), 3);
+                Double proportionD = MathUtils.mul(proportionTmp, 100);
+                String proportion = proportionD.toString() + "%";
+                PollutionDaysAndProportion pollutionDaysAndProportion = new PollutionDaysAndProportion();
+                pollutionDaysAndProportion.setDays(days);
+                pollutionDaysAndProportion.setPollutionLevel(pollution);
+                pollutionDaysAndProportion.setProportion(proportion);
+                pollutionDaysAndProportions.add(pollutionDaysAndProportion);
+            }
+            //������������������
+            MonthlyPollutionLevel monthlyPollutionLevel = new MonthlyPollutionLevel();
+            monthlyPollutionLevel.setPollutionDaysAndProportions(pollutionDaysAndProportions);
+            monthlyPollutionLevel.setTime(monthlyEntry.getKey());
+            monthlyPollutionLevels.add(monthlyPollutionLevel);
+        }
+        return monthlyPollutionLevels;
+    }
+
+    @Override
+    public Map<String, Map<String, Object>> oneYearsData(Map map) {
+        int city_code = Integer.parseInt(map.get("cityCode").toString());
+        String year = map.get("year").toString();
+        String startTime = year + "-01-01 00:00:00";
+        String endTime = year + "-12-31 23:59:59";
+        QueryWrapper<CityAqiDaily> cityAqiDailyQueryWrapper = new QueryWrapper<>();
+        cityAqiDailyQueryWrapper.eq("city_code", city_code);
+        cityAqiDailyQueryWrapper.between("time", startTime, endTime);
+        List<CityAqiDaily> cityAqiDailies = cityAqiDailyMapper.selectList(cityAqiDailyQueryWrapper);
+        Map<String, Map<String, Object>> resultMap = new HashMap<>();
+        for (int i = 1; i < 13; i++) {
+            Map<String, Object> monthMap = new HashMap<>();
+            String month = null;
+            if (i < 10) {
+                month = "0" + i;
+            } else {
+                month = String.valueOf(i);
+            }
+            String monthDate = year + "-" + month;
+            String monthFirstDay = year + "-" + month + "-01";
+            int monthDay = DateUtils.getMonthDay(monthFirstDay);
+            for (int j = 1; j < monthDay + 1; j++) {
+                String day = null;
+                if (j < 10) {
+                    day = "0" + j;
+                } else {
+                    day = String.valueOf(j);
+                }
+                String dayDate = year + "-" + month + "-" + day;
+                monthMap.put(dayDate, null);
+            }
+            resultMap.put(monthDate, monthMap);
+        }
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        for (CityAqiDaily cityAqiDaily : cityAqiDailies) {
+            String time = sdf.format(cityAqiDaily.getTime());
+            String monthDate = time.substring(0, 7);
+            String dayDate = time.substring(0, 10);
+            Double PM2_5 = null;
+            Double PM10 = null;
+            Double SO2 = null;
+            Double NO2 = null;
+            Double CO = null;
+            Double O3 = null;
+            String primaryPollutant = null;
+            String AQI = null;
+            String value = cityAqiDaily.getValue();
+            JSONObject jsonObject = new JSONObject();
+            jsonObject = JSONObject.parseObject(value);
+            if (!ObjectUtils.isEmpty(jsonObject.get("PM2_5"))) {
+                PM2_5 = (Double.parseDouble(jsonObject.get("PM2_5").toString()));
+            }
+            if (!ObjectUtils.isEmpty(jsonObject.get("PM10"))) {
+                PM10 = (Double.parseDouble(jsonObject.get("PM10").toString()));
+            }
+            if (!ObjectUtils.isEmpty(jsonObject.get("SO2"))) {
+                SO2 = (Double.parseDouble(jsonObject.get("SO2").toString()));
+            }
+            if (!ObjectUtils.isEmpty(jsonObject.get("NO2"))) {
+                NO2 = (Double.parseDouble(jsonObject.get("NO2").toString()));
+            }
+            if (!ObjectUtils.isEmpty(jsonObject.get("CO"))) {
+                CO = (Double.parseDouble(jsonObject.get("CO").toString()));
+            }
+            if (!ObjectUtils.isEmpty(jsonObject.get("O3"))) {
+                O3 = (Double.parseDouble(jsonObject.get("O3").toString()));
+            }
+            if (!ObjectUtils.isEmpty(jsonObject.get("primaryPollutant"))) {
+                primaryPollutant = jsonObject.get("primaryPollutant").toString();
+            }
+            if (!ObjectUtils.isEmpty(jsonObject.get("AQI"))) {
+                AQI = jsonObject.get("AQI").toString();
+            }
+            Map<String, Object> valueMap = new HashMap<>();
+            valueMap.put("PM2_5", PM2_5);
+            valueMap.put("PM10", PM10);
+            valueMap.put("SO2", SO2);
+            valueMap.put("NO2", NO2);
+            valueMap.put("CO", CO);
+            valueMap.put("O3", O3);
+            valueMap.put("AQI", AQI);
+            valueMap.put("primaryPollutant", primaryPollutant);
+            Map<String, Object> monthMap = new HashMap<>();
+            monthMap = resultMap.get(monthDate);
+            monthMap.put(dayDate, valueMap);
+            resultMap.put(monthDate, monthMap);
+        }
+        return resultMap;
+    }
+
+
+    @Override
+    public List<CityPollutionLevel> queryAreaPollutionLevel(AreaPollutionLevelForm form) {
+        //������
+        Integer regionCode = form.getRegionCode();
+        Date startDate = form.getStartDate();
+        Date endDate = form.getEndDate();
+        //������������������������������
+        List<SysArea> allAreas = sysAreaService.getChildren(regionCode);
+        //������������������������
+        List<CityPollutionLevel> datas = new ArrayList<>();
+        //��������������������� ������������
+        for (SysArea area : allAreas) {
+            CityPollutionLevel cityPollutionLevel = calculateDaysByTimeAndSysArea(area, startDate, endDate);
+            datas.add(cityPollutionLevel);
+        }
+        return datas;
+    }
+
+    @Override
+    public List<CityPollutionLevel> querySpecialCitiesPollutionLevel(SpecialCitiesPollutionLevelForm form) {
+        //������
+        Date startDate = form.getStartDate();
+        Date endDate = form.getEndDate();
+        List<SysArea> areas = specialCitiesProperties.getTwentyEightCities();
+        //������������������������
+        List<CityPollutionLevel> datas = new ArrayList<>();
+        //��������������������� ������������
+        for (SysArea area : areas) {
+            CityPollutionLevel cityPollutionLevel = calculateDaysByTimeAndSysArea(area, startDate, endDate);
+            datas.add(cityPollutionLevel);
+        }
+        return datas;
+    }
+
+    @Override
+    public List<CityAreaRangeVO> cityAreaRange(Integer regionCode, Date time) {
+        //���������������������������������������������������null
+        if (DateUtils.getYesterdayDate().getTime() < time.getTime())
+            return null;
+        //������������������������������������
+        List<SysArea> allAreas = sysAreaService.getChildren(regionCode);
+        //������������������
+        Date compareTime = DateUtils.addMonths(time, -12);
+        //���������������������������������������������
+        Date startDate = DateUtils.getFirstDayOfMonth(time);
+        Date endDate = DateUtils.getLastDayOfMonth(time);
+        //���������������������������������������������
+        Date compareStartDate = DateUtils.getFirstDayOfMonth(compareTime);
+        Date compareEndDate = DateUtils.getLastDayOfMonth(compareTime);
+        //���������������
+        List<CityAreaRangeVO> vos = new ArrayList<>();
+        for (SysArea area : allAreas) {
+            CityAreaRangeVO vo = new CityAreaRangeVO();
+            Map<String, Object> data = new HashMap<>();
+            Map<String, Object> compareData = new HashMap<>();
+            //���������������������������
+            QueryWrapper<CityAqiDaily> wrapper = new QueryWrapper<>();
+            wrapper.eq("time", time);
+            wrapper.eq("city_code", area.getAreaCode());
+            List<CityAqiDaily> datas = cityAqiDailyMapper.selectList(wrapper);
+            if (!ObjectUtils.isEmpty(datas))
+                data = JSON.parseObject(datas.get(0).getValue(), Map.class);
+            //���������������������������
+            QueryWrapper<CityAqiDaily> compareWrapper = new QueryWrapper<>();
+            compareWrapper.eq("time", compareTime);
+            compareWrapper.eq("city_code", area.getAreaCode());
+            List<CityAqiDaily> compareDatas = cityAqiDailyMapper.selectList(compareWrapper);
+            if (!ObjectUtils.isEmpty(compareDatas))
+                compareData = JSON.parseObject(compareDatas.get(0).getValue(), Map.class);
+            if (ObjectUtils.isEmpty(compareDatas) && ObjectUtils.isEmpty(datas)) {
+                vos.add(vo);
+                continue;
+            }
+            //������6������������������������������������
+            ConcentrationAndPercent PM25 = getConcentrationAndPercent(data.get("PM2_5"), compareData.get("PM2_5"));
+            ConcentrationAndPercent PM10 = getConcentrationAndPercent(data.get("PM10"), compareData.get("PM10"));
+            ConcentrationAndPercent SO2 = getConcentrationAndPercent(data.get("SO2"), compareData.get("SO2"));
+            ConcentrationAndPercent NO2 = getConcentrationAndPercent(data.get("NO2"), compareData.get("NO2"));
+            ConcentrationAndPercent CO = getConcentrationAndPercent(data.get("CO"), compareData.get("CO"));
+            ConcentrationAndPercent O3 = getConcentrationAndPercent(data.get("O3"), compareData.get("O3"));
+            ConcentrationAndPercent compositeIndex = getConcentrationAndPercent(data.get("compositeIndex"), compareData.get("compositeIndex"));
+            //���������������������������������������
+            CityPollutionLevel days = calculateDaysByTimeAndSysArea(area, startDate, endDate);
+            CityPollutionLevel compareDays = calculateDaysByTimeAndSysArea(area, compareStartDate, compareEndDate);
+            Integer fineDays = null;
+            Integer pollutionDays = null;
+            Integer compareFineDays = null;
+            Integer comparePollutionDays = null;
+            if (days != null) {
+                fineDays = days.getExcellentWeatherDays() + days.getGoodWeatherDays();
+                pollutionDays = days.getMildWeatherDays() + days.getServerWeatherDays() + days.getSeriousWeatherDays() + days.getMiddleWeatherDays();
+            }
+            if (compareDays != null) {
+                compareFineDays = compareDays.getExcellentWeatherDays() + compareDays.getGoodWeatherDays();
+                comparePollutionDays = compareDays.getMildWeatherDays() + compareDays.getServerWeatherDays() + compareDays.getSeriousWeatherDays() + compareDays.getMiddleWeatherDays();
+            }
+            ConcentrationAndPercent fineDaysData = getFineDaysConcentrationAndPercent(fineDays, compareFineDays);
+            ConcentrationAndPercent pollutionDaysData = getFineDaysConcentrationAndPercent(pollutionDays, comparePollutionDays);
+            //������������
+            vo.setCityName(area.getAreaName());
+            vo.setCompositeIndex(compositeIndex);
+            vo.setPM10(PM10);
+            vo.setPM25(PM25);
+            vo.setNO2(NO2);
+            vo.setSO2(SO2);
+            vo.setO3(O3);
+            vo.setCO(CO);
+            vo.setFineDays(fineDaysData);
+            vo.setServerDays(pollutionDaysData);
+            vos.add(vo);
+        }
+        //���������������������
+        vos.sort(Comparator.comparing(value -> Double.valueOf(value.getCompositeIndex().getConcentration())));
+        for(int i =1;i<vos.size()+1;i++){
+            vos.get(i-1).setRange(i);
+        }
+        return vos;
+    }
+
+    @Override
+    public List<CityPollutionLevel> queryProvinceCitiesPollutionLevel(ProvinceCitiesPollutionLevelForm form) {
+        //������
+        Date startDate = form.getStartDate();
+        Date endDate = form.getEndDate();
+        Integer regionCode = form.getRegionCode();
+        //������������������������
+        List<SysArea> allCities = sysAreaService.getChildren(regionCode);
+        //������������������������
+        List<CityPollutionLevel> datas = new ArrayList<>();
+        //��������������������� ������������
+        for (SysArea city : allCities) {
+            CityPollutionLevel cityPollutionLevel = calculateDaysByTimeAndSysArea(city, startDate, endDate);
+            datas.add(cityPollutionLevel);
+        }
+        return datas;
+    }
+
+    @Override
+    public CityPollutionLevel calculateDaysByTimeAndSysArea(SysArea area, Date startDate, Date endDate) {
+        //������������
+        QueryWrapper<CityAqiDaily> wrapper = new QueryWrapper<>();
+        wrapper.eq("city_code", area.getAreaCode());
+        wrapper.between("time", startDate, endDate);
+        wrapper.orderByAsc("time");
+        List<CityAqiDaily> cityAqiDailies = cityAqiDailyMapper.selectList(wrapper);
+        if (ObjectUtils.isEmpty(cityAqiDailies))
+            return null;
+        //���������������������������������������
+        Map<String, CityAqiDaily> tmpMap = new LinkedHashMap<>();
+        for (CityAqiDaily cityAqiDaily : cityAqiDailies) {
+            String tmpTime = DateUtils.dateToDateString(cityAqiDaily.getTime(), "yyyy-MM-dd");
+            tmpMap.put(tmpTime, cityAqiDaily);
+        }
+        cityAqiDailies = new ArrayList<CityAqiDaily>(tmpMap.values());
+        //���������������������������������������
+        Map<String, Integer> pollutionDaysMap = new LinkedHashMap<>();
+        pollutionDaysMap.put(Constants.EXCELLENT_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.GOOD_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.MILD_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.MIDDLE_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.SERIOUS_WEATHER_CODE, 0);
+        pollutionDaysMap.put(Constants.SERVER_WEATHER_CODE, 0);
+        for (CityAqiDaily cityAqiDaily : cityAqiDailies) {
+            Map<String, Object> valueMap = JSON.parseObject(cityAqiDaily.getValue(), Map.class);
+            if (valueMap.get("AQI") == null)
+                continue;
+            Integer aqi = Integer.valueOf(valueMap.get("AQI").toString());
+            //������AQI������������
+            String pollutionClass = AQIUtils.classCodeOfPollutionByAqi(aqi);
+            Integer days = pollutionDaysMap.get(pollutionClass);
+            pollutionDaysMap.put(pollutionClass, days + 1);
+        }
+        //������������
+        CityPollutionLevel cityPollutionLevel = new CityPollutionLevel();
+        cityPollutionLevel.setRegionName(area.getAreaName());
+        cityPollutionLevel.setExcellentWeatherDays(pollutionDaysMap.get(Constants.EXCELLENT_WEATHER_CODE));
+        cityPollutionLevel.setGoodWeatherDays(pollutionDaysMap.get(Constants.GOOD_WEATHER_CODE));
+        cityPollutionLevel.setMildWeatherDays(pollutionDaysMap.get(Constants.MILD_WEATHER_CODE));
+        cityPollutionLevel.setMiddleWeatherDays(pollutionDaysMap.get(Constants.MIDDLE_WEATHER_CODE));
+        cityPollutionLevel.setSeriousWeatherDays(pollutionDaysMap.get(Constants.SERIOUS_WEATHER_CODE));
+        cityPollutionLevel.setServerWeatherDays(pollutionDaysMap.get(Constants.SERVER_WEATHER_CODE));
+        return cityPollutionLevel;
+    }
+
+    @Override
+    public List<String> airQualityBulletin(String regionCode, Date time) {
+        List<String> result = new ArrayList<>();
+        //���������������
+        QueryWrapper<CityAqiDaily> dailyWrapper = new QueryWrapper<>();
+        dailyWrapper.eq("city_code", regionCode);
+        dailyWrapper.eq("time", time);
+        CityAqiDaily cityAqiDaily = cityAqiDailyMapper.selectOne(dailyWrapper);
+        if (cityAqiDaily == null)
+            return null;
+        Map<String, Object> dailyDataMap = JSON.parseObject(cityAqiDaily.getValue(), Map.class);
+        //���������������
+        int year = DateUtils.getYear(time);
+        int month = DateUtils.getMonth(time);
+        int day = DateUtils.getDay(time);
+        //������������title
+        String title = getBulletinTitle(month + "", day + "");
+        if (title == null)
+            return null;
+        //���������������������������
+        String paragraphOne = getParagraphOne(month + "", day + "", dailyDataMap);
+        if (paragraphOne == null)
+            return null;
+        //���������������������
+        List<String> paragraphTwoAndFour = getParagraphTwoAndFour(year + "", month + "", day + "", regionCode, time);
+        if (paragraphTwoAndFour == null)
+            return null;
+        String paragraphTwo = paragraphTwoAndFour.get(0);
+        //���������������������������
+        String paragraphThree = getParagraphThree(month + "", day + "", regionCode, time);
+        if (paragraphThree == null)
+            return null;
+        //���������������������
+        String paragraphFour = paragraphTwoAndFour.get(1);
+        result.add(title);
+        result.add(paragraphOne);
+        result.add(paragraphTwo);
+        result.add(paragraphThree);
+        result.add(paragraphFour);
+        return result;
+    }
+
+    //������������title������
+    private String getBulletinTitle(String month, String day) {
+        String title = bulletinProperties.getTitle();
+        title = title.replace("{month}", month);
+        title = title.replace("{day}", day);
+        return title;
+    }
+
+    //���������������������������
+    private String getParagraphOne(String month, String day, Map<String, Object> dailyData) {
+        //������������������
+        String pollutionLevelDescribe = AQIUtils.classOfPollutionByAqi(Integer.parseInt(dailyData.get("AQI").toString()));
+        String pollutionLevel = AQIUtils.classCodeOfPollutionByAqi(Integer.parseInt(dailyData.get("AQI").toString()));
+        //���������������������������
+        int standardCount = AQIUtils.standardCount(dailyData);
+        String paragraphOne = bulletinProperties.getParagraphOne();
+        paragraphOne = paragraphOne.replace("{month}", month);
+        paragraphOne = paragraphOne.replace("{day}", day);
+        paragraphOne = paragraphOne.replace("{pollutionLevel}", pollutionLevel);
+        paragraphOne = paragraphOne.replace("{pollutionLevelDescribe}", pollutionLevelDescribe);
+        paragraphOne = paragraphOne.replace("{standardCount}", standardCount + "");
+        paragraphOne = paragraphOne.replace("{PM2.5}", dailyData.get("PM2_5").toString());
+        paragraphOne = paragraphOne.replace("{SO2}", dailyData.get("SO2").toString());
+        paragraphOne = paragraphOne.replace("{NO2}", dailyData.get("NO2").toString());
+        paragraphOne = paragraphOne.replace("{CO}", dailyData.get("CO").toString());
+        paragraphOne = paragraphOne.replace("{O3}", dailyData.get("O3").toString());
+        paragraphOne = paragraphOne.replace("{PM10}", dailyData.get("PM10").toString());
+        return paragraphOne;
+    }
+
+    //���������������������������������������
+    private List<String> getParagraphTwoAndFour(String year, String month, String day, String regionCode, Date time) {
+        List<String> result = new ArrayList<>();
+        String paragraphTwo = bulletinProperties.getParagraphTwo();
+        String paragraphFour = bulletinProperties.getParagraphFour();
+        Date startTime = DateUtils.getFirstDayOfYear(time);
+        Date endTime = time;
+        Date compareStartTime = DateUtils.addMonths(startTime, -12);
+        Date compareEndTime = DateUtils.addMonths(endTime, -12);
+        SysArea area = new SysArea();
+        area.setAreaCode(Integer.parseInt(regionCode));
+        //������������������������
+        CityPollutionLevel days = calculateDaysByTimeAndSysArea(area, startTime, endTime);
+        //������������������������������
+        CityPollutionLevel compareDays = calculateDaysByTimeAndSysArea(area, compareStartTime, compareEndTime);
+        if (days == null || compareDays == null)
+            return null;
+        //������������������
+        List<CityAqiYearly> yearDataList = cityAqiYearlyService.getCityAqiYearlyByRegionCodeAndTime(Integer.parseInt(regionCode), startTime, endTime);
+        List<CityAqiYearly> compareYearDataList = cityAqiYearlyService.getCityAqiYearlyByRegionCodeAndTime(Integer.parseInt(regionCode), compareStartTime, compareEndTime);
+        if (ObjectUtils.isEmpty(yearDataList) || ObjectUtils.isEmpty(compareYearDataList))
+            return null;
+        CityAqiYearly yearData = yearDataList.get(0);
+        CityAqiYearly compareYearData = compareYearDataList.get(0);
+        Map<String, Object> dataMap = JSON.parseObject(yearData.getValue(), Map.class);
+        Map<String, Object> compareDataMap = JSON.parseObject(compareYearData.getValue(), Map.class);
+        //���������������������
+        String yearPM_5 = dataMap.get("PM2_5").toString();
+        String fineDays = days.getExcellentWeatherDays() + days.getGoodWeatherDays() + "";
+        int allDays = DateUtils.getDays(startTime, endTime) + 1;
+        paragraphTwo = paragraphTwo.replace("{year}", year);
+        paragraphTwo = paragraphTwo.replace("{yearPM2.5}", yearPM_5);
+        paragraphTwo = paragraphTwo.replace("{fineDays}", fineDays);
+        paragraphTwo = paragraphTwo.replace("{days}", allDays + "");
+        result.add(paragraphTwo);
+
+        //���������������������
+        //������������������������
+        Double compositeIndex = Double.valueOf(dataMap.get("compositeIndex").toString());
+        Double compareCompositeIndex = Double.valueOf(compareDataMap.get("compositeIndex").toString());
+        //������������������������������������
+        String yoyYearCompositeIndexUpDown = getUpOrDown(compositeIndex, compareCompositeIndex);
+        //������������������������������������������
+        String yoyYearCompositeIndex = calculateComparePerPositive(compositeIndex, compareCompositeIndex).toString();
+
+        //������������PM2.5
+        Double PM2_5 = Double.valueOf(dataMap.get("PM2_5").toString());
+        Double comparePM2_5 = Double.valueOf(compareDataMap.get("PM2_5").toString());
+        //������PM2.5������������������
+        String yoyYearPM2_5UpDown = getUpOrDown(PM2_5, comparePM2_5);
+        //������PM2.5������������������������
+        String yoyYearPM2_5 = calculateComparePerPositive(PM2_5, comparePM2_5).toString();
+
+        //������������������������
+        int yearFineDays = days.getExcellentWeatherDays() + days.getGoodWeatherDays();
+        //������������������������������
+        int compareYearFineDays = compareDays.getExcellentWeatherDays() + days.getGoodWeatherDays();
+        //������������������������
+        int yoyYearFineDaysInt = yearFineDays - compareYearFineDays;
+        String yoyYearFineDays = yoyYearFineDaysInt > 0 ? yoyYearFineDaysInt + "" : yoyYearFineDaysInt * (-1) + "";
+        //���������������������������������
+        String yoyYearFineDaysUpDown = getIncreaseOrDecrease(yearFineDays, compareYearFineDays);
+        //������������������������
+        int yearPollutionDays = days.getMildWeatherDays() + days.getMiddleWeatherDays() + days.getSeriousWeatherDays() + days.getServerWeatherDays();
+        //������������������������������
+        String yearFineDaysPer = String.valueOf(MathUtils.division(yearFineDays * 100, allDays, 2));
+
+        //������168������������������������������������������������������
+        List<Integer> oneSixEightRanges = rangeByCities(compositeIndex,
+                calculateCompare(compositeIndex, compareCompositeIndex),
+                startTime, endTime, compareStartTime, compareEndTime,
+                specialCitiesProperties.getOneSixEightCities());
+
+        //������28������������������������������������������������������
+        List<Integer> twentyEightRanges = rangeByCities(compositeIndex,
+                calculateCompare(compositeIndex, compareCompositeIndex),
+                startTime, endTime, compareStartTime, compareEndTime,
+                specialCitiesProperties.getTwentyEightCities());
+
+        String compositeIndex28range = twentyEightRanges.get(0).toString();
+        String compositeIndexPer28range = twentyEightRanges.get(1).toString();
+        String compositeIndex168range = oneSixEightRanges.get(0).toString();
+        String compositeIndexPer168range = oneSixEightRanges.get(1).toString();
+        //������������������
+        paragraphFour = paragraphFour.replace("{month}", month);
+        paragraphFour = paragraphFour.replace("{day}", day);
+        paragraphFour = paragraphFour.replace("{yearCompositeIndex}", compositeIndex + "");
+        paragraphFour = paragraphFour.replace("{yoyYearCompositeIndex}", yoyYearCompositeIndex);
+        paragraphFour = paragraphFour.replace("{yoyYearCompositeIndexUpDown}", yoyYearCompositeIndexUpDown);
+        paragraphFour = paragraphFour.replace("{yearPM2.5}", PM2_5 + "");
+        paragraphFour = paragraphFour.replace("{yoyYearPM2.5UpDown}", yoyYearPM2_5UpDown);
+        paragraphFour = paragraphFour.replace("{yoyYearPM2.5}", yoyYearPM2_5);
+        paragraphFour = paragraphFour.replace("{yearFineDays}", yearFineDays + "");
+        paragraphFour = paragraphFour.replace("{yearFineDaysPer}", yearFineDaysPer);
+        paragraphFour = paragraphFour.replace("{yearPollutionDays}", yearPollutionDays + "");
+        paragraphFour = paragraphFour.replace("{yoyYearFineDaysUpDown}", yoyYearFineDaysUpDown);
+        paragraphFour = paragraphFour.replace("{yoyYearFineDays}", yoyYearFineDays);
+        paragraphFour = paragraphFour.replace("{compositeIndex28range}", compositeIndex28range);
+        paragraphFour = paragraphFour.replace("{compositeIndexPer28range}", compositeIndexPer28range);
+        paragraphFour = paragraphFour.replace("{compositeIndex168range}", compositeIndex168range);
+        paragraphFour = paragraphFour.replace("{compositeIndexPer168range}", compositeIndexPer168range);
+        result.add(paragraphFour);
+        return result;
+    }
+
+    //������������������������������������������������������
+    private List<Integer> rangeByCities(
+            Double compositeIndex,
+            Double compositeIndexPer,
+            Date startTime,
+            Date endTime,
+            Date compareStartTime,
+            Date compareEndTime, List<SysArea> areas) {
+        List<Double> compositeIndexList = new ArrayList<>();
+        List<Double> compositePerList = new ArrayList<>();
+        for (SysArea sysArea : areas) {
+            //������������
+            List<CityAqiYearly> data = cityAqiYearlyService.getCityAqiYearlyByRegionCodeAndTime(sysArea.getAreaCode(), startTime, endTime);
+            //������������������
+            List<CityAqiYearly> compareData = cityAqiYearlyService.getCityAqiYearlyByRegionCodeAndTime(sysArea.getAreaCode(), compareStartTime, compareEndTime);
+            if (ObjectUtils.isEmpty(data) || ObjectUtils.isEmpty(compareData))
+                continue;
+            Map<String, Object> dataMap = JSON.parseObject(data.get(0).getValue(), Map.class);
+            Map<String, Object> compareDataMap = JSON.parseObject(compareData.get(0).getValue(), Map.class);
+            //������������������
+            compositeIndexList.add(Double.valueOf(dataMap.get("compositeIndex").toString()));
+            //���������������������������
+            Double per = calculateCompare(Double.valueOf(dataMap.get("compositeIndex").toString()), Double.valueOf(compareDataMap.get("compositeIndex").toString()));
+            compositePerList.add(per);
+        }
+        Collections.sort(compositeIndexList);
+        Collections.sort(compositePerList);
+        Integer compositeIndexRange = compositeIndexList.indexOf(compositeIndex);
+        Integer compositePerRange = compositePerList.indexOf(compositeIndexPer);
+        return Arrays.asList((compositeIndexRange + 1), (compositePerRange + 1));
+    }
+
+    //���������������������������
+    private String getParagraphThree(String month, String day, String regionCode, Date time) {
+        String paragraphThree = bulletinProperties.getParagraphThree();
+        //������������������������
+        CityAqiMonthly monthlyData = cityAqiMonthlyService.getCityAqiMonthByRegionCodeAndTime(Integer.parseInt(regionCode), time);
+        //������������������������
+        Date compareTime = DateUtils.addMonths(time, -12);
+        CityAqiMonthly compareMonthlyData = cityAqiMonthlyService.getCityAqiMonthByRegionCodeAndTime(Integer.parseInt(regionCode), compareTime);
+        if (monthlyData == null || compareMonthlyData == null)
+            return null;
+        Map<String, Object> monthlyDataMap = JSON.parseObject(monthlyData.getValue(), Map.class);
+        Map<String, Object> compareMonthlyDataMap = JSON.parseObject(compareMonthlyData.getValue(), Map.class);
+        //������������������
+        Date endTime = time;
+        Date startTime = DateUtils.getFirstDayOfMonth(time);
+        Date compareStartTime = DateUtils.addMonths(startTime, -12);
+        Date compareEndTime = DateUtils.addMonths(endTime, -12);
+        SysArea area = new SysArea();
+        area.setAreaCode(Integer.parseInt(regionCode));
+        CityPollutionLevel days = calculateDaysByTimeAndSysArea(area, startTime, endTime);
+        CityPollutionLevel compareDays = calculateDaysByTimeAndSysArea(area, compareStartTime, compareEndTime);
+        if (days == null || compareDays == null)
+            return null;
+        //������������������������
+        Double compositeIndex = Double.valueOf(monthlyDataMap.get("compositeIndex").toString());
+        Double compareCompositeIndex = Double.valueOf(compareMonthlyDataMap.get("compositeIndex").toString());
+        //������������������������������������
+        String yoyMonthCompositeIndexUpDown = getUpOrDown(compositeIndex, compareCompositeIndex);
+        //������������������������������������������
+        String yoyMonthCompositeIndex = calculateComparePerPositive(compositeIndex, compareCompositeIndex).toString();
+
+        //������������PM2.5
+        Double PM2_5 = Double.valueOf(monthlyDataMap.get("PM2_5").toString());
+        Double comparePM2_5 = Double.valueOf(compareMonthlyDataMap.get("PM2_5").toString());
+        //������PM2.5������������������
+        String yoyMonthPM2_5UpDown = getUpOrDown(PM2_5, comparePM2_5);
+        //������PM2.5������������������������
+        String yoyMonthPM2_5 = calculateComparePerPositive(PM2_5, comparePM2_5).toString();
+
+        //������������������������
+        int monthFineDays = days.getExcellentWeatherDays() + days.getGoodWeatherDays();
+        //������������������������������
+        int compareMonthFineDays = compareDays.getExcellentWeatherDays() + days.getGoodWeatherDays();
+        //������������������������
+        int yoyMonthFineDaysInt = monthFineDays - compareMonthFineDays;
+        String yoyMonthFineDays = yoyMonthFineDaysInt > 0 ? yoyMonthFineDaysInt + "" : yoyMonthFineDaysInt * (-1) + "";
+        //���������������������������������
+        String yoyMonthFineDaysUpDown = getIncreaseOrDecrease(monthFineDays, compareMonthFineDays);
+
+        paragraphThree = paragraphThree.replace("{month}", month);
+        paragraphThree = paragraphThree.replace("{day}", day);
+        paragraphThree = paragraphThree.replace("{monthCompositeIndex}", compositeIndex.toString());
+        paragraphThree = paragraphThree.replace("{yoyMonthCompositeIndex}", yoyMonthCompositeIndex);
+        paragraphThree = paragraphThree.replace("{yoyMonthCompositeIndexUpDown}", yoyMonthCompositeIndexUpDown);
+        paragraphThree = paragraphThree.replace("{monthPM2.5}", PM2_5.toString());
+        paragraphThree = paragraphThree.replace("{yoyMonthPM2.5UpDown}", yoyMonthPM2_5UpDown);
+        paragraphThree = paragraphThree.replace("{yoyMonthPM2.5}", yoyMonthPM2_5);
+        paragraphThree = paragraphThree.replace("{monthFineDays}", monthFineDays + "");
+        paragraphThree = paragraphThree.replace("{yoyMonthFineDaysUpDown}", yoyMonthFineDaysUpDown);
+        paragraphThree = paragraphThree.replace("{yoyMonthFineDays}", yoyMonthFineDays);
+        return paragraphThree;
+    }
+
+    //������currentData���compareData���������������"������","������".currentData>compareData���������������
+    private String getUpOrDown(Double currentData, Double compareData) {
+        if (MathUtils.sub(currentData, compareData) > 0)
+            return "������";
+        return "������";
+    }
+
+    //������������������������������������������������������������"������","������".currentData>compareData���������������
+    private String getIncreaseOrDecrease(int currentDays, int compareDays) {
+        if (currentDays - compareDays > 0)
+            return "������";
+        return "������";
+    }
+
+
+    //������������������/������������ ���������������������-���������������/������������ ���������������
+    private Double calculateComparePerPositive(Double currentData, Double compareData) {
+        double tmp1 = MathUtils.sub(currentData, compareData);
+        double result = MathUtils.mul(MathUtils.division(tmp1, compareData, 4), 100d);
+        return result > 0 ? result : MathUtils.mul(result, -1d);
+    }
+
+    //������������������/������������ ���������������������-���������������/������������
+    private Double calculateCompare(Double currentData, Double compareData) {
+        double tmp1 = MathUtils.sub(currentData, compareData);
+        return MathUtils.mul(MathUtils.division(tmp1, compareData, 4), 100d);
+    }
+
+
+    //��������������������������������������� ������������ ������������
+    private ConcentrationAndPercent getConcentrationAndPercent(Object data, Object compareData) {
+        ConcentrationAndPercent cap = new ConcentrationAndPercent();
+        cap.setConcentration(data != null ? data.toString() : "-");
+        cap.setCompareConcentration(compareData != null ? compareData.toString() : "-");
+        if (data != null && compareData != null)
+            cap.setPercent(calculateCompare(Double.valueOf(data.toString()), Double.valueOf(compareData.toString())) + "%");
+        else
+            cap.setPercent("-");
+        return cap;
+    }
+
+    //������������������������������������������������
+    private ConcentrationAndPercent getFineDaysConcentrationAndPercent(Integer days, Integer compareDays) {
+        ConcentrationAndPercent cap = new ConcentrationAndPercent();
+        cap.setConcentration(days != null ? days + "���" : "-");
+        cap.setPercent(compareDays != null ? (days - compareDays) + "���" : "-");
+        return cap;
+    }
+
+
 }
+

--
Gitblit v1.8.0