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.mapper.CityAqiMonthlyMapper;
|
import com.moral.api.pojo.dto.cityAQI.CityPollutionLevel;
|
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.PieChartOfPollutionLevelVO;
|
import com.moral.api.service.CityAqiDailyService;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
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.*;
|
|
/**
|
* <p>
|
* 城市aqi日数据表 服务实现类
|
* </p>
|
*
|
* @author moral
|
* @since 2021-11-01
|
*/
|
@Service
|
public class CityAqiDailyServiceImpl extends ServiceImpl<CityAqiDailyMapper, CityAqiDaily> implements CityAqiDailyService {
|
|
@Autowired
|
CityAqiDailyMapper cityAqiDailyMapper;
|
@Autowired
|
SysAreaService sysAreaService;
|
@Autowired
|
SpecialCitiesProperties specialCitiesProperties;
|
@Autowired
|
BulletinProperties bulletinProperties;
|
@Autowired
|
CityAqiMonthlyService cityAqiMonthlyService;
|
@Autowired
|
CityAqiYearlyService cityAqiYearlyService;
|
|
@Override
|
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);
|
List<CityAqiDaily> cityAqiDailies = cityAqiDailyMapper.selectList(wrapper);
|
//取开始结束时间,拼装返回time
|
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<>();
|
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);
|
}
|
//计算比例
|
List<Map<String, Object>> valueMap = new ArrayList<>();
|
Set<Map.Entry<String, Integer>> entries = pollutionDaysMap.entrySet();
|
Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
|
Integer totalDays = 0;
|
while (iterator.hasNext()) {
|
Map.Entry<String, Integer> entry = iterator.next();
|
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 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;
|
}
|
//封装返回对象
|
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<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);
|
//查询年度数据
|
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);
|
}
|
|
|
}
|
