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.Collection;
|
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.Collector;
|
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", "rawtypes", "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" };
|
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;
|
}
|
|
@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.get("items"), new TypeReference<List<Map<String, Object>>>() {});
|
parameters.remove("items");
|
ExecutorService threadPool = Executors.newCachedThreadPool();
|
CompletionService<Map<String, List<Object>>> cs = new ExecutorCompletionService<Map<String, List<Object>>>(threadPool);
|
|
String type = (String) parameters.get("type");
|
if ("month".equals(type)) {
|
for (Map<String, Object> map : list) {
|
int timeLength = Integer.valueOf(parameters.get("timeLength").toString());
|
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) {
|
parameters.put("timeLength", lengthOfMonth);
|
}
|
}
|
}
|
|
List<Object> timeList = new ArrayList<Object>();
|
for (int i = 0; i <Integer.valueOf(parameters.get("timeLength").toString()); i++) {
|
timeList.add(i, String.format("%02d", "day".equals(type) || "hour".equals(type) ? i : i + 1));
|
}
|
parameters.put("timeList", timeList);
|
|
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.get("formatTime"));
|
map.remove("formatTime");
|
map.putAll(parameters);
|
cs.submit(new Callable<Map<String, List<Object>>>() {
|
@Override
|
public Map<String, List<Object>> call() throws Exception {
|
return getMonitorPointOrDeviceAvgData4Compare(map);
|
}
|
});
|
}
|
|
List<Object> dataList = new ArrayList<Object>();
|
for (Map<String, Object> map : list) {
|
dataList.add(cs.take().get());
|
}
|
Map[] maps = new HashMap[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", ""));
|
maps[index] = map;
|
}
|
if (key.startsWith("sensors")) {
|
sensors.addAll((List<String>) map.get(key));
|
}
|
}
|
}
|
resultMap.put("times", timeList);
|
resultMap.put("datas", Arrays.asList(maps));
|
resultMap.put("sensors", new ArrayList<Object>(sensors));
|
return resultMap;
|
}
|
|
|
public Map<String, List<Object>> getMonitorPointOrDeviceAvgData4Compare(Map<String, Object> parameters) throws Exception {
|
Map<String, List<Object>> resultMap = new HashMap<String, List<Object>>();
|
|
List<Map<String, Object>> resultList = getMonitorPointOrDeviceAvgData(parameters);
|
|
List<Object> timeList = (List<Object>) parameters.get("timeList");
|
|
List<Object> dataList = new ArrayList<Object>();
|
Set<String> sensors ;
|
if (parameters.containsKey("sensorKey")) {
|
String sensorKey = (String) parameters.get("sensorKey");
|
Sensor sensor = new Sensor();
|
sensor.setSensorKey(sensorKey);
|
sensor = sensorMapper.selectOne(sensor );
|
sensors = new HashSet<String>();
|
sensors.add(sensorKey + "-" + sensor.getName() + "-" + sensor.getUnit());
|
} else {
|
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", "")));
|
}
|
});
|
sensors.addAll((Set<String>)parameters.get("sensors"));
|
}
|
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);
|
|
}
|
}
|
}
|
dataList.add(doubleMap);
|
String part = parameters.get("part").toString();
|
resultMap.put("data" + part, dataList);
|
resultMap.put("sensors" + part, new ArrayList<Object>(sensors));
|
return resultMap;
|
}
|
|
@Override
|
public List<Map<String, Object>> getMonitorPointOrDeviceAvgData(Map<String, Object> parameters) throws Exception {
|
List<Map<String, Object>> resultList ;
|
|
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")) {
|
resultList = new ArrayList<Map<String,Object>>();
|
Integer monitorPointId = Integer.valueOf(parameters.get("monitorPoint").toString());
|
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, parameters);
|
parameter.put("sensorKeyColumn", sensorKeyColumn);
|
}
|
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]);
|
}
|
resultList.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);
|
parameters.put("sensorKeyColumn", sensorKeyColumn);
|
|
}
|
resultList = historyMinutelyMapper.getMonitorPointOrDeviceAvgData(parameters);
|
}
|
return resultList;
|
}
|
|
private String getSensorKeyColumnBySensors(List<Map<String, Object>> sensors,Map<String, Object> parameters) {
|
String sensorKeyColumn = "";
|
Set<String> sensorKeys = new HashSet<String>();
|
if (parameters.containsKey("sensors")) {
|
sensorKeys = (Set<String>) parameters.get("sensors");
|
}
|
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");
|
String unit = (String) sensors.get(i).get("unit");
|
sensorKeyColumn += "AVG(json -> '$." + sensorKey + "[0]') " + sensorKey;
|
if (i != sensors.size() - 1) {
|
sensorKeyColumn += " ,";
|
}
|
sensorKeys.add(sensorKey + "-" + name + "-" + unit );
|
parameters.put("sensors", sensorKeys);
|
}
|
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;
|
}
|
|
/**
|
* 根据线性表单的条件规则，获取多条线性表单数据
|
* @param lineChartCriteria
|
* @return
|
*/
|
@Override
|
public List<List<PairData>> queryLineChartDateByCrieria(LineChartCriteria lineChartCriteria){
|
String sensorKey = lineChartCriteria.getSensorKey();
|
TimePeriod timePeriod = lineChartCriteria.getTimePeriod();
|
List<DataCondition> dataConditionList = lineChartCriteria.getDataConditions();
|
List<List<PairData>> list = new ArrayList<>();
|
dataConditionList.forEach(item -> {
|
List<PairData> pairDataList = queryOneLineChartDateByCrieria(sensorKey,timePeriod,item);
|
list.add(pairDataList);
|
});
|
return list;
|
}
|
|
/**
|
* 根据线性表单的条件规则，获取一条线性表单数据
|
* @param sensorKey
|
* @param timePeriod
|
* @param dataCondition
|
* @return
|
*/
|
public List<PairData> queryOneLineChartDateByCrieria(String sensorKey, TimePeriod timePeriod, DataCondition dataCondition){
|
List<String> timeList = ReportTimeFormat.makeTimeList(timePeriod);
|
List<PairData> lineChartDatas = historyMinutelyMapper.selectLineChartDateByCrieria(sensorKey,timePeriod,dataCondition);
|
List<PairData> lineChartDatasWithEmpty = new ArrayList<>();
|
int m = 0;
|
int dataLength = lineChartDatas.size()-1;
|
m = dataLength>-1?0:-1;
|
if(m>-1){
|
for(int n =0;n<timeList.size();n++){
|
String time = timeList.get(n);
|
if(m>-1){
|
PairData pairData = lineChartDatas.get(m);
|
String keyTime = pairData.getCategory();
|
if(time.equals(keyTime)){
|
lineChartDatasWithEmpty.add(pairData);
|
m = m<dataLength ? m+1 : -1;
|
}else{
|
lineChartDatasWithEmpty.add(generateEmptyData(time));
|
}
|
}else {
|
lineChartDatasWithEmpty.add(generateEmptyData(time));
|
}
|
|
}
|
}else{
|
fillEmptyDataToList(timeList,lineChartDatasWithEmpty);
|
}
|
return lineChartDatasWithEmpty;
|
}
|
private PairData generateEmptyData(String time) {
|
PairData pairData = new PairData();
|
pairData.setCategory(time);
|
pairData.setValue(null);
|
return pairData;
|
}
|
private void fillEmptyDataToList(List<String> timeList,List<PairData> lineChartDatasWithEmpty){
|
timeList.forEach( time ->{
|
PairData pairData = generateEmptyData(time);
|
lineChartDatasWithEmpty.add(pairData);
|
});
|
}
|
}
|
