package com.moral.service.impl;
|
|
import java.text.ParseException;
|
import java.time.LocalDate;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.stream.Collectors;
|
|
import javax.annotation.Resource;
|
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.ObjectUtils;
|
|
import com.moral.entity.Sensor;
|
import com.moral.mapper.AlarmDailyMapper;
|
import com.moral.mapper.SensorMapper;
|
import com.moral.service.AlarmDailyService;
|
import com.moral.service.HistoryMinutelyService;
|
|
@Service
|
@SuppressWarnings({ "rawtypes", "unchecked" })
|
public class AlarmDailyServiceImpl implements AlarmDailyService {
|
|
@Resource
|
private AlarmDailyMapper alarmDailyMapper;
|
|
@Resource
|
private SensorMapper sensorMapper;
|
|
@Resource
|
private HistoryMinutelyService historyMinutelyService;
|
|
@Override
|
public Map getPieData(Map<String, Object> parameters) {
|
Map<String, Object> resultMap = new LinkedHashMap<String, Object>();
|
try {
|
historyMinutelyService.convertQueryParam(parameters);
|
} catch (ParseException e) {
|
e.printStackTrace();
|
}
|
List<Map<String, Object>> alarmDatas = alarmDailyMapper.getAlarmData(parameters);
|
Object dimension = parameters.get("dimension");
|
if ("monitorPoint".equals(dimension)) {
|
for (Map<String, Object> alarmData : alarmDatas) {
|
String name = alarmData.remove("name").toString();
|
alarmData.remove("sum");
|
for (Map.Entry<String, Object> entry : alarmData.entrySet()) {
|
String key = entry.getKey();
|
Object value = entry.getValue().toString();
|
if (!"0".equals(value)) {
|
List list;
|
Map<String, Object> map = new HashMap<String, Object>();
|
if (ObjectUtils.isEmpty(resultMap.get(key))) {
|
list = new ArrayList();
|
} else {
|
list = (List) resultMap.get(key);
|
}
|
map.put("name", name);
|
map.put("value", value);
|
list.add(map);
|
resultMap.put(key, list);
|
}
|
}
|
}
|
} else {
|
Map<String, Object> alarmData = alarmDatas.get(0);
|
List<String> sensors = (List<String>) parameters.get("sensors");
|
List list = new ArrayList();
|
if (!ObjectUtils.isEmpty(alarmData)) {
|
for (String key : alarmData.keySet()) {
|
for (String sensor : sensors) {
|
String[] split = sensor.split("-");
|
if (key.equals(split[0]) && !"0".equals(alarmData.get(key).toString())) {
|
Map<String, Object> map = new HashMap<String, Object>();
|
if (parameters.containsKey("description")) {
|
map.put("name", split[3]);
|
} else {
|
map.put("name", split[1]);
|
}
|
map.put("value", alarmData.get(key));
|
list.add(map);
|
}
|
}
|
}
|
}
|
resultMap.put("list", list);
|
}
|
return resultMap;
|
}
|
|
@Override
|
public List<Integer> getAlarmDataByYear(Map<String, Object> parameters) {
|
LocalDate localDate = LocalDate.now();
|
parameters.put("start", localDate.with(TemporalAdjusters.firstDayOfYear()));
|
parameters.put("end", localDate.with(TemporalAdjusters.firstDayOfNextYear()));
|
parameters.put("sensorKeys",
|
sensorMapper.selectAll().stream().map(sensor -> sensor.getSensorKey()).collect(Collectors.toList()));
|
List<Map<String, Object>> list = alarmDailyMapper.getAlarmDataByYear(parameters);
|
Integer[] result = new Integer[12];
|
for (int i = 0; i < result.length; i++) {
|
if (ObjectUtils.isEmpty(list)) {
|
break;
|
}
|
for (Map<String, Object> map : list) {
|
Integer month = Integer.valueOf(map.get("time").toString().substring(5));
|
if (i + 1 < month) {
|
break;
|
} else if (i + 1 == month) {
|
result[i] = Integer.valueOf(map.get("sum").toString());
|
list.remove(map);
|
break;
|
}
|
}
|
}
|
return Arrays.asList(result);
|
}
|
|
@Override
|
public List<Map<String, Object>> getAlarmDataByMonth(Map<String, Object> parameters) {
|
LocalDate localDate = LocalDate.now();
|
List<Sensor> sensors = sensorMapper.selectAll();
|
// Iterator<Sensor> iterator = sensors.iterator();
|
// while (iterator.hasNext()) {
|
// if ("warn".equals(iterator.next().getSensorKey())) {
|
// iterator.remove();
|
// }
|
// }
|
parameters.put("start", localDate.with(TemporalAdjusters.firstDayOfMonth()));
|
parameters.put("end", localDate.with(TemporalAdjusters.firstDayOfNextMonth()));
|
parameters.put("sensors", sensors);
|
Map<String, Object> map = alarmDailyMapper.getAlarmDataByMonth(parameters);
|
List<Entry<String, Object>> list = new ArrayList<Entry<String,Object>>(map.entrySet());
|
Collections.sort(list, new Comparator<Map.Entry<String, Object>>() {
|
@Override
|
public int compare(Entry<String, Object> o1, Entry<String, Object> o2) {
|
if (o2.getValue().equals(o1.getValue())) {
|
return o1.getKey().compareTo(o2.getKey());
|
//return Integer.compare(Integer.valueOf(o1.getKey().replace("e", "")),Integer.valueOf(o2.getKey().replace("e", "")));
|
} else {
|
return Integer.valueOf(o2.getValue().toString()).compareTo(Integer.valueOf(o1.getValue().toString()));
|
}
|
}
|
});
|
List<Map<String, Object>> resultList = new ArrayList<Map<String,Object>>();
|
for (Entry<String, Object> entry : list) {
|
for (Sensor sensor : sensors) {
|
if (!entry.getValue().toString().equals("0") && entry.getKey().equals(sensor.getSensorKey())) {
|
Map<String, Object> map2 = new HashMap<String, Object>();
|
map2.put(sensor.getDescription(), entry.getValue());
|
resultList.add(map2);
|
sensors.remove(sensor);
|
break;
|
}
|
}
|
}
|
|
return resultList;
|
}
|
|
}
|
