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.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.concurrent.Callable;
|
import java.util.concurrent.CompletionService;
|
import java.util.concurrent.ExecutorCompletionService;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
|
import javax.annotation.Resource;
|
|
import org.apache.commons.lang3.time.DateUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.ObjectUtils;
|
|
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.mapper.DeviceMapper;
|
import com.moral.mapper.HistoryMinutelyMapper;
|
import com.moral.mapper.SensorMapper;
|
import com.moral.service.HistoryMinutelyService;
|
|
@Service
|
public class HistoryMinutelyServiceImpl implements HistoryMinutelyService {
|
|
@Resource
|
private HistoryMinutelyMapper historyMinutelyMapper;
|
|
@Resource
|
private DeviceMapper deviceMapper;
|
|
@Resource
|
private SensorMapper sensorMapper;
|
|
private Set<String> sensorKeys = new HashSet<String>();
|
|
@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" };
|
String sensorKeyColumn = "";
|
for (int i = 0; i < macKeys.length; i++) {
|
sensorKeyColumn += "AVG(json -> '$." + macKeys[i] + "[0]') " + macKeys[i];
|
if (i != macKeys.length -1) {
|
sensorKeyColumn += " ,";
|
}
|
}
|
parameters.put("sensorKeyColumn", sensorKeyColumn);
|
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;
|
}
|
|
public Map<String, List<Object>> getMonitorPointOrDeviceAvgData4Compare(Map<String, Object> parameters) throws Exception {
|
Map<String, List<Object>> resultMap = new HashMap<String, List<Object>>();
|
if (ObjectUtils.isEmpty(parameters)) {
|
resultMap.put("c", null);
|
return resultMap;
|
}
|
List<Map<String, Object>> resultList = getMonitorPointOrDeviceAvgData(parameters);
|
|
List<Object> timeList = new ArrayList<Object>();
|
List<Object> dataList = new ArrayList<Object>();
|
String sensorKey = (String) parameters.get("sensorKey");
|
for (Map<String, Object> map : resultList) {
|
String time = map.get("time").toString();
|
time =time.substring(time.length() - 2);
|
timeList.add(time);
|
dataList.add(map.get(sensorKey));
|
}
|
String part = (String) parameters.get("part");
|
resultMap.put("time" + part, timeList);
|
resultMap.put("data" + part, dataList);
|
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>>();
|
Map<String, Object> parametersA = new HashMap<String, Object>();
|
Map<String, Object> parametersB = new HashMap<String, Object>();
|
if (parameters.containsKey("time") && parameters.containsKey("monitorPoint")) {
|
parametersA.put("part", "A");
|
parametersA.putAll(parameters);
|
parametersA.remove("timeb");
|
}
|
if (parameters.containsKey("timeb") && parameters.containsKey("monitorPointb")) {
|
parametersB.putAll(parameters);
|
parametersB.put("part", "B");
|
parametersB.put("time", parametersB.get("timeb"));
|
parametersB.put("monitorPoint", parametersB.get("monitorPointb"));
|
if (parameters.containsKey("macb")) {
|
parametersB.put("mac", parametersB.get("macb"));
|
}
|
parametersB.remove("timeb");
|
}
|
List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
|
list.add(parametersA);
|
list.add(parametersB);
|
ExecutorService threadPool = Executors.newCachedThreadPool();
|
CompletionService<Map<String, List<Object>>> cs = new ExecutorCompletionService<Map<String, List<Object>>>(threadPool);
|
for (Map<String, Object> map : list) {
|
cs.submit(new Callable<Map<String, List<Object>>>() {
|
@Override
|
public Map<String, List<Object>> call() throws Exception {
|
return getMonitorPointOrDeviceAvgData4Compare(map);
|
}
|
});
|
|
}
|
for (Map<String, Object> map : list) {
|
resultMap.putAll(cs.take().get());
|
}
|
if (resultMap.containsKey("timeA") && resultMap.containsKey("timeB")) {
|
List<Object> timeA = resultMap.get("timeA");
|
List<Object> timeB = resultMap.get("timeB");
|
List<Object> time = new ArrayList<Object>(timeA);
|
List<Object> time1 = new ArrayList<Object>(timeB);
|
List<Object> dataA = resultMap.get("dataA");
|
List<Object> dataB = resultMap.get("dataB");
|
List<Object> resultA = new ArrayList<Object>();
|
List<Object> resultB = new ArrayList<Object>();
|
time1.removeAll(time);
|
time.addAll(time1);
|
time.sort(new Comparator<Object>() {
|
@Override
|
public int compare(Object o1, Object o2) {
|
return Integer.compare(Integer.valueOf(o1.toString()), Integer.valueOf(o2.toString()));
|
}
|
});
|
for (int i = 0; i < time.size(); i++) {
|
Object object = time.get(i);
|
int indexA = timeA.indexOf(object);
|
if (indexA > -1) {
|
resultA.add(i, dataA.get(indexA));
|
}else {
|
resultA.add("-");
|
}
|
int indexB = timeB.indexOf(object);
|
if (indexB > -1) {
|
resultB.add(i, dataB.get(indexB));
|
}else {
|
resultB.add("-");
|
}
|
}
|
resultMap.put("dataA", resultA);
|
resultMap.put("dataB", resultB);
|
resultMap.put("time", time);
|
} else if (resultMap.containsKey("timeA")) {
|
resultMap.put("time", resultMap.get("timeA"));
|
} else {
|
resultMap.put("time", resultMap.get("timeB"));
|
}
|
return resultMap;
|
}
|
|
|
@Override
|
public List<Map<String, Object>> getMonitorPointOrDeviceAvgData(Map<String, Object> parameters) throws Exception {
|
List<Map<String, Object>> resul ;
|
|
String type = (String) parameters.get("type");
|
String time = (String) parameters.get("time");
|
String format = (String) parameters.get("format");
|
Date start = DateUtils.parseDate(time, format), end = null ;
|
if (parameters.containsKey("timeb")) {
|
end = DateUtils.parseDate((String)parameters.get("timeb"), format);
|
} else {
|
switch (type) {
|
case "year":
|
end = DateUtils.addYears(start, 1);
|
break;
|
case "month":
|
end = DateUtils.addMonths(start, 1);
|
break;
|
case "day":
|
end = DateUtils.addDays(start, 1);
|
break;
|
case "hour":
|
end = DateUtils.addHours(start, 1);
|
break;
|
}
|
|
}
|
parameters.put("start", start);
|
parameters.put("end", end);
|
|
if (parameters.containsKey("sensorKey")) {
|
String sensorKey = (String) parameters.get("sensorKey");
|
String sensorKeyColumn = "AVG(json -> '$." + sensorKey + "[0]') " + sensorKey;
|
parameters.put("sensorKeyColumn", sensorKeyColumn);
|
}
|
|
sensorKeys.clear();
|
// 监控点平均值
|
if (!parameters.containsKey("mac")) {
|
resul = new ArrayList<Map<String,Object>>();
|
Integer monitorPointId = Integer.valueOf((String) parameters.get("monitorPoint"));
|
List<Map<String, Object>> deviceVersions = deviceMapper.getDeviceVersionIdByMonitorPoint(monitorPointId);
|
ExecutorService threadPool = Executors.newCachedThreadPool();
|
CompletionService<List<Map<String, Object>>> cs = new ExecutorCompletionService<List<Map<String, Object>>>(threadPool);
|
List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
|
for (Map<String, Object> map : deviceVersions) {
|
cs.submit(new Callable<List<Map<String, Object>>>() {
|
@Override
|
public List<Map<String, Object>> call() throws Exception {
|
Map<String, Object> parameter = new HashMap<String, Object>(parameters);
|
Integer deviceVersionId = (Integer) map.get("deviceVersionId");
|
if (!parameter.containsKey("sensorKeyColumn")) {
|
List<Map<String, Object>> sensors = sensorMapper.getSensorsByDeviceVersionId(deviceVersionId);
|
String sensorKeyColumn = getSensorKeyColumnBySensors(sensors);
|
parameter.put("sensorKeyColumn", sensorKeyColumn);
|
parameters.put("sensors", sensorKeys);
|
}
|
List<String> macs = deviceMapper.getDeviceMacByMonitorPointAndDeviceVersion(monitorPointId, deviceVersionId);
|
if (ObjectUtils.isEmpty(macs) || macs.contains("null") ) {
|
return new ArrayList<Map<String,Object>>();
|
}else {
|
parameter.put("macs", macs);
|
return historyMinutelyMapper.getMonitorPointOrDeviceAvgData(parameter);
|
}
|
}
|
});
|
}
|
for (Map<String, Object> map : deviceVersions) {
|
list.addAll(cs.take().get());
|
}
|
Map<String, Map<String, Number[]>> result = new LinkedHashMap<String, Map<String, Number[]>>();
|
for (Map<String, Object> map : list) {
|
time = (String) map.get("time");
|
map.remove("time");
|
Map<String, Number[]> times = new HashMap<String, Number[]>();
|
if (result.containsKey(time)) {
|
times = (Map<String, Number[]>) result.get(time);
|
}
|
for (Map.Entry<String,Object> entry : map.entrySet()) {
|
String sensorKey = entry.getKey();
|
Number[] doubles = new Number[3];
|
Double sum = (Double) entry.getValue();
|
Integer count = 1;
|
if (times.containsKey(sensorKey)) {
|
doubles = times.get(sensorKey);
|
sum = (Double) doubles[0] + sum;
|
count = (Integer) doubles[1] + 1;
|
}
|
doubles[0] = sum;
|
doubles[1] = count;
|
doubles[2] = new BigDecimal(sum / count).setScale(3, RoundingMode.HALF_UP).doubleValue();
|
times.put(sensorKey, doubles);
|
}
|
result.put(time, times);
|
}
|
Iterator<Entry<String, Map<String, Number[]>>> iterator = result.entrySet().iterator();
|
while(iterator.hasNext()){
|
Entry<String, Map<String, Number[]>> entry = iterator.next();
|
String resultTime = entry.getKey();
|
Map<String, Number[]> value = entry.getValue();
|
Map<String, Object> resultMap = new HashMap<String, Object>();
|
resultMap.put("time", resultTime);
|
for (String sensorKey : value.keySet()) {
|
resultMap.put(sensorKey, value.get(sensorKey)[2]);
|
}
|
resul.add(resultMap);
|
}
|
// 设备 平均值
|
} else {
|
// 所有传感器
|
if (!parameters.containsKey("sensorKeyColumn")) {
|
String mac = (String) parameters.get("mac");
|
Device device = new Device();
|
device.setMac(mac);
|
device = deviceMapper.selectOne(device);
|
List<Map<String, Object>> sensors = sensorMapper.getSensorsByDeviceVersionId(device.getDeviceVersionId());
|
String sensorKeyColumn = getSensorKeyColumnBySensors(sensors);
|
parameters.put("sensorKeyColumn", sensorKeyColumn);
|
parameters.put("sensors", sensorKeys);
|
|
}
|
resul = historyMinutelyMapper.getMonitorPointOrDeviceAvgData(parameters);
|
}
|
return resul;
|
}
|
|
private String getSensorKeyColumnBySensors(List<Map<String, Object>> sensors) {
|
String sensorKeyColumn = "";
|
|
for (int i = 0; i < sensors.size(); i++) {
|
String sensorKey = (String) sensors.get(i).get("sensor_key");
|
String name = (String) sensors.get(i).get("name");
|
sensorKeyColumn += "AVG(json -> '$." + sensorKey + "[0]') " + sensorKey;
|
if (i != sensors.size() - 1) {
|
sensorKeyColumn += " ,";
|
}
|
sensorKeys.add(sensorKey + "-" + name);
|
}
|
return sensorKeyColumn;
|
}
|
|
@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.get("macKey");
|
String sensorKeyColumn = "AVG(json -> '$." + sensorKey + "[0]') " + sensorKey;
|
parameters.put("sensorKeyColumn", sensorKeyColumn);
|
|
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;
|
}
|
|
}
|
