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