From 2ad979f912a1883c7a46048fa371d213f8406ba9 Mon Sep 17 00:00:00 2001
From: jinpengyong <jpy123456>
Date: Mon, 08 Nov 2021 11:26:22 +0800
Subject: [PATCH] update
---
screen-api/src/main/java/com/moral/api/service/impl/CityAqiServiceImpl.java | 336 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 313 insertions(+), 23 deletions(-)
diff --git a/screen-api/src/main/java/com/moral/api/service/impl/CityAqiServiceImpl.java b/screen-api/src/main/java/com/moral/api/service/impl/CityAqiServiceImpl.java
index 1bde34d..357a1df 100644
--- a/screen-api/src/main/java/com/moral/api/service/impl/CityAqiServiceImpl.java
+++ b/screen-api/src/main/java/com/moral/api/service/impl/CityAqiServiceImpl.java
@@ -4,25 +4,33 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.moral.api.entity.CityAqi;
+import com.moral.api.entity.CityAqiDaily;
import com.moral.api.entity.Forecast;
+import com.moral.api.entity.Organization;
+import com.moral.api.entity.SysArea;
import com.moral.api.mapper.CityAqiMapper;
import com.moral.api.mapper.ForecastMapper;
+import com.moral.api.service.CityAqiDailyService;
import com.moral.api.service.CityAqiService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.moral.api.service.OrganizationService;
+import com.moral.api.service.SysAreaService;
+import com.moral.constant.Constants;
import com.moral.constant.RedisConstants;
+import com.moral.pojo.AQI;
import com.moral.util.AQIUtils;
+import com.moral.util.AmendUtils;
import com.moral.util.DateUtils;
+
+import com.moral.util.MathUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.DoubleStream;
/**
* <p>
@@ -43,6 +51,15 @@
@Autowired
private RedisTemplate redisTemplate;
+
+ @Autowired
+ private OrganizationService organizationService;
+
+ @Autowired
+ private SysAreaService sysAreaService;
+
+ @Autowired
+ private CityAqiDailyService cityAqiDailyService;
@Override
public List<Map<String, Object>> measuredCompareForecastOfO3(Map<String, Object> params) {
@@ -72,7 +89,7 @@
Date date = (Date) forecastDatum.get("time");
String value = forecastDatum.get("value").toString();
Map<String, Object> data = JSONObject.parseObject(value, Map.class);
- Object o3 = data.get("o3");
+ Object o3 = data.get("O3");
if (i == DateUtils.getHour(date) * 2) {
if (!ObjectUtils.isEmpty(o3)) {
map.put("O3", o3);
@@ -87,7 +104,7 @@
Date date = (Date) measuredDatum.get("time");
String value = measuredDatum.get("value").toString();
Map<String, Object> data = JSONObject.parseObject(value, Map.class);
- Object o3 = data.get("o3");
+ Object o3 = data.get("O3");
if (i == (DateUtils.getHour(date) * 2 + 1)) {
if (!ObjectUtils.isEmpty(o3)) {
map.put("O3", o3);
@@ -102,35 +119,308 @@
@Override
public Map<String, Object> queryCityAqiByRegionCode(Integer regionCode) {
- Map<String,Object> value = (Map<String, Object>) redisTemplate.opsForHash().get(RedisConstants.CITY_AQI,String.valueOf(regionCode));
- if(value==null)
+ Map<String, Object> value = (Map<String, Object>) redisTemplate.opsForHash().get(RedisConstants.CITY_AQI, String.valueOf(regionCode));
+ if (value == null)
value = queryCityAqiByRegionCodeFromDB(regionCode);
//������AQI������������������
- if(value==null||value.get("aqi")==null)
+ if (value == null || value.get("AQI") == null)
return null;
- Integer aqi = Integer.parseInt(value.get("aqi").toString());
+ Integer aqi = Integer.parseInt(value.get("AQI").toString());
String category = AQIUtils.classOfPollutionByAqi(aqi);
- value.put("category",category);
+ value.put("category", category);
return value;
}
+ @Override
+ public Map<String, Object> query24HoursAqiByRegionCode(Integer regionCode) {
+ //������������������������������������������������������
+ QueryWrapper<CityAqi> lastDataWrapper = new QueryWrapper<>();
+ lastDataWrapper.eq("city_code", regionCode);
+ lastDataWrapper.orderByDesc("time");
+ lastDataWrapper.last(true, "limit 1");
+ CityAqi cityAqi = cityAqiMapper.selectOne(lastDataWrapper);
+ //���������24������������������
+ Date endDate = cityAqi.getTime();
+ Date startDate = DateUtils.addHours(endDate, -23);
+ //������������
+ QueryWrapper<CityAqi> wrapper = new QueryWrapper<>();
+ wrapper.between("time", startDate, endDate);
+ wrapper.eq("city_code", regionCode);
+ List<CityAqi> cityAqis = cityAqiMapper.selectList(wrapper);
+ //������������������24���������������
+ if (cityAqis.size() != 24) {
+ Map<Date, CityAqi> dateCityAqiMap = new HashMap<>();
+ cityAqis.forEach(value -> dateCityAqiMap.put(value.getTime(), value));
+ for (int i = 0; i < 24; i++) {
+ Date date = DateUtils.addHours(startDate, i);
+ CityAqi cityAqi1 = dateCityAqiMap.get(date);
+ if (cityAqi1 == null) {
+ CityAqi newCityAqi = new CityAqi();
+ newCityAqi.setTime(date);
+ cityAqis.add(newCityAqi);
+ }
+ }
+ //������������������������
+ cityAqis.sort(Comparator.comparing(CityAqi::getTime));
+ }
+ //������������������,map���key���HH:mm������������������value���aqi���������
+ Map<String, Object> result = new LinkedHashMap<>();
+ for (CityAqi aqi : cityAqis) {
+ String key = DateUtils.dateToDateString(aqi.getTime(), "HH:mm");
+ String allDataJson = aqi.getValue();
+ if (allDataJson == null) {
+ result.put(key, "");
+ continue;
+ }
+ Map<String, Object> allDataMap = JSON.parseObject(allDataJson, Map.class);
+ Object aqiData = allDataMap.get("AQI");
+ if (aqiData == null)
+ result.put(key, "");
+ else
+ result.put(key, aqiData);
+ }
+ return result;
+ }
+
+ @Override
+ public Map<String, Object> queryTodayAqiAndPollutant(Integer regionCode) {
+ //���������������9���������
+ Date startDate = new Date(DateUtils.getTodayTime());
+ Date endDate = new Date();
+ //������������������
+ QueryWrapper<CityAqi> wrapper = new QueryWrapper<>();
+ wrapper.between("time", startDate, endDate);
+ wrapper.eq("city_code", regionCode);
+ wrapper.select("DISTINCT city_code,time,value");
+ List<CityAqi> cityAqis = cityAqiMapper.selectList(wrapper);
+ //���������������
+ Map<String, Object> sixParamAvg = calculate6ParamAvg(cityAqis);
+ //������������aqi������������������
+ Map<String, Object> result = new HashMap<>();
+ AQI aqi = AQIUtils.hourlyAQI(sixParamAvg);
+ result.put("aqi",aqi.getAQIValue());
+ result.put("pollutant",aqi.getPrimaryPollutantNames());
+ //���������������������
+ CityAqi lastCityAqi = cityAqis.get(cityAqis.size() - 1);
+ String time = DateUtils.dateToDateString(lastCityAqi.getTime(), "HH:mm");
+ result.put("time", time);
+ return result;
+ }
+
/**
- * @Description: ������������������������
- * @Param: [regionCode]
- * @return: java.util.Map<java.lang.String,java.lang.Object>
- * @Author: ���������
- * @Date: 2021/10/28
- */
+ * @Description: ������6������������
+ * @Param: [cityAqiList]
+ * @return: java.util.Map<java.lang.String, java.lang.Double>
+ * ���������key���sensorCode,value������
+ * @Author: ���������
+ * @Date: 2021/11/2
+ */
+ private Map<String, Object> calculate6ParamAvg(List<CityAqi> cityAqiList) {
+ Double co = calculateSensorAvg(cityAqiList, "CO");
+ Double pm2_5 = calculateSensorAvg(cityAqiList, "PM2_5");
+ Double pm10 = calculateSensorAvg(cityAqiList, "PM10");
+ Double so2 = calculateSensorAvg(cityAqiList, "SO2");
+ Double no2 = calculateSensorAvg(cityAqiList, "NO2");
+ Double o3 = calculateSensorAvg(cityAqiList, "O3");
+ Map<String, Object> result = new HashMap<>();
+ result.put(Constants.SENSOR_CODE_CO, co);
+ result.put(Constants.SENSOR_CODE_NO2, no2);
+ result.put(Constants.SENSOR_CODE_SO2, so2);
+ result.put(Constants.SENSOR_CODE_O3, o3);
+ result.put(Constants.SENSOR_CODE_PM25, pm2_5);
+ result.put(Constants.SENSOR_CODE_PM10, pm10);
+ return result;
+ }
+
+ /**
+ * @Description: ������������������������
+ * @Param: [cityAqiList, sensor]
+ * ���sensor���������������������������
+ * @return: java.lang.Double
+ * @Author: ���������
+ * @Date: 2021/11/2
+ */
+ private Double calculateSensorAvg(List<CityAqi> cityAqiList, String sensor) {
+ Double sum = 0d;
+ int num = 0;
+ for (CityAqi cityAqi : cityAqiList) {
+ String value = cityAqi.getValue();
+ if (value == null)
+ continue;
+ Map<String, Object> valueMap = JSON.parseObject(value, Map.class);
+ Object sensorValueObject = valueMap.get(sensor);
+ if (sensorValueObject == null)
+ continue;
+ Double sensorValue = Double.valueOf(sensorValueObject.toString());
+ sum = MathUtils.add(sum, sensorValue);
+ num++;
+ }
+ if (num == 0)
+ return null;
+ Double avg = MathUtils.division(sum, num, 2);
+ return avg;
+ }
+
+ /**
+ * @Description: ������������������������
+ * @Param: [regionCode]
+ * @return: java.util.Map<java.lang.String, java.lang.Object>
+ * @Author: ���������
+ * @Date: 2021/10/28
+ */
private Map<String, Object> queryCityAqiByRegionCodeFromDB(Integer regionCode) {
QueryWrapper<CityAqi> wrapper = new QueryWrapper();
- wrapper.eq("city_code",regionCode);
+ wrapper.eq("city_code", regionCode);
wrapper.orderByDesc("time");
- wrapper.last(true,"limit 1");
+ wrapper.last(true, "limit 1");
CityAqi cityAqi = cityAqiMapper.selectOne(wrapper);
- if(cityAqi==null)
+ if (cityAqi == null)
return null;
String value = cityAqi.getValue();
- redisTemplate.opsForHash().put(RedisConstants.CITY_AQI,regionCode,value);
- return JSON.parseObject(value,Map.class);
+ redisTemplate.opsForHash().put(RedisConstants.CITY_AQI, regionCode, value);
+ return JSON.parseObject(value, Map.class);
}
+
+ @Override
+ public Map<String, Object> provincialRanking(Integer organizationId) {
+ //���������
+ Map<String, Object> result = new HashMap<>();
+
+ Date now = new Date();
+ //������
+ Date yesterday = DateUtils.dataToTimeStampTime(DateUtils.getDateOfDay(now, -1), DateUtils.yyyy_MM_dd_EN);
+ String dateString = DateUtils.dateToDateString(yesterday, DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
+
+ //���������,���code
+ Organization organization = organizationService.getById(organizationId);
+ Integer provinceCode = organization.getProvinceCode();
+ Integer cityCode = organization.getCityCode();
+ //������������������city_code
+ QueryWrapper<SysArea> wrapper = new QueryWrapper<>();
+ wrapper.select("area_code").eq("parent_code", provinceCode);
+ List<Object> cityCodes = sysAreaService.listObjs(wrapper);
+
+ List<Map<String, Object>> ranks = new ArrayList<>();
+ for (Object code : cityCodes) {
+ Map<String, Object> rankMap = new HashMap<>();
+ rankMap.put("cityCode", code);
+ QueryWrapper<CityAqiDaily> queryWrapper = new QueryWrapper<>();
+ queryWrapper.select("value").eq("city_code", code).eq("time", dateString);
+
+ //1.������������
+ CityAqiDaily one = cityAqiDailyService.getOne(queryWrapper);
+ if (!ObjectUtils.isEmpty(one)) {
+ String value = one.getValue();
+ Map<String, Object> valueMap = JSONObject.parseObject(value, Map.class);
+ rankMap.put("AQI", valueMap.get("AQI"));
+ }
+
+ //2.������������������������������������������������
+ queryWrapper.clear();
+ //���������������������1���������������������������
+ Date start = DateUtils.addMonths(DateUtils.getFirstDayOfLastMonth(), 1);
+ queryWrapper.select("value").eq("city_code", code).ge("time", start).le("time", yesterday);
+ List<CityAqiDaily> listMonth = cityAqiDailyService.list(queryWrapper);
+ OptionalDouble averageMonth = listMonth.parallelStream().flatMapToDouble(v -> {
+ Map<String, Object> dataValue = JSONObject.parseObject(v.getValue(), Map.class);
+ Double compositeIndex = Double.parseDouble(dataValue.get("compositeIndex").toString());
+ return DoubleStream.of(compositeIndex);
+ }).average();
+ if (averageMonth.isPresent()) {
+ //���������������������
+ double compositeIndexAvgMonth = AmendUtils.sciCal(averageMonth.getAsDouble(), 2);
+ rankMap.put("compositeIndexMonth", compositeIndexAvgMonth);
+ }
+
+ //3.������������������������������������������������
+ queryWrapper.clear();
+ //���������������������1.1���������������������������
+ String yearStart = DateUtils.dateToDateString(now, DateUtils.yyyy);
+ queryWrapper.select("value").eq("city_code", code).ge("time", yearStart).le("time", yesterday);
+ List<CityAqiDaily> listYear = cityAqiDailyService.list(queryWrapper);
+ OptionalDouble averageYear = listYear.parallelStream().flatMapToDouble(v -> {
+ Map<String, Object> dataValue = JSONObject.parseObject(v.getValue(), Map.class);
+ Double compositeIndex = Double.parseDouble(dataValue.get("compositeIndex").toString());
+ return DoubleStream.of(compositeIndex);
+ }).average();
+ if (averageYear.isPresent()) {
+ //���������������������
+ double compositeIndexAvgYear = AmendUtils.sciCal(averageYear.getAsDouble(), 2);
+ rankMap.put("compositeIndexYear", compositeIndexAvgYear);
+ }
+ ranks.add(rankMap);
+ }
+
+ //���������������aqi������
+ ranks.removeIf(o -> o.get("AQI") == null);
+ sortByField(ranks, "AQI");
+ //���������������
+ Map<String, Object> dayMap = rankByField(ranks, cityCode, "AQI", cityCodes.size());
+ if (ObjectUtils.isEmpty(dayMap)) {
+ dayMap.put("rank", null);
+ dayMap.put("size", null);
+ }
+ dayMap.put("AQI", dayMap.remove("value"));
+ result.put("day", dayMap);
+
+ //������������������������������
+ ranks.removeIf(o -> o.get("compositeIndexMonth") == null);
+ sortByField(ranks, "compositeIndexMonth");
+ //���������������
+ Map<String, Object> monthMap = rankByField(ranks, cityCode, "compositeIndexMonth", cityCodes.size());
+ if (ObjectUtils.isEmpty(monthMap)) {
+ monthMap.put("rank", null);
+ monthMap.put("size", null);
+ }
+ monthMap.put("compositeIndex", monthMap.remove("value"));
+ result.put("month", monthMap);
+
+ //������������������������������
+ sortByField(ranks, "compositeIndexYear");
+ //���������������
+ sortByField(ranks, "compositeIndexYear");
+ Map<String, Object> yearMap = rankByField(ranks, cityCode, "compositeIndexYear", cityCodes.size());
+ if (ObjectUtils.isEmpty(yearMap)) {
+ yearMap.put("rank", null);
+ yearMap.put("size", null);
+ }
+ yearMap.put("compositeIndex", yearMap.remove("value"));
+ result.put("year", yearMap);
+
+ //���������������
+ result.put("time", DateUtils.dateToDateString(yesterday, DateUtils.yyyy_MM_dd_EN));
+ return result;
+ }
+
+ //������������������
+ private void sortByField(List<Map<String, Object>> list, String sortField) {
+ list.sort((o1, o2) -> {
+ double v1 = Double.parseDouble(o1.get(sortField).toString());
+ double v2 = Double.parseDouble(o2.get(sortField).toString());
+ if (v1 > v2) {
+ return -1;
+ } else if (v1 < v2) {
+ return 1;
+ }
+ return 0;
+ });
+ }
+
+ //������
+ private Map<String, Object> rankByField(List<Map<String, Object>> list, Integer cityCode, String rankField, Integer size) {
+ Map<String, Object> result = new HashMap<>();
+ for (int i = 0; i < list.size(); i++) {
+ Map<String, Object> map = list.get(i);
+ if (cityCode == (int) map.get("cityCode")) {
+ int rank = i + 1;
+ result.put("rank", rank);
+ result.put("size", size);
+ Object value = map.get(rankField);
+ result.put("value", value);
+ break;
+ }
+ }
+ return result;
+ }
+
}
--
Gitblit v1.8.0