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/CityAqiServiceImpl.java | 1447 +++++++++++++++++++++++++++++++++++++++++++++++++-------
1 files changed, 1,249 insertions(+), 198 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 466b0c5..2f04c25 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
@@ -1,35 +1,41 @@
package com.moral.api.service.impl;
+import com.alibaba.excel.util.StringUtils;
import com.alibaba.fastjson.JSON;
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.plugins.pagination.Page;
+import com.moral.api.config.properties.SpecialCitiesProperties;
+import com.moral.api.dto.CityAqiDailyListDTO;
+import com.moral.api.entity.*;
+import com.moral.api.mapper.*;
+import com.moral.api.pojo.dto.cityAQI.CityPollutionLevel;
+import com.moral.api.pojo.dto.cityAQI.ConcentrationAndPercent;
+import com.moral.api.pojo.form.aqi.AirQualityComparisonForm;
+import com.moral.api.pojo.vo.cityAQI.AirQualityComparisonVO;
+import com.moral.api.pojo.vo.cityAQI.CityAreaRangeVO;
+import com.moral.api.service.*;
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.ComprehensiveIndexUtils;
import com.moral.util.DateUtils;
import com.moral.util.MathUtils;
+import org.apache.commons.collections4.CollectionUtils;
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.math.BigDecimal;
+import java.text.SimpleDateFormat;
import java.util.*;
+import java.util.stream.Collectors;
import java.util.stream.DoubleStream;
/**
@@ -45,6 +51,8 @@
@Autowired
private CityAqiMapper cityAqiMapper;
+ @Autowired
+ private CityAqiDailyMapper cityAqiDailyMapper;
@Autowired
private ForecastMapper forecastMapper;
@@ -53,13 +61,37 @@
private RedisTemplate redisTemplate;
@Autowired
- private OrganizationService organizationService;
-
- @Autowired
private SysAreaService sysAreaService;
@Autowired
private CityAqiDailyService cityAqiDailyService;
+
+ @Autowired
+ private CityAqiMonthlyService cityAqiMonthlyService;
+
+ @Autowired
+ private CityAqiYearlyService cityAqiYearlyService;
+
+ @Autowired
+ private SpecialCitiesProperties specialCitiesProperties;
+
+ @Autowired
+ private CityWeatherService cityWeatherService;
+
+ @Autowired
+ private OrganizationService organizationService;
+
+ @Autowired
+ private DeviceMapper deviceMapper;
+
+ @Autowired
+ private HistoryHourlyService historyHourlyService;
+
+ @Autowired
+ SpecialCitiesProperties citiesProperties;
+
+ @Autowired
+ private SysAreaMapper sysAreaMapper;
@Override
public List<Map<String, Object>> measuredCompareForecastOfO3(Map<String, Object> params) {
@@ -117,11 +149,54 @@
return result;
}
+
+ @Override
+ public List<Map<String, Object>> measuredCompareForecastOfO3_8H(Map<String, Object> params) {
+ String regionCode = params.get("regionCode").toString();
+ String time = params.get("time").toString();
+ Date endTime = DateUtils.getDate(time+" "+"23:00:00",DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
+ Date startDate = DateUtils.getDate(time+" "+"00:00:00",DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
+ Date startTime = DateUtils.addHours(startDate,-7);
+ //������������
+ QueryWrapper<Forecast> forecastQueryWrapper = new QueryWrapper<>();
+ forecastQueryWrapper.select("time", "value")
+ .eq("city_code", regionCode)
+ .between("time",startTime,endTime)
+ .orderByAsc("time");
+ List<Map<String, Object>> forecastData = forecastMapper.selectMaps(forecastQueryWrapper);
+ //������������
+ QueryWrapper<CityAqi> cityAqiQueryWrapper = new QueryWrapper<>();
+ cityAqiQueryWrapper.select("time", "value")
+ .eq("city_code", regionCode)
+ .between("time",startTime,endTime).orderByAsc("time");
+ List<Map<String, Object>> measuredData = cityAqiMapper.selectMaps(cityAqiQueryWrapper);
+
+ List<Map<String, Object>> result = getO3_8H(forecastData,0,time);
+ result.addAll(getO3_8H(measuredData,1,time));
+ return result;
+ }
+
+
@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)
value = queryCityAqiByRegionCodeFromDB(regionCode);
+ //������������������������������������������������������������
+ if (value == null) {
+ String regionCodeStr = String.valueOf(regionCode);
+ String end = regionCodeStr.substring(regionCodeStr.length() - 2, regionCodeStr.length());
+ if (!end.equals(00)) {
+ regionCodeStr = regionCodeStr.substring(0, regionCodeStr.length() - 2);
+ regionCodeStr += "00";
+ regionCode = Integer.parseInt(regionCodeStr);
+ value = (Map<String, Object>) redisTemplate.opsForHash().get(RedisConstants.CITY_AQI, String.valueOf(regionCode));
+ if (value == null)
+ value = queryCityAqiByRegionCodeFromDB(regionCode);
+ } else {
+ return null;
+ }
+ }
//������AQI������������������
if (value == null || value.get("AQI") == null)
return null;
@@ -134,50 +209,46 @@
@Override
public Map<String, Object> query24HoursAqiByRegionCode(Integer regionCode) {
//������������������������������������������������������
- QueryWrapper<CityAqi> lastDataWrapper = new QueryWrapper<>();
+ /*QueryWrapper<CityAqi> lastDataWrapper = new QueryWrapper<>();
lastDataWrapper.eq("city_code", regionCode);
lastDataWrapper.orderByDesc("time");
lastDataWrapper.last(true, "limit 1");
CityAqi cityAqi = cityAqiMapper.selectOne(lastDataWrapper);
+ if (cityAqi == null)
+ return null;
//���������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);
+ wrapper.eq("city_code", regionCode);*/
+ List<CityAqi> cityAqis = cityAqiMapper.listCity(regionCode);
//������������������24���������������
- if (cityAqis.size() != 24) {
- Map<Date, CityAqi> dateCityAqiMap = new HashMap<>();
- cityAqis.forEach(value -> dateCityAqiMap.put(value.getTime(), value));
+ if(CollectionUtils.isEmpty(cityAqis)){
+ return new HashMap<>();
+ }
+ Date startDate = cityAqis.get(0).getTime();
+ if(cityAqis.size()<24){
for (int i = 0; i < 24; i++) {
- Date date = DateUtils.addHours(startDate, i);
- CityAqi cityAqi1 = dateCityAqiMap.get(date);
- if (cityAqi1 == null) {
+ Date dateTime = DateUtils.addHours(startDate, i);
+ if(cityAqis.size()-1 <i){
CityAqi newCityAqi = new CityAqi();
- newCityAqi.setTime(date);
+ newCityAqi.setTime(dateTime);
+ newCityAqi.setValue("0");
cityAqis.add(newCityAqi);
+ continue;
}
}
- //������������������������
- cityAqis.sort(Comparator.comparing(CityAqi::getTime));
}
- //������������������,map���key���HH:mm������������������value���aqi���������
+ //������������������������
+ cityAqis.sort(Comparator.comparing(CityAqi::getTime));
+
+ //������������������,map���key���yyyy-MM-dd 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);
+ String key = DateUtils.dateToDateString(aqi.getTime(), "yyyy-MM-dd HH:mm");
+ result.put(key,aqi.getValue());
}
return result;
}
@@ -198,8 +269,8 @@
//������������aqi������������������
Map<String, Object> result = new HashMap<>();
AQI aqi = AQIUtils.hourlyAQI(sixParamAvg);
- result.put("aqi",aqi.getAQIValue());
- result.put("pollutant",aqi.getPrimaryPollutantNames());
+ 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");
@@ -207,21 +278,1116 @@
return result;
}
+ @Override
+ public List<Map<String, Object>> rankingDetails(Map<String, Object> params) {
+ List<Map<String, Object>> result = new ArrayList<>();
+ int regionCode = Integer.parseInt(params.get("regionCode").toString());
+ String type = params.get("type").toString();
+ String time = null;
+ if (!ObjectUtils.isEmpty(params.get("time"))) {
+ time = params.get("time").toString();
+ }
+ String start = null;
+ String end = null;
+ if (!ObjectUtils.isEmpty(params.get("start")) || !ObjectUtils.isEmpty(params.get("end"))) {
+ start = params.get("start").toString();
+ end = params.get("end").toString();
+ }
+ String cityType = params.get("cityType").toString();
+
+ String s = String.valueOf(regionCode);
+ //���������������,���code
+ Integer curProvinceCode = Integer.parseInt(s.substring(0, 2) + "0000");
+ Integer curCityCode = Integer.parseInt(s.substring(0, 4) + "00");
+
+ QueryWrapper<SysArea> areaWrapper = new QueryWrapper<>();
+
+ List<SysArea> sysAreas;
+ if ("28".equals(cityType)) {
+ //������2+26������
+ sysAreas = specialCitiesProperties.getTwentyEightCities();
+ } else {
+ if ("province".equals(cityType)) {
+ //���������������������
+ areaWrapper.select("area_code", "area_name").eq("parent_code", curProvinceCode);
+ } else {
+ //������������������������
+ areaWrapper.select("area_code", "area_name").eq("parent_code", curCityCode);
+ }
+ sysAreas = sysAreaService.list(areaWrapper);
+ }
+
+ switch (type) {
+ case "today":
+ result = accumulatedTodayRank(sysAreas);
+ break;
+ case "hour":
+ time = new StringBuilder(time).replace(10, 11, " ").toString() + ":00:00";
+ result = hourRank(sysAreas, time);
+ break;
+ case "day":
+ time = time + " 00:00:00";
+ result = dayRank(sysAreas, time);
+ break;
+ case "month":
+ time = time + "-01 00:00:00";
+ result = monthRank(sysAreas, time);
+ break;
+ case "year":
+ time = time + "-01-01 00:00:00";
+ result = yearRank(sysAreas, time);
+ break;
+ case "custom":
+ start = start + " 00:00:00";
+ end = end + " :00:00";
+ result = customRank(sysAreas, start, end);
+ break;
+ default:
+ break;
+ }
+ return result;
+ }
+
+ /**
+ * @param sysAreas ������������������������
+ * @return ���������������������������
+ */
+ private List<Map<String, Object>> accumulatedTodayRank(List<SysArea> sysAreas) {
+ List<Integer> regionCodes = sysAreas.stream()
+ .map(SysArea::getAreaCode)
+ .collect(Collectors.toList());
+
+ List<Map<String, Object>> result = new ArrayList<>();
+ List<String> sensors = Arrays.asList("PM2_5", "PM10", "SO2", "NO2", "CO", "O3");
+ Date now = new Date();
+ String today = DateUtils.dateToDateString(now, DateUtils.yyyy_MM_dd_EN);
+ QueryWrapper<CityAqi> wrapper = new QueryWrapper<>();
+ wrapper.select("city_code", "value")
+ .ge("time", today)
+ .in("city_code", regionCodes);
+ List<Map<String, Object>> cumulativeData = cityAqiMapper.selectMaps(wrapper);
+ //���city_code������
+ Map<Integer, List<Map<String, Object>>> data = cumulativeData.parallelStream().collect(Collectors.groupingBy(o -> Integer.parseInt(o.get("city_code").toString())));
+ data.forEach((cityCode, value) -> {
+ List<Double> doubles = new ArrayList<>();
+ for (Map<String, Object> objectMap : value) {
+ Object o = JSONObject.parseObject((String) objectMap.get("value"), Map.class).get("O3_8H");
+ if (!ObjectUtils.isEmpty(o)) {
+ double v = Double.parseDouble(o.toString());
+ doubles.add(v);
+ }
+ }
+
+ Map<String, Object> dataMap = new HashMap<>();
+ sensors.forEach(sensor -> {
+ OptionalDouble optionalDouble = value.parallelStream().flatMapToDouble(v -> {
+ Map<String, Object> sensorValue = JSONObject.parseObject((String) v.get("value"), Map.class);
+ Object o = sensorValue.get(sensor);
+ if (ObjectUtils.isEmpty(o)) {
+ return null;
+ }
+ double aDouble = Double.parseDouble(o.toString());
+ return DoubleStream.of(aDouble);
+ }).average();
+
+ if (optionalDouble.isPresent()) {
+ //���������������������
+ double sciCal = AmendUtils.sciCal(optionalDouble.getAsDouble(), 0);
+ if ("CO".equals(sensor)) {
+ sciCal = AmendUtils.sciCal(optionalDouble.getAsDouble(), 1);
+ }
+ dataMap.put(sensor, sciCal);
+ }
+ });
+
+ //������������O3_8H������,������������O3������8H���������
+ if (!ObjectUtils.isEmpty(doubles)) {
+ dataMap.put("O3_8H", Collections.max(doubles));
+ }
+
+ //������������aqi,���������������������
+ Map<String, Object> sixParamMap = new HashMap<>();
+ sixParamMap.put(Constants.SENSOR_CODE_PM25, dataMap.get("PM2_5"));
+ sixParamMap.put(Constants.SENSOR_CODE_PM10, dataMap.get("PM10"));
+ sixParamMap.put(Constants.SENSOR_CODE_SO2, dataMap.get("SO2"));
+ sixParamMap.put(Constants.SENSOR_CODE_NO2, dataMap.get("NO2"));
+ sixParamMap.put(Constants.SENSOR_CODE_CO, dataMap.get("CO"));
+ sixParamMap.put(Constants.SENSOR_CODE_O3, dataMap.get("O3"));
+ AQI aqi = AQIUtils.dailyAQI(sixParamMap);
+ dataMap.put("AQI", aqi.getAQIValue());
+ List<String> primaryPollutantNames = aqi.getPrimaryPollutantNames();
+ String primaryPollutant = "";
+ if (!ObjectUtils.isEmpty(primaryPollutantNames)) {
+ primaryPollutant = primaryPollutantNames.stream().map(String::valueOf).collect(Collectors.joining(","));
+ }
+ dataMap.put("primaryPollutant", primaryPollutant);
+
+ //������������������������������,O3������������O3_8H������
+ Map<String, Object> compositeIndexMap = new HashMap<>(dataMap);
+ compositeIndexMap.put("O3", compositeIndexMap.get("O3_8H"));
+ Double compositeIndex = ComprehensiveIndexUtils.dailyData(compositeIndexMap);
+ dataMap.put("compositeIndex", compositeIndex);
+
+ //���������
+ for (SysArea sysArea : sysAreas) {
+ if (cityCode.equals(sysArea.getAreaCode())) {
+ dataMap.put("cityName", sysArea.getAreaName());
+ break;
+ }
+ }
+ result.add(dataMap);
+ });
+ return result;
+ }
+
+ /**
+ * @param sysAreas ������������������������
+ * @param time ��������������������������� 2021-11-04 13:00:00
+ * @return ���������������������
+ */
+ private List<Map<String, Object>> hourRank(List<SysArea> sysAreas, String time) {
+ List<Integer> regionCodes = sysAreas.stream()
+ .map(SysArea::getAreaCode)
+ .collect(Collectors.toList());
+
+ List<Map<String, Object>> result = new ArrayList<>();
+ QueryWrapper<CityAqi> wrapper = new QueryWrapper<>();
+ wrapper.select("value")
+ .eq("time", time)
+ .in("city_code", regionCodes);
+ List<Map<String, Object>> hourData = cityAqiMapper.selectMaps(wrapper);
+ for (Map<String, Object> hourDatum : hourData) {
+ Map<String, Object> value = JSONObject.parseObject((String) hourDatum.get("value"), Map.class);
+ List<String> primaryPollutantNames = (List<String>) value.get("primaryPollutant");
+ String primaryPollutant = "";
+ if (!ObjectUtils.isEmpty(primaryPollutantNames)) {
+ primaryPollutant = primaryPollutantNames.stream().map(String::valueOf).collect(Collectors.joining(","));
+ }
+ value.put("primaryPollutant", primaryPollutant);
+ value.remove("pubtime");
+ value.remove("rank");
+ result.add(value);
+ }
+ return result;
+ }
+
+ /**
+ * @param sysAreas ������������������������
+ * @param time ��������������������������� 2021-11-04 00:00:00
+ * @return ������������������
+ */
+ private List<Map<String, Object>> dayRank(List<SysArea> sysAreas, String time) {
+ List<Integer> regionCodes = sysAreas.stream()
+ .map(SysArea::getAreaCode)
+ .collect(Collectors.toList());
+
+ List<Map<String, Object>> result = new ArrayList<>();
+ QueryWrapper<CityAqiDaily> wrapper = new QueryWrapper<>();
+ wrapper.select("city_code", "value")
+ .eq("time", time)
+ .in("city_code", regionCodes);
+ List<CityAqiDaily> dayData = cityAqiDailyService.list(wrapper);
+ for (CityAqiDaily cityAqiDaily : dayData) {
+ Map<String, Object> resultMap = JSONObject.parseObject(cityAqiDaily.getValue(), Map.class);
+ resultMap.put("O3_8H", resultMap.remove("O3"));
+ List<String> primaryPollutantNames = (List<String>) resultMap.get("primaryPollutant");
+ String primaryPollutant = "";
+ if (!ObjectUtils.isEmpty(primaryPollutantNames)) {
+ primaryPollutant = primaryPollutantNames.stream().map(String::valueOf).collect(Collectors.joining(","));
+ }
+ resultMap.put("primaryPollutant", primaryPollutant);
+
+
+ //���������
+ for (SysArea sysArea : sysAreas) {
+ if (cityAqiDaily.getCityCode().equals(sysArea.getAreaCode())) {
+ resultMap.put("cityName", sysArea.getAreaName());
+ break;
+ }
+ }
+ result.add(resultMap);
+ }
+ return result;
+ }
+
+ /**
+ * @param sysAreas ������������������������
+ * @param time ��������������������������� 2021-11-01 00:00:00
+ * @return ������������������
+ */
+ private List<Map<String, Object>> monthRank(List<SysArea> sysAreas, String time) {
+ List<Integer> regionCodes = sysAreas.stream()
+ .map(SysArea::getAreaCode)
+ .collect(Collectors.toList());
+
+ List<Map<String, Object>> result = new ArrayList<>();
+ QueryWrapper<CityAqiMonthly> cityAqiMonthlyQueryWrapper = new QueryWrapper<>();
+ cityAqiMonthlyQueryWrapper.select("city_code", "value")
+ .eq("time", time)
+ .in("city_code", regionCodes);
+ List<CityAqiMonthly> list = cityAqiMonthlyService.list(cityAqiMonthlyQueryWrapper);
+ for (CityAqiMonthly cityAqiMonthly : list) {
+ Map<String, Object> resultMap = JSONObject.parseObject(cityAqiMonthly.getValue(), Map.class);
+ resultMap.put("O3_8H", resultMap.remove("O3"));
+ //���������
+ for (SysArea sysArea : sysAreas) {
+ if (cityAqiMonthly.getCityCode().equals(sysArea.getAreaCode())) {
+ resultMap.put("cityName", sysArea.getAreaName());
+ break;
+ }
+ }
+ result.add(resultMap);
+ }
+ return result;
+ }
+
+ /**
+ * @param sysAreas ������������������������
+ * @param time ��������������������������� 2021-11-01 00:00:00 ������1���1���
+ * @return ������������������
+ */
+ private List<Map<String, Object>> yearRank(List<SysArea> sysAreas, String time) {
+ List<Integer> regionCodes = sysAreas.stream()
+ .map(SysArea::getAreaCode)
+ .collect(Collectors.toList());
+
+ List<Map<String, Object>> result = new ArrayList<>();
+ QueryWrapper<CityAqiYearly> cityAqiYearlyQueryWrapper = new QueryWrapper<>();
+ cityAqiYearlyQueryWrapper.select("city_code", "value")
+ .in("city_code", regionCodes)
+ .eq("time", time);
+ List<CityAqiYearly> list = cityAqiYearlyService.list(cityAqiYearlyQueryWrapper);
+ for (CityAqiYearly cityAqiYearly : list) {
+ Map<String, Object> resultMap = JSONObject.parseObject(cityAqiYearly.getValue(), Map.class);
+ resultMap.put("O3_8H", resultMap.remove("O3"));
+ for (SysArea sysArea : sysAreas) {
+ if (cityAqiYearly.getCityCode().equals(sysArea.getAreaCode())) {
+ resultMap.put("cityName", sysArea.getAreaName());
+ break;
+ }
+ }
+ result.add(resultMap);
+ }
+ return result;
+ }
+
+ /**
+ * @param sysAreas ������������������������
+ * @param start ���������������������������������,���������������2021-11-03 00:00:00
+ * @param end ���������������������������������,���������������2021-11-25 00:00:00
+ * @return ������������������������
+ */
+ private List<Map<String, Object>> customRank(List<SysArea> sysAreas, String start, String end) {
+ List<Integer> regionCodes = sysAreas.stream()
+ .map(SysArea::getAreaCode)
+ .collect(Collectors.toList());
+
+ //���������������������������
+ List<String> sensors = Arrays.asList("PM2_5", "PM10", "SO2", "NO2");
+ List<Map<String, Object>> result = new ArrayList<>();
+ QueryWrapper<CityAqiDaily> cityAqiDailyQueryWrapper = new QueryWrapper<>();
+ cityAqiDailyQueryWrapper.select("city_code", "value")
+ .ge("time", start)
+ .le("time", end)
+ .in("city_code", regionCodes);
+ List<Map<String, Object>> thisMonthData = cityAqiDailyService.listMaps(cityAqiDailyQueryWrapper);
+ //���city_code������
+ Map<Integer, List<Map<String, Object>>> customMap = thisMonthData.parallelStream()
+ .collect(Collectors.groupingBy(o -> Integer.parseInt(o.get("city_code").toString())));
+ customMap.forEach((cityCode, value) -> {
+ Map<String, Object> resultMap = new HashMap<>();
+
+ Map<String, Object> params = new HashMap<>();
+ List<Map<String, Object>> temp = new ArrayList<>();
+ for (Map<String, Object> map : value) {
+ Map<String, Object> sensorsValue = JSONObject.parseObject(map.get("value").toString(), Map.class);
+ Map<String, Object> tempMap = new HashMap<>();
+ tempMap.put(Constants.SENSOR_CODE_CO, sensorsValue.get("CO"));
+ tempMap.put(Constants.SENSOR_CODE_O3, sensorsValue.get("O3"));
+ Map<String, Object> hashMap = new HashMap<>();
+ hashMap.put("value", JSONObject.toJSONString(tempMap));
+ temp.add(hashMap);
+ }
+ params.put("data", temp);
+ //1. CO 95������������������������
+ Map<String, Object> coAvgOfWeekOrMonth = AmendUtils.getCOAvgOfWeekOrMonth(params);
+ if (!ObjectUtils.isEmpty(coAvgOfWeekOrMonth)) {
+ resultMap.put("CO", coAvgOfWeekOrMonth.get(Constants.SENSOR_CODE_CO));
+ }
+
+ //2. O3 90������������������������
+ Map<String, Object> o3AvgOfWeekOrMonth = AmendUtils.getO3AvgOfWeekOrMonth(params);
+ if (!ObjectUtils.isEmpty(o3AvgOfWeekOrMonth)) {
+ resultMap.put("O3", o3AvgOfWeekOrMonth.get(Constants.SENSOR_CODE_O3));
+ }
+
+ sensors.forEach(sensor -> {
+ OptionalDouble optionalDouble = value.parallelStream().flatMapToDouble(v -> {
+ Map<String, Object> sensorValue = JSONObject.parseObject((String) v.get("value"), Map.class);
+ Object o = sensorValue.get(sensor);
+ if (ObjectUtils.isEmpty(o)) {
+ return null;
+ }
+ double aDouble = Double.parseDouble(o.toString());
+ return DoubleStream.of(aDouble);
+ }).average();
+
+ if (optionalDouble.isPresent()) {
+ //���������������������
+ double sciCal = AmendUtils.sciCal(optionalDouble.getAsDouble(), 0);
+ resultMap.put(sensor, sciCal);
+ }
+ });
+
+ //���������������������
+ Double compositeIndex = ComprehensiveIndexUtils.dailyData(resultMap);
+ resultMap.put("compositeIndex", compositeIndex);
+
+ //������O3���O3_8H������
+ resultMap.put("O3_8H", resultMap.remove("O3"));
+
+ //���������
+ for (SysArea sysArea : sysAreas) {
+ if (cityCode.equals(sysArea.getAreaCode())) {
+ resultMap.put("cityName", sysArea.getAreaName());
+ break;
+ }
+ }
+ result.add(resultMap);
+ });
+ return result;
+ }
+
+
+ /**
+ * @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.orderByDesc("time");
+ wrapper.last(true, "limit 1");
+ CityAqi cityAqi = cityAqiMapper.selectOne(wrapper);
+ if (cityAqi == null)
+ return null;
+ String value = cityAqi.getValue();
+ redisTemplate.opsForHash().put(RedisConstants.CITY_AQI, regionCode, value);
+ return JSON.parseObject(value, Map.class);
+ }
+
+ @Override
+ public Map<String, Object> provincialRanking(Integer regionCode) {
+ //���������
+ 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_EN);
+
+ String s = String.valueOf(regionCode);
+ //���������,���code
+ Integer provinceCode = Integer.parseInt(s.substring(0, 2) + "0000");
+ Integer cityCode = Integer.parseInt(s.substring(0, 4) + "00");
+ Map<String,Object> params = new HashMap<>();
+ params.put("cityCode",provinceCode);
+ params.put("start",dateString);
+ params.put("end",dateString);
+ params.put("type",1);
+ List<CityAqiDailyListDTO> dayList = cityAqiDailyMapper.CityAqiDailyMap(params);
+ String start = DateUtils.dateToDateString(DateUtils.addMonths(DateUtils.getFirstDayOfLastMonth(), 1));
+ params.put("start",start);
+ params.put("type",2);
+ List<CityAqiDailyListDTO> monList = cityAqiDailyMapper.CityAqiDailyMap(params);
+ start =DateUtils.dateToDateString(now, DateUtils.yyyy);
+ params.put("start",start);
+ params.put("end",start);
+ params.put("type",3);
+ List<CityAqiDailyListDTO> yearList = cityAqiDailyMapper.CityAqiDailyMap(params);
+ int indexDay = dayList.stream().map(CityAqiDailyListDTO::getCityCode).collect(Collectors.toList()).indexOf(cityCode.toString());
+ int indexMon = monList.stream().map(CityAqiDailyListDTO::getCityCode).collect(Collectors.toList()).indexOf(cityCode.toString());
+ int indexYear = yearList.stream().map(CityAqiDailyListDTO::getCityCode).collect(Collectors.toList()).indexOf(cityCode.toString());
+ result.put("day",mapResult(dayList,indexDay));
+ result.put("month",mapResult(monList,indexMon));
+ result.put("year",mapResult(yearList,indexYear));
+ /* //������������������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");
+ 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 Map<String,Object> mapResult(List<CityAqiDailyListDTO> list, int length){
+ Map<String,Object> map = new HashMap<>();
+ map.put("AQI",CollectionUtils.isNotEmpty(list)&&length>0&&Objects.nonNull(list.get(length-1))?list.get(length-1).getAqi():0);
+ map.put("rank",CollectionUtils.isNotEmpty(list)&&length>0?length:0);
+ map.put("size",CollectionUtils.isNotEmpty(list)&&length>0?list.size():0);
+ return map;
+ }
+
+ @Override
+ public List<AirQualityComparisonVO> queryAirQualityComparison(AirQualityComparisonForm form) {
+ //������
+ Integer regionCode = form.getRegionCode();
+ String regionType = form.getRegionType();
+ Date startDate = form.getStartDate();
+ Date endDate = form.getEndDate();
+ Date comparisonStartDate = form.getComparisonStartDate();
+ Date comparisonEndDate = form.getComparisonEndDate();
+ String dateType = form.getDateType();
+ //������������/������
+ List<SysArea> areas = getSysAreasByRegionType(regionType, regionCode);
+ if (ObjectUtils.isEmpty(areas))
+ return null;
+ List<AirQualityComparisonVO> vos = new ArrayList<>();
+ for (SysArea area : areas) {
+ //������������������������������������6������������������
+ Map<String, Object> data = getDataByTimeTypeAndRegionCode(dateType, startDate, endDate, area.getAreaCode());
+ Map<String, Object> comparisonData = getDataByTimeTypeAndRegionCode(dateType, comparisonStartDate, comparisonEndDate, area.getAreaCode());
+ if (ObjectUtils.isEmpty(data) || ObjectUtils.isEmpty(comparisonData))
+ continue;
+ //���������������������������������������
+ CityPollutionLevel days = cityAqiDailyService.calculateDaysByTimeAndSysArea(area, startDate, endDate);
+ CityPollutionLevel comparisonDays = cityAqiDailyService.calculateDaysByTimeAndSysArea(area, comparisonStartDate, comparisonEndDate);
+ int fineDays = days.getExcellentWeatherDays() + days.getGoodWeatherDays();
+ int serverDays = days.getSeriousWeatherDays() + days.getServerWeatherDays();
+ int comparisonFineDays = comparisonDays.getExcellentWeatherDays() + comparisonDays.getGoodWeatherDays();
+ int comparisonServerDays = comparisonDays.getSeriousWeatherDays() + comparisonDays.getServerWeatherDays();
+ //������6������������������
+ Map<String, ConcentrationAndPercent> sixParamAndComIndexResult = contrastSixParamAndComIndex(data, comparisonData);
+ //������������������������������������������
+ ConcentrationAndPercent fine = contrastDays(fineDays, comparisonFineDays);
+ ConcentrationAndPercent server = contrastDays(serverDays, comparisonServerDays);
+ //������������������
+ AirQualityComparisonVO vo = new AirQualityComparisonVO();
+ vo.setFineDays(fine);
+ vo.setServerDays(server);
+ vo.setCO(sixParamAndComIndexResult.get("CO"));
+ vo.setO3(sixParamAndComIndexResult.get("O3"));
+ vo.setPM25(sixParamAndComIndexResult.get("PM2_5"));
+ vo.setPM10(sixParamAndComIndexResult.get("PM10"));
+ vo.setSO2(sixParamAndComIndexResult.get("SO2"));
+ vo.setNO2(sixParamAndComIndexResult.get("NO2"));
+ vo.setCompositeIndex(sixParamAndComIndexResult.get("compositeIndex"));
+ vo.setCityName(area.getAreaName());
+ vos.add(vo);
+ }
+ return vos;
+ }
+
+ //������������
+ @Override
+ public Map<String, Object> momData(Integer regionCode, Integer size, Integer current, Integer orgId) {
+ Map<String,Object> result = new HashMap<>();
+ Page<CityAqi> page = new Page<>(current, size);
+ Page<CityAqi> pageNext = new Page<>(current+1, size);
+ QueryWrapper<CityAqi> cityAqiQueryWrapper = new QueryWrapper<>();
+ cityAqiQueryWrapper.eq("city_code",regionCode);
+ Integer count = cityAqiMapper.selectCount(cityAqiQueryWrapper);
+ if (count==0){
+ return result;
+ }
+ cityAqiQueryWrapper.orderByDesc("time");
+ Page<CityAqi> resultPage = cityAqiMapper.selectPage(page, cityAqiQueryWrapper);
+ List<CityAqi> cityAqiList = resultPage.getRecords();
+ Page<CityAqi> resultPageNext = cityAqiMapper.selectPage(pageNext, cityAqiQueryWrapper);
+ List<CityAqi> cityAqiListNext = resultPageNext.getRecords();
+ List<Map<String,Object>> resultList = new ArrayList<>();
+ if (cityAqiList.size()==0){
+ return result;
+ }
+ for (int i=0; i<cityAqiList.size(); i++) {
+ Map<String,Object> resultMap = new HashMap<>();
+ String hour = cityAqiList.get(i).getTime().toString().substring(11,13);
+ String previousHour = null;
+ Date previousTtime = null;
+ Double PM2_5 = null;
+ Double PM10 = null;
+ Double O3 = null;
+ Integer AQI = null;
+ String AQIIndex = null;
+ Double TVOC = null;
+ Double previousPM2_5 = null;
+ Double previousPM10 = null;
+ Double previousO3 = null;
+ String PM2_5_change = null;
+ String PM10_change = null;
+ String O3_change = null;
+ String value = cityAqiList.get(i).getValue();
+ if (!ObjectUtils.isEmpty(value)){
+ 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("O3"))){
+ O3 = Double.parseDouble(jsonObject.get("O3").toString());
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("AQI"))){
+ AQI = Integer.parseInt(jsonObject.get("AQI").toString());
+ AQIIndex = AQIUtils.classCodeOfPollutionByAqi(AQI);
+ }
+ }
+ if (i<cityAqiList.size()-1){
+ previousHour = cityAqiList.get(i+1).getTime().toString().substring(11,13);
+ previousTtime = cityAqiList.get(i+1).getTime();
+ String previousValue = cityAqiList.get(i+1).getValue();
+ if (!ObjectUtils.isEmpty(previousValue)){
+ JSONObject jsonObject = JSONObject.parseObject(previousValue);
+ if (!ObjectUtils.isEmpty(jsonObject.get("PM2_5"))){
+ previousPM2_5 = Double.parseDouble(jsonObject.get("PM2_5").toString());
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("PM10"))){
+ previousPM10 = Double.parseDouble(jsonObject.get("PM10").toString());
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("O3"))){
+ previousO3 = Double.parseDouble(jsonObject.get("O3").toString());
+ }
+ }
+ }else if (cityAqiListNext.size()>0){
+ previousHour = cityAqiListNext.get(0).getTime().toString().substring(11,13);
+ previousTtime = cityAqiListNext.get(0).getTime();
+ String previousValue = cityAqiListNext.get(0).getValue();
+ if (!ObjectUtils.isEmpty(previousValue)){
+ JSONObject jsonObject = JSONObject.parseObject(previousValue);
+ if (!ObjectUtils.isEmpty(jsonObject.get("PM2_5"))){
+ previousPM2_5 = Double.parseDouble(jsonObject.get("PM2_5").toString());
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("PM10"))){
+ previousPM10 = Double.parseDouble(jsonObject.get("PM10").toString());
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("O3"))){
+ previousO3 = Double.parseDouble(jsonObject.get("O3").toString());
+ }
+ }
+ }else {
+ continue;
+ }
+ if (!ObjectUtils.isEmpty(PM2_5) && !ObjectUtils.isEmpty(previousPM2_5)){
+ Double difference_PM2_5 = PM2_5-previousPM2_5;
+ if (difference_PM2_5==0){
+ PM2_5_change = "������";
+ }
+ if (difference_PM2_5>0){
+ PM2_5_change = "������"+difference_PM2_5;
+ }
+ if (difference_PM2_5<0){
+ PM2_5_change = "������"+Math.abs(difference_PM2_5);
+ }
+ }
+ if (!ObjectUtils.isEmpty(PM10) && !ObjectUtils.isEmpty(previousPM10)){
+ Double difference_PM10 = PM10-previousPM10;
+ if (difference_PM10==0){
+ PM10_change = "������";
+ }
+ if (difference_PM10>0){
+ PM10_change = "������"+difference_PM10;
+ }
+ if (difference_PM10<0){
+ PM10_change = "������"+Math.abs(difference_PM10);
+ }
+ }
+ if (!ObjectUtils.isEmpty(O3) && !ObjectUtils.isEmpty(previousO3)){
+ Double difference_O3 = O3-previousO3;
+ if (difference_O3==0){
+ O3_change = "������";
+ }
+ if (difference_O3>0){
+ O3_change = "������"+difference_O3;
+ }
+ if (difference_O3<0){
+ O3_change = "������"+Math.abs(difference_O3);
+ }
+ }
+ //���������������������������������id
+ List<Integer> allOrgId = new ArrayList<>();
+ allOrgId.add(orgId);
+ //������������
+ //���������������
+ List<Organization> allChildrenOrganization = organizationService.getChildrenOrganizationsById(orgId);
+ if (!ObjectUtils.isEmpty(allChildrenOrganization) || allChildrenOrganization.size() < 1){
+ for (Organization organization:allChildrenOrganization) {
+ allOrgId.add(organization.getId());
+ }
+ }
+ //������������
+ List<Integer> allOrgIdWithoutDuplicates = allOrgId.stream().distinct().collect(Collectors.toList());
+ //������������list���������������Mac
+ List<String> deviceMacList = new ArrayList<>();
+ for (Integer orgIdWithoutDuplicates:allOrgIdWithoutDuplicates) {
+ //������id������������������
+ QueryWrapper<Device> wrapper_device = new QueryWrapper<>();
+ wrapper_device.eq("is_delete",Constants.NOT_DELETE).eq("organization_id",orgIdWithoutDuplicates);
+ List<Device> devices = new ArrayList<>();
+ devices = deviceMapper.selectList(wrapper_device);
+ if (devices.size()>0){
+ for (Device device:devices) {
+ String deviceMac = device.getMac();
+ deviceMacList.add(deviceMac);
+ }
+ }else {
+ continue;
+ }
+ }
+ //������������
+ SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+ String time = df.format(cityAqiList.get(i).getTime());
+ if (deviceMacList.size()>0){
+ List<HistoryHourly> valueByMacs = historyHourlyService.getValueByMacs(deviceMacList, time);
+ if (valueByMacs.size()>0){
+ for (HistoryHourly historyHourly:valueByMacs) {
+ String value_historyHourly = historyHourly.getValue();
+ if (!ObjectUtils.isEmpty(value_historyHourly)){
+ JSONObject jsonObject = JSONObject.parseObject(value_historyHourly);
+ if (!ObjectUtils.isEmpty(jsonObject.get("a99054"))){
+ TVOC = Double.parseDouble(jsonObject.get("a99054").toString());
+ }
+ }
+ }
+ }
+ }
+ resultMap.put("time",time.substring(0,13));
+ resultMap.put("title","���"+hour+"������������������");
+ String PM2_5_string = subZeroAndDot(PM2_5.toString());
+ String PM10_string = subZeroAndDot(PM10.toString());
+ String O3_string = subZeroAndDot(O3.toString());
+ String PM2_5_change_string = subZeroAndDot(PM2_5_change.toString());
+ String PM10_change_string = subZeroAndDot(PM10_change.toString());
+ String O3_change_string = subZeroAndDot(O3_change.toString());
+ resultMap.put("info",hour+"������������AQI���"+AQI+"������������"+AQIIndex+"������"+previousHour+"������������PM10���"+PM10_string+"������/������������"+PM10_change_string+"���PM2.5���"+PM2_5_string+"������/������������"+PM2_5_change_string+"���TVOC���������"+String.format("%.2f", TVOC)+"������/������������O3���"+O3_string+"������/������������"+O3_change_string+"���");
+ QueryWrapper<CityWeather> cityWeatherQueryWrapper = new QueryWrapper<>();
+ cityWeatherQueryWrapper.eq("city_code",regionCode);
+ cityWeatherQueryWrapper.eq("time",cityAqiList.get(i).getTime());
+ CityWeather cityWeather = cityWeatherService.getOne(cityWeatherQueryWrapper);
+ Integer temp = null;
+ Integer humidity = null;
+ String windDir = "";
+ Integer windScale = null;
+ if (!ObjectUtils.isEmpty(cityWeather)){
+ String cityWeatherValue = cityWeather.getValue();
+ if (!ObjectUtils.isEmpty(cityWeatherValue)){
+ JSONObject jsonObject = JSONObject.parseObject(cityWeatherValue);
+ if (!ObjectUtils.isEmpty(jsonObject.get("temp"))){
+ temp = Integer.parseInt(jsonObject.get("temp").toString());
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("humidity"))){
+ humidity = Integer.parseInt(jsonObject.get("humidity").toString());
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("windDir"))){
+ windDir = jsonObject.get("windDir").toString();
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("windScale"))){
+ windScale = Integer.parseInt(jsonObject.get("windScale").toString());
+ }
+ }
+ }
+ String temp_string = "";
+ if (temp!=null){
+ temp_string = temp.toString();
+ }
+ String humidity_string = "";
+ if (humidity!=null){
+ humidity_string = humidity.toString();
+ }
+ String windScale_string = "";
+ if (windScale!=null){
+ windScale_string = windScale.toString();
+ }
+ resultMap.put("weatherCondition","���������������������������"+temp_string+"������������"+humidity_string+"%,"+windDir+windScale_string+"������");
+ resultMap.put("auther","���������������������������");
+ resultList.add(resultMap);
+ }
+ Integer totel = count-1;
+ result.put("totel",totel);
+ result.put("resultList",resultList);
+ result.put("current",current);
+ int totalPageNumber = totel/size;
+ if(totel%size != 0){
+ totalPageNumber += 1;
+ }
+ result.put("totalPageNumber",totalPageNumber);
+ return result;
+ }
+
+ @Override
+ public Map<String, Object> countyData(Integer regionCode) {
+ Map<String,Object> resultMap = new HashMap<>();
+ //������������
+ SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH");
+ Calendar calendar = Calendar.getInstance();
+ int minute = calendar.get(Calendar.MINUTE);
+ if (minute >= 45){
+ calendar.set(Calendar.HOUR_OF_DAY,calendar.get(Calendar.HOUR_OF_DAY)-1);
+ }else {
+ calendar.set(Calendar.HOUR_OF_DAY,calendar.get(Calendar.HOUR_OF_DAY)-2);
+ }
+ String time = df.format(calendar.getTime())+":00:00";
+ QueryWrapper<CityAqi> cityAqiQueryWrapper = new QueryWrapper<>();
+ cityAqiQueryWrapper.likeRight("city_code",regionCode.toString().substring(0,4));
+ cityAqiQueryWrapper.ne("city_code",regionCode);
+ cityAqiQueryWrapper.eq("time",time);
+ List<CityAqi> cityAqis = cityAqiMapper.selectList(cityAqiQueryWrapper);
+ QueryWrapper<SysArea> sysAreaQueryWrapper = new QueryWrapper<>();
+ sysAreaQueryWrapper.eq("parent_code",regionCode);
+ List<SysArea> sysAreas = sysAreaMapper.selectList(sysAreaQueryWrapper);
+ Map<Integer, Object> sysAreaMap = new HashMap<>();
+ for (SysArea sysarea:sysAreas) {
+ sysAreaMap.put(sysarea.getAreaCode(),sysarea.getAreaName());
+ }
+ List<Map<String,Object>> resultList = new ArrayList<>();
+ for (CityAqi cityAqi:cityAqis) {
+ if (!ObjectUtils.isEmpty(cityAqi.getValue())){
+ Map<String, Object> cityAqiMap = new HashMap<>();
+ String cityAqiValue = cityAqi.getValue();
+ JSONObject jsonObject = JSONObject.parseObject(cityAqiValue);
+ String AQI = "--";
+ String PM10 = "--";
+ String PM2_5 = "--";
+ String SO2 = "--";
+ String NO2 = "--";
+ String CO = "--";
+ String O3 = "--";
+ String thirty = "--";
+ String forty = "--";
+ String fifty = "--";
+ String city_name = "--";
+ if (!ObjectUtils.isEmpty(jsonObject.get("AQI"))){
+ AQI = jsonObject.get("AQI").toString();
+ BigDecimal AQI_base = BigDecimal.valueOf(Double.parseDouble(AQI));
+ BigDecimal thirty_percent = BigDecimal.valueOf(1.3);
+ BigDecimal forty_percent = BigDecimal.valueOf(1.4);
+ BigDecimal fifty_percent = BigDecimal.valueOf(1.5);
+ Double AQI_thirty = AQI_base.multiply(thirty_percent).doubleValue();
+ Double AQI_forty = AQI_base.multiply(forty_percent).doubleValue();
+ Double AQI_fifty = AQI_base.multiply(fifty_percent).doubleValue();
+ thirty = String.valueOf(Math.round(AQI_thirty));
+ forty = String.valueOf(Math.round(AQI_forty));
+ fifty = String.valueOf(Math.round(AQI_fifty));
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("PM10"))){
+ PM10 = String.valueOf(Math.round(Double.parseDouble(jsonObject.get("PM10").toString())));
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("PM2_5"))){
+ PM2_5 = String.valueOf(Math.round(Double.parseDouble(jsonObject.get("PM2_5").toString())));
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("SO2"))){
+ SO2 = String.valueOf(Math.round(Double.parseDouble(jsonObject.get("SO2").toString())));
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("NO2"))){
+ NO2 = String.valueOf(Math.round(Double.parseDouble(jsonObject.get("NO2").toString())));
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("CO"))){
+ CO = String.valueOf(Math.round(Double.parseDouble(jsonObject.get("CO").toString())));
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("O3"))){
+ O3 = String.valueOf(Math.round(Double.parseDouble(jsonObject.get("O3").toString())));
+ }
+ if (!ObjectUtils.isEmpty(jsonObject.get("cityName"))){
+ city_name = jsonObject.get("cityName").toString();
+ }
+ cityAqiMap.put("AQI",AQI);
+ cityAqiMap.put("PM10",PM10);
+ cityAqiMap.put("PM2_5",PM2_5);
+ cityAqiMap.put("SO2",SO2);
+ cityAqiMap.put("NO2",NO2);
+ cityAqiMap.put("CO",CO);
+ cityAqiMap.put("O3",O3);
+ cityAqiMap.put("thirty",thirty);
+ cityAqiMap.put("forty",forty);
+ cityAqiMap.put("fifty",fifty);
+ cityAqiMap.put("city_name",city_name);
+ resultList.add(cityAqiMap);
+ }
+ sysAreaMap.remove(cityAqi.getCityCode());
+ }
+ if (sysAreaMap.size()>0){
+ for(Integer key:sysAreaMap.keySet()){
+ Map<String,Object> nullMap = new HashMap<>();
+ nullMap.put("AQI","--");
+ nullMap.put("PM10","--");
+ nullMap.put("PM2_5","--");
+ nullMap.put("SO2","--");
+ nullMap.put("NO2","--");
+ nullMap.put("CO","--");
+ nullMap.put("O3","--");
+ nullMap.put("thirty","--");
+ nullMap.put("forty","--");
+ nullMap.put("fifty","--");
+ nullMap.put("city_name",sysAreaMap.get(key));
+ resultList.add(nullMap);
+ }
+ }
+ resultMap.put("resultList",resultList);
+ resultMap.put("time",time);
+ QueryWrapper<SysArea> areaQueryWrapper = new QueryWrapper<>();
+ areaQueryWrapper.eq("area_code",regionCode);
+ SysArea sysArea = sysAreaMapper.selectOne(areaQueryWrapper);
+ resultMap.put("areaName",sysArea.getAreaName());
+ return resultMap;
+ }
+
+ /**
+ * @Description: ������6������������������������������������
+ * @Param: [data, comparisonData]
+ * @return: java.util.Map<java.lang.String, com.moral.api.pojo.dto.cityAQI.ConcentrationAndPercent>
+ * @Author: ���������
+ * @Date: 2022/1/17
+ */
+ private Map<String, ConcentrationAndPercent> contrastSixParamAndComIndex(Map<String, Object> data, Map<String, Object> comparisonData) {
+ Map<String, ConcentrationAndPercent> result = new HashMap<>();
+ result.put("CO", contrastParam(Double.parseDouble(data.get("CO").toString()), Double.parseDouble(comparisonData.get("CO").toString()), "CO"));
+ result.put("NO2", contrastParam(Double.parseDouble(data.get("NO2").toString()), Double.parseDouble(comparisonData.get("NO2").toString()), "NO2"));
+ result.put("SO2", contrastParam(Double.parseDouble(data.get("SO2").toString()), Double.parseDouble(comparisonData.get("SO2").toString()), "SO2"));
+ result.put("O3", contrastParam(Double.parseDouble(data.get("O3").toString()), Double.parseDouble(comparisonData.get("O3").toString()), "O3"));
+ result.put("PM2_5", contrastParam(Double.parseDouble(data.get("PM2_5").toString()), Double.parseDouble(comparisonData.get("PM2_5").toString()), "PM2_5"));
+ result.put("PM10", contrastParam(Double.parseDouble(data.get("PM10").toString()), Double.parseDouble(comparisonData.get("PM10").toString()), "PM10"));
+ result.put("compositeIndex", contrastParam(Double.parseDouble(data.get("compositeIndex").toString()), Double.parseDouble(comparisonData.get("compositeIndex").toString()), "compositeIndex"));
+ return result;
+ }
+
+ /**
+ * @Description: ������6������������������������/���������������������
+ * @Param: [data, comparisonData]
+ * @return: com.moral.api.pojo.dto.cityAQI.ConcentrationAndPercent
+ * @Author: ���������
+ * @Date: 2022/1/17
+ */
+ private ConcentrationAndPercent contrastParam(Double data, Double comparisonData, String sensor) {
+ double percentD = MathUtils.division(data - comparisonData, comparisonData, 4);
+ String percent = MathUtils.mul(percentD,100d) + "%";
+ ConcentrationAndPercent concentrationAndPercent = new ConcentrationAndPercent();
+ concentrationAndPercent.setPercent(percent);
+ if (sensor.equals("CO")) {//CO���������������������
+ Double CO = AmendUtils.sciCal(data, 1);
+ concentrationAndPercent.setConcentration(CO.toString());
+ }else if (sensor.equals("compositeIndex")){
+ concentrationAndPercent.setConcentration(data.toString());
+ }else{
+ Double sensorD = AmendUtils.sciCal(data, 0);
+ Integer sensorI = new Double(sensorD).intValue();
+ concentrationAndPercent.setConcentration(sensorI.toString());
+ }
+ return concentrationAndPercent;
+ }
+
+ /**
+ * @Description: ���������������������������������
+ * @Param: [days, comparisonDays]
+ * @return: com.moral.api.pojo.dto.cityAQI.ConcentrationAndPercent
+ * @Author: ���������
+ * @Date: 2022/1/17
+ */
+ private ConcentrationAndPercent contrastDays(Integer days, Integer comparisonDays) {
+ ConcentrationAndPercent concentrationAndPercent = new ConcentrationAndPercent();
+ concentrationAndPercent.setConcentration(days.toString());
+ Integer result = days - comparisonDays;
+ concentrationAndPercent.setPercent(result.toString() + "���");
+ return concentrationAndPercent;
+ }
+
+ /**
+ * @Description: ���������������������������������6������������������������������������������������������������������������
+ * @Param: [comparisonType, startDate, endDate, regionCode]
+ * @return: java.util.Map<java.lang.String , java.lang.Object>
+ * @Author: ���������
+ * @Date: 2022/1/17
+ */
+ private Map<String, Object> getDataByTimeTypeAndRegionCode(String TimeType, Date startDate, Date endDate, Integer regionCode) {
+ Map<String, Object> data;
+ if (Constants.MONTH.equals(TimeType) && (!DateUtils.isCurrentMonth(startDate) || !DateUtils.isCurrentYear(startDate))) {//��������������� ���������������
+ List<CityAqiMonthly> cityAqis = cityAqiMonthlyService.getCityAqiMonthByRegionCodeAndTime(regionCode, startDate, endDate);
+ if (ObjectUtils.isEmpty(cityAqis))
+ return null;
+ data = JSON.parseObject(cityAqis.get(0).getValue(), Map.class);
+ } else if (Constants.YEAR.equals(TimeType) && (!DateUtils.isCurrentYear(startDate))) {//��������������� ���������������
+ List<CityAqiYearly> cityAqis = cityAqiYearlyService.getCityAqiYearlyByRegionCodeAndTime(regionCode, startDate, endDate);
+ if (ObjectUtils.isEmpty(cityAqis))
+ return null;
+ data = JSON.parseObject(cityAqis.get(0).getValue(), Map.class);
+ } else {//���������������������
+ List<CityAqiDaily> cityAqis = cityAqiDailyService.getCityAqiDailyByRegionCodeAndTime(regionCode, startDate, endDate);
+ if (ObjectUtils.isEmpty(cityAqis))
+ return null;
+ List<CityAqi> newCityAqis = new ArrayList<>();
+ List<Map<String, Object>> dailyDataMaps = new ArrayList<>();
+ cityAqis.forEach((value) -> {
+ newCityAqis.add(new CityAqi(value));
+ dailyDataMaps.add(JSON.parseObject(value.getValue(), Map.class));
+ });
+ //������������
+ data = calculate6ParamAvg(newCityAqis);
+ //���������������
+ data.put("CO", Double.parseDouble(data.remove(Constants.SENSOR_CODE_CO).toString()));
+ data.put("NO2", Double.parseDouble(data.remove(Constants.SENSOR_CODE_NO2).toString()));
+ data.put("SO2", Double.parseDouble(data.remove(Constants.SENSOR_CODE_SO2).toString()));
+ data.put("O3", Double.parseDouble(data.remove(Constants.SENSOR_CODE_O3).toString()));
+ data.put("PM2_5", Double.parseDouble(data.remove(Constants.SENSOR_CODE_PM25).toString()));
+ data.put("PM10", Double.parseDouble(data.remove(Constants.SENSOR_CODE_PM10).toString()));
+ //������������������
+ Double compositeIndex = ComprehensiveIndexUtils.dailyData(data);
+ data.put("compositeIndex", compositeIndex);
+ }
+ return data;
+ }
+
+
+ //������������������
+ 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;
+ }
+
+ /**
+ * @Description: ���������������������������������������������������������
+ * @Param: [regionType, regionCode]
+ * @return: java.util.List<com.moral.api.entity.SysArea>
+ * @Author: ���������
+ * @Date: 2022/1/14
+ */
+ private List<SysArea> getSysAreasByRegionType(String regionType, Integer regionCode) {
+ List<SysArea> areas;
+ if (regionType.equals(Constants.TWENTY_EIGHT_CITIES)) {
+ areas = citiesProperties.getTwentyEightCities();
+ } else {
+ areas = sysAreaService.getChildren(regionCode);
+ }
+ return areas;
+ }
+
/**
* @Description: ������6������������
* @Param: [cityAqiList]
- * @return: java.util.Map<java.lang.String, java.lang.Double>
+ * @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");
+ 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);
@@ -262,166 +1428,51 @@
}
/**
- * @Description: ������������������������
- * @Param: [regionCode]
- * @return: java.util.Map<java.lang.String, java.lang.Object>
- * @Author: ���������
- * @Date: 2021/10/28
+ * ������java������������������������������.���0
+ * @param s
+ * @return
*/
- private Map<String, Object> queryCityAqiByRegionCodeFromDB(Integer regionCode) {
- QueryWrapper<CityAqi> wrapper = new QueryWrapper();
- wrapper.eq("city_code", regionCode);
- wrapper.orderByDesc("time");
- wrapper.last(true, "limit 1");
- CityAqi cityAqi = cityAqiMapper.selectOne(wrapper);
- if (cityAqi == null)
- return null;
- String value = cityAqi.getValue();
- redisTemplate.opsForHash().put(RedisConstants.CITY_AQI, regionCode, value);
- return JSON.parseObject(value, Map.class);
+ public static String subZeroAndDot(String s){
+ if(s.indexOf(".") > 0){
+ s = s.replaceAll("0+?$", "");//���������������0
+ s = s.replaceAll("[.]$", "");//������������������.���������
+ }
+ return s;
}
- @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"));
+ public List<Map<String, Object>> getO3_8H(List<Map<String, Object>> data , int type,String day) {
+ List<Map<String, Object>> list = new ArrayList<>();
+ for(int i = 0 ;i<=23;i++){
+ Map<String, Object> map = new HashMap<>();
+ if(type == 0){
+ map.put("type","������");
+ }else {
+ map.put("type","������");
}
+ String times = day+" "+i;
+ Date endDate = DateUtils.getDate(times,DateUtils.yyyy_MM_dd_HH_EN);
+ Date startDate = DateUtils.addHours(DateUtils.getDate(day+" "+i,DateUtils.yyyy_MM_dd_HH_EN),-7);
+ List<Double> value = new ArrayList<>();
+ for(Map<String, Object> m : data){
+ Date time = (Date) m.get("time");
+ if(DateUtils.isTimeBeforE(time,startDate) && DateUtils.isTimeBeforE(endDate,time)){
+ Map<String, Object> sensorValue = JSONObject.parseObject((String) m.get("value"), Map.class);
+ Double o3 = Double.parseDouble(sensorValue.get("O3").toString());
+ value.add(o3);
-
- //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);
+ if (value.size() < 6) {
+ continue;
}
- ranks.add(rankMap);
+ double average = value.stream().mapToDouble(aDouble -> aDouble).summaryStatistics().getAverage();
+ map.put("O3", new BigDecimal(average).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue());
+ map.put("time",times);
+ list.add(map);
}
- //���������������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);
+ return list;
- //������������������������������
- 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