package com.moral.service.impl;
|
|
import static com.moral.common.bean.Constants.NULL_VALUE;
|
import static org.springframework.util.ObjectUtils.isEmpty;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Calendar;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.Set;
|
import java.util.TreeSet;
|
import java.util.concurrent.Callable;
|
import java.util.concurrent.CompletionService;
|
import java.util.concurrent.ExecutorCompletionService;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.stream.Collectors;
|
|
import javax.annotation.Resource;
|
|
import com.moral.common.util.ReportTimeFormat;
|
import com.moral.entity.charts.DataCondition;
|
import com.moral.entity.charts.LineChartCriteria;
|
import com.moral.entity.charts.PairData;
|
import com.moral.entity.charts.TimePeriod;
|
import org.apache.commons.lang3.time.DateUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.ObjectUtils;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.TypeReference;
|
import com.moral.common.util.CalculateUtils;
|
import com.moral.common.util.ResourceUtil;
|
import com.moral.common.util.ValidateUtil;
|
import com.moral.entity.Device;
|
import com.moral.entity.Sensor;
|
import com.moral.mapper.DeviceMapper;
|
import com.moral.mapper.HistoryMinutelyMapper;
|
import com.moral.mapper.SensorMapper;
|
import com.moral.service.HistoryMinutelyService;
|
|
@Service
|
@SuppressWarnings({ "unchecked", "unused" })
|
public class HistoryMinutelyServiceImpl implements HistoryMinutelyService {
|
|
@Resource
|
private HistoryMinutelyMapper historyMinutelyMapper;
|
|
@Resource
|
private DeviceMapper deviceMapper;
|
|
@Resource
|
private SensorMapper sensorMapper;
|
|
// volatile
|
|
@Override
|
public Map<String, Object> getDayAQIByDevice(Map<String, Object> parameters) {
|
ValidateUtil.notNull(parameters.get("mac"), "param.is.null");
|
LocalDate localDate = LocalDate.now();
|
// 昨日00:00:00
|
parameters.put("start", localDate.minusDays(1));
|
|
// 今日00:00:00
|
parameters.put("end", localDate);
|
String[] macKeys = { "e1", "e2", "e10", "e11", "e15", "e16" };
|
parameters.put("sensorKeys", Arrays.asList(macKeys));
|
Map<String, Double> average = historyMinutelyMapper.getSersionAvgByDevice(parameters);
|
return getAQIByDataMap(average);
|
}
|
|
private Map<String, Object> getAQIByDataMap(Map<String, Double> average) {
|
Map<String, Object> resultMap = new HashMap<String, Object>();
|
if (isEmpty(average)) {
|
resultMap.put("AQI", "N/V");
|
} else {
|
String[] IAQIValues = ResourceUtil.getArrValue("IAQI");
|
Set<Double> IAQIs = new HashSet<Double>();
|
for (Map.Entry<String, Double> entry : average.entrySet()) {
|
double minMacKey = 0, maxMacKey = 0, minIAQI = 0, maxIAQI = 0;
|
String[] macKeyValues = ResourceUtil.getArrValue(entry.getKey());
|
Double avg = entry.getValue();
|
if (isEmpty(avg)) {
|
IAQIs.add(null);
|
} else {
|
int index = -1;
|
for (int i = 0; i < macKeyValues.length; i++) {
|
if (avg <= Double.valueOf(macKeyValues[i])) {
|
if (i == 0) {
|
index = i;
|
} else {
|
index = i - 1;
|
}
|
break;
|
}
|
}
|
if (index == -1) {
|
IAQIs.add(Double.MAX_VALUE);
|
} else {
|
minMacKey = Double.valueOf(macKeyValues[index]);
|
maxMacKey = Double.valueOf(macKeyValues[index + 1]);
|
minIAQI = Double.valueOf(IAQIValues[index]);
|
maxIAQI = Double.valueOf(IAQIValues[index + 1]);
|
Double result = CalculateUtils.calculateIAQI(maxIAQI, minIAQI, maxMacKey, minMacKey, avg);
|
IAQIs.add(result);
|
}
|
}
|
}
|
IAQIs.remove(null);
|
if (isEmpty(IAQIs)) {
|
resultMap.put("AQI", "N/V");
|
} else {
|
Double AQI = Collections.max(IAQIs);
|
if (AQI == Double.MAX_VALUE) {
|
resultMap.put("AQI", IAQIValues[IAQIValues.length - 1]);
|
} else {
|
resultMap.put("AQI", String.format("%.0f", AQI));
|
}
|
}
|
}
|
return resultMap;
|
}
|
|
@Override
|
public Map<String, List<Object>> getCompareReport(Map<String, Object> parameters) throws Exception {
|
Map<String, List<Object>> resultMap = new HashMap<String, List<Object>>();
|
List<Map<String, Object>> list = JSON.parseObject((String)parameters.remove("items"), new TypeReference<List<Map<String, Object>>>() {});
|
|
String type = (String) parameters.get("type");
|
parameters.putAll(getElementByType(type));
|
Integer timeLength = Integer.valueOf(parameters.remove("timeLength").toString());
|
if ("month".equals(type)) {
|
for (Map<String, Object> map : list) {
|
String[] formatTime = map.get("formatTime").toString().split("-");
|
LocalDate localDate = LocalDate.of(Integer.valueOf(formatTime[0]), Integer.valueOf(formatTime[1]), 1);
|
int lengthOfMonth = localDate.lengthOfMonth();
|
if (lengthOfMonth > timeLength) {
|
timeLength = lengthOfMonth;
|
}
|
}
|
}
|
|
List<Object> timeList = new ArrayList<Object>();
|
for (int i = 0; i < timeLength; i++) {
|
timeList.add(String.format("%02d", "day".equals(type) || "hour".equals(type) ? i : i + 1));
|
}
|
parameters.put("timeList", timeList);
|
|
ExecutorService threadPool = Executors.newCachedThreadPool();
|
CompletionService<Map<String, Object>> cs = new ExecutorCompletionService<Map<String, Object>>(threadPool);
|
for (int i = 0; i < list.size(); i++) {
|
Map<String, Object> map = list.get(i);
|
map.put("part", i);
|
if (ObjectUtils.isEmpty(map.get("mac"))) {
|
map.remove("mac");
|
}
|
map.put("time", map.remove("formatTime"));
|
map.putAll(parameters);
|
cs.submit(new Callable<Map<String, Object>>() {
|
@Override
|
public Map<String, Object> call() throws Exception {
|
return getMonitorPointOrDeviceAvgData4Compare(map);
|
}
|
});
|
}
|
|
List<Object> dataList = new ArrayList<Object>();
|
for (Map<String, Object> map : list) {
|
dataList.add(cs.take().get());
|
}
|
Object[] datas = new Object[list.size()];
|
Object[] deviceCounts = new Object[list.size()];
|
Set<String> sensors = new TreeSet<String>(new Comparator<String>() {
|
@Override
|
public int compare(String o1, String o2) {
|
return Integer.compare(Integer.valueOf(o1.split("-")[0].replace("e", "")), Integer.valueOf(o2.split("-")[0].replace("e", "")));
|
}
|
});
|
for (Object object : dataList) {
|
Map<String, Object> map = (Map<String, Object>)object;
|
for (String key : map.keySet()) {
|
if (key.startsWith("data")) {
|
int index = Integer.valueOf(key.replace("data", ""));
|
datas[index] = map.get(key);
|
}
|
if (key.startsWith("deviceCount")) {
|
int index = Integer.valueOf(key.replace("deviceCount", ""));
|
deviceCounts[index] = map.get(key);
|
}
|
if (key.startsWith("sensors")) {
|
sensors.addAll((List<String>) map.get(key));
|
}
|
}
|
}
|
resultMap.put("times", timeList);
|
resultMap.put("datas", Arrays.asList(datas));
|
resultMap.put("deviceCounts", Arrays.asList(deviceCounts));
|
resultMap.put("sensors", new ArrayList<Object>(sensors));
|
return resultMap;
|
}
|
|
|
public Map<String, Object> getMonitorPointOrDeviceAvgData4Compare(Map<String, Object> parameters) throws Exception {
|
Map<String, Object> resultMap = new HashMap<String, Object>();
|
List<Map<String, Object>> resultList = getMonitorPointOrDeviceAvgData(parameters);
|
List<Object> timeList = (List<Object>) parameters.get("timeList");
|
List<String> sensors = (List<String>) parameters.get("sensors");
|
String part = parameters.get("part").toString();
|
Map<String, Double[]> doubleMap = new LinkedHashMap<String, Double[]>();
|
for (Map<String, Object> map : resultList) {
|
String time = map.get("time").toString();
|
time = time.substring(time.length() - 2);
|
int index = timeList.indexOf(time);
|
for (String sensor : sensors) {
|
String[] split = sensor.split("-");
|
String sensorKey = split[0];
|
if (map.containsKey(sensorKey)) {
|
Double[] doubles;
|
if (doubleMap.containsKey(sensor)) {
|
doubles = doubleMap.get(sensor);
|
} else {
|
doubles = new Double[timeList.size()];
|
}
|
doubles[index] = (Double) map.get(sensorKey);
|
doubleMap.put(sensor, doubles);
|
}
|
}
|
}
|
|
Object deviceCount;
|
if (parameters.containsKey("deviceCount")) {
|
deviceCount = parameters.remove("deviceCount");
|
} else {
|
deviceCount = deviceMapper.getDeviceCountByRegion(parameters);
|
}
|
|
resultMap.put("deviceCount" + part, deviceCount);
|
resultMap.put("data" + part, doubleMap);
|
resultMap.put("sensors" + part, sensors);
|
return resultMap;
|
}
|
|
@Override
|
public List<Map<String, Object>> getMonitorPointOrDeviceAvgData(Map<String, Object> parameters) throws Exception {
|
String type = (String) parameters.get("type");
|
if (!parameters.containsKey("field")) {
|
parameters.putAll(getElementByType(type));
|
}
|
String time = (String) parameters.get("time");
|
String format = (String) parameters.get("format");
|
Integer field = Integer.valueOf(parameters.get("field").toString());
|
Date start = DateUtils.parseDate(time, format), end = null ;
|
if (parameters.containsKey("timeb")) {
|
end = DateUtils.parseDate((String)parameters.get("timeb"), format);
|
} else {
|
Calendar instance = Calendar.getInstance();
|
instance.setTime(start);
|
instance.add(field, 1);
|
end = instance.getTime();
|
}
|
parameters.put("start", start);
|
parameters.put("end", end);
|
|
List<String> sensorKeys = new ArrayList<String>();
|
List<String> sensors = new ArrayList<String>();
|
if (parameters.containsKey("sensors")) {
|
try {
|
sensors = JSON.parseObject((String)parameters.get("sensors"), new TypeReference<List<String>>() {});
|
for (String sensor : sensors) {
|
sensorKeys.add(sensor.split("-")[0]);
|
}
|
} catch (Exception e) {
|
sensorKeys = sensors = (List<String>)parameters.remove("sensors");
|
}
|
} else {
|
List<Sensor> sensorList = sensorMapper.getSensorsByCriteria(parameters);
|
for (Sensor sensor : sensorList) {
|
sensorKeys.add(sensor.getSensorKey());
|
sensors.add(sensor.getSensorKey() + "-" + sensor.getName() + "-" + sensor.getUnit());
|
}
|
}
|
parameters.put("sensorKeys", sensorKeys);
|
parameters.put("sensors", sensors);
|
|
return historyMinutelyMapper.getMonitorPointOrDeviceAvgData(parameters);
|
}
|
|
@Override
|
public Map<String, Object> getMonthAverageBySensor(Map<String, Object> parameters) {
|
ValidateUtil.notNull(parameters.get("mac"), "param.is.null");
|
ValidateUtil.notNull(parameters.get("macKey"), "param.is.null");
|
Map<String, Object> result = new HashMap<String, Object>();
|
LocalDate end = LocalDate.now(),start;
|
// 每月一日的数据取上月的数据
|
if (1 == end.getDayOfMonth()) {
|
// 上个月1日00:00:00
|
start = end.plusDays(-1).with(TemporalAdjusters.firstDayOfMonth());
|
} else {
|
// 这个月1日00:00:00
|
start = end.with(TemporalAdjusters.firstDayOfMonth());
|
}
|
parameters.put("start", start);
|
parameters.put("end", end);
|
String sensorKey = (String) parameters.remove("macKey");
|
List<String> sensorKeys = new ArrayList<String>();
|
sensorKeys.add(sensorKey);
|
parameters.put("sensorKeys", sensorKeys);
|
|
Map<String, Double> average = historyMinutelyMapper.getSersionAvgByDevice(parameters);
|
if (isEmpty(average)) {
|
result.put("average", NULL_VALUE);
|
} else {
|
result.put("average", String.format("%.2f", average.get(sensorKey)));
|
}
|
return result;
|
}
|
|
/**
|
* 根据线性表单的条件规则，获取多条线性表单数据
|
* @param lineChartCriteria
|
* @return
|
*/
|
@Override
|
public Map<String, List<List<Double>>> queryLineChartDateByCrieria(LineChartCriteria lineChartCriteria){
|
Map<String,List<List<Double>>> listMap = new HashMap<>();
|
List<String> sensorKeys = lineChartCriteria.getSensorKeys();
|
List<DataCondition> dataConditionList = lineChartCriteria.getDataConditions();
|
TimePeriod timePeriod = lineChartCriteria.getTimePeriod();
|
sensorKeys.forEach(sensorKey -> {
|
listMap.put(sensorKey,new ArrayList<List<Double>>(dataConditionList.size()));
|
});
|
dataConditionList.forEach(dataCondition -> {
|
Map<String,List<Double>> dataMap = queryOneLineChartDateByCrieria(sensorKeys,timePeriod,dataCondition);
|
// 数据装载
|
listMap.forEach( (sensorKey,list) -> {
|
List<Double> rowData = dataMap.get(sensorKey);
|
list.add(rowData);
|
});
|
});
|
return listMap;
|
}
|
|
/**
|
* 根据线性表单的条件规则，获取一条线性表单数据,包含 所有检测项目
|
* @param sensorKeys
|
* @param timePeriod
|
* @param dataCondition
|
* @return
|
*/
|
public Map<String,List<Double>> queryOneLineChartDateByCrieria(List<String> sensorKeys, TimePeriod timePeriod, DataCondition dataCondition){
|
List<String> timeList = ReportTimeFormat.makeTimeList(timePeriod);
|
List<Map<String,Object>> lineChartDatas = historyMinutelyMapper.selectLineChartDateByCrieria(sensorKeys,timePeriod,dataCondition);
|
Map<String,List<Double>> lineChartDatasWithEmpty = new HashMap<>();
|
// lineChartDatasWithEmpty 初始化
|
sensorKeys.forEach(sensorKey -> {
|
lineChartDatasWithEmpty.put(sensorKey,timeList.stream().map(time -> {
|
Double data = null;
|
return data;
|
}).collect(Collectors.toList()));
|
});
|
// m 为查询data的index，此处要防止m越界
|
int m = 0;
|
int dataLength = lineChartDatas.size()-1;
|
m = dataLength>-1?0:-1;
|
if(m >-1){
|
for(int n =0;n<timeList.size();n++){
|
if(m>-1) {
|
String time = timeList.get(n);
|
Map<String,Object> rowData = lineChartDatas.get(m);
|
String keyTime = rowData.get("format_time").toString();
|
if(time.equals(keyTime)){
|
// list to map
|
int finalN = n;
|
sensorKeys.forEach(sensorKey -> {
|
Object value = rowData.get(sensorKey);
|
List<Double> lineChartDatasWithEmptyTemp = lineChartDatasWithEmpty.get(sensorKey);
|
if(finalN < lineChartDatasWithEmptyTemp.size()){
|
Double sensorValue = value!= null?new Double(value.toString()):null;
|
lineChartDatasWithEmptyTemp.set(finalN,sensorValue);
|
}
|
});
|
// 置为 -1，防止越界
|
m = m<dataLength ? m+1 : -1;
|
}
|
}
|
}
|
}
|
return lineChartDatasWithEmpty;
|
}
|
|
private Map<String, Object> getElementByType(Object type){
|
Map<String, Object> resultMap = new HashMap<String, Object>();
|
switch (type.toString()) {
|
case "year":
|
resultMap.put("format", "yyyy");
|
resultMap.put("typeFormat", "%Y-%m");
|
resultMap.put("timeLength", 12);
|
resultMap.put("field", Calendar.YEAR);
|
break;
|
case "month":
|
resultMap.put("format", "yyyy-MM");
|
resultMap.put("typeFormat", "%Y-%m-%d");
|
resultMap.put("timeLength", 28);
|
resultMap.put("field", Calendar.MONTH);
|
break;
|
case "day":
|
resultMap.put("format", "yyyy-MM-dd");
|
resultMap.put("typeFormat", "%Y-%m-%d %H");
|
resultMap.put("timeLength", 24);
|
resultMap.put("field", Calendar.DATE);
|
break;
|
case "hour":
|
resultMap.put("format", "yyyy-MM-dd HH");
|
resultMap.put("typeFormat", "%Y-%m-%d %H:%i");
|
resultMap.put("timeLength", 60);
|
resultMap.put("field", Calendar.HOUR);
|
break;
|
}
|
return resultMap;
|
}
|
}
|
