From ea5be111f899db0af7356bbee88c07161875cc54 Mon Sep 17 00:00:00 2001
From: whycxzp <glperry@163.com>
Date: 星期一, 16 六月 2025 19:12:46 +0800
Subject: [PATCH] 领导层首页-实时告警信息
---
src/main/java/com/whyc/service/LeaderHomeService.java | 918 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 894 insertions(+), 24 deletions(-)
diff --git a/src/main/java/com/whyc/service/LeaderHomeService.java b/src/main/java/com/whyc/service/LeaderHomeService.java
index a941000..2648e42 100644
--- a/src/main/java/com/whyc/service/LeaderHomeService.java
+++ b/src/main/java/com/whyc/service/LeaderHomeService.java
@@ -1,9 +1,16 @@
package com.whyc.service;
-import com.whyc.dto.NameValueDto;
-import com.whyc.dto.Response;
+import com.sun.org.glassfish.gmbal.NameValue;
+import com.whyc.constant.BattSingalIdEnum;
+import com.whyc.constant.Capperformance;
+import com.whyc.constant.DevAlarmEnum;
+import com.whyc.constant.PowerAlarmEnum;
+import com.whyc.dto.*;
+import com.whyc.factory.BattCapFactory;
import com.whyc.factory.ThreadPoolExecutorFactory;
+import com.whyc.pojo.db_batt_testdata.BatttestdataId;
import com.whyc.pojo.db_batt_testdata.BatttestdataInf;
+import com.whyc.pojo.db_param.AppParam;
import com.whyc.pojo.db_station.BattInf;
import com.whyc.pojo.db_station.PowerInf;
import com.whyc.pojo.db_station.StationInf;
@@ -17,11 +24,7 @@
import java.util.stream.Collectors;
import java.time.LocalDateTime;
-import java.time.LocalDate;
-import java.time.ZoneId;
-import java.time.temporal.TemporalAdjusters;
import java.util.List;
-import java.util.stream.Collectors;
import static com.whyc.util.DateUtil.convertToLocalDateTime;
@@ -41,11 +44,28 @@
@Autowired
private BatttestdataInfService battTestDataInfService;
+ @Autowired
+ private PwrdevAlarmService powerAlarmService;
+
+ @Autowired
+ private DevalarmDataService devAlarmService;
+
+ @Autowired
+ private BattalarmDataService battAlarmService;
+
+ @Autowired
+ private AppParamService appParamService;
+
+ @Autowired
+ private BatttestdataIdService battTestDataIdService;
+
+
+
public Response getAll(Integer userId) {
Response response = new Response();
Map<String,Object> map = new HashMap<>();
- CountDownLatch latch = new CountDownLatch(9);
+ CountDownLatch latch = new CountDownLatch(6);
ThreadPoolExecutor poolExecutor = ThreadPoolExecutorFactory.getPoolExecutor();
//绔欑偣淇℃伅缁熻,
@@ -74,29 +94,536 @@
//deviceInfoStatistics(userId, map);
latch.countDown();
});
- //TODO 瀹炴椂鍛婅淇℃伅缁熻
+
+ /**
+ * 瀹炴椂鍛婅淇℃伅缁熻
+ * 閫昏緫鏇存柊:
+ * 鐢垫睜閲岄潰鐨勫崟浣�(鍗曚綋1,鍗曚綋2..)鍗曢」,鍙互鍚堝苟. 鐢垫簮閲岄潰鐨勬暣娴佸櫒(鏁存祦鍣�1,鏁存祦鍣�2..)鍛婅鍗曢」鍙互鍚堝苟
+ * 鍚堝苟鍚庢椂闂撮噰鐢ㄦ渶鍏堜骇鐢熸姤璀︾殑閭ｄ釜鏃堕棿
+ */
poolExecutor.execute(() -> {
- //alarmRealtimeStatistics(userId, map);
- latch.countDown();
- });
- //TODO 涓嶅悓鏃堕棿鍚屼竴鍝佺墝钃勭數姹犳�ц兘缁熻
- poolExecutor.execute(() -> {
- //performanceInfoStatistics(userId, map);
- latch.countDown();
- });
- //TODO 鍚屼竴鏃堕棿涓嶅悓鍝佺墝钃勭數姹犳�ц兘缁熻
- poolExecutor.execute(() -> {
- //performanceInfoStatistics2(userId, map);
- latch.countDown();
- });
- //TODO 鍚屼竴鏃堕棿鍚屼竴鍝佺墝钃勭數姹犳�ц兘缁熻
- poolExecutor.execute(() -> {
- //performanceInfoStatistics3(userId, map);
+ alarmRealtimeStatistics(userId, map);
latch.countDown();
});
return response;
}
+
+ private void alarmRealtimeStatistics(Integer userId, Map<String, Object> map) {
+ //鐢垫睜鍛婅淇℃伅缁熻
+ List<AlarmDto> battAlarmListNew = new ArrayList<>();
+ List<AlarmDto> battAlarmList = battAlarmService.getListByUserId(userId);
+ //鍚堝苟鍗曚綋鍛婅鐨勫憡璀︿俊鎭�,瀵笰larmDto涓瑼lmId 鍦�17~28涔嬮棿鐨勮繘琛屽悎骞�.
+ Map<String, List<AlarmDto>> mergeMap = battAlarmList.stream()
+ .filter(alarm -> alarm.getAlmId() >= 17 && alarm.getAlmId() <= 28)
+ .collect(Collectors.groupingBy(temp -> temp.getBattGroupId()+"_"+temp.getAlmId()));
+ mergeMap.forEach((almId, list) -> {
+ //瀵筶ist鍐呯殑瀛楁 鍗曚綋缂栧彿杩涜鍚堝苟. 鏃堕棿鍙栨渶灏忕殑
+ List<AlarmDto> mergeList = list.stream()
+ .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
+ .collect(Collectors.toList());
+ AlarmDto alarmDto = mergeList.get(0);
+ //鎸夊崟浣撶紪鍙锋帓搴�
+ mergeList.sort(Comparator.comparing(AlarmDto::getMonNum));
+ alarmDto.setMonNumStr(mergeList.stream()
+ .map(AlarmDto::getMonNum)
+ .map(String::valueOf)
+ .collect(Collectors.joining(",")));
+ alarmDto.setMonNum(null);
+ battAlarmListNew.add(alarmDto);
+ });
+
+ List<AlarmDto> battAlarmListOther = battAlarmList.stream().filter(alarm -> alarm.getAlmId() < 17).collect(Collectors.toList());
+ battAlarmListNew.addAll(battAlarmListOther);
+ //瀵瑰憡璀﹀悕绉拌祴鍊�
+ battAlarmListNew.forEach(alarmDto -> {
+ alarmDto.setAlmName(BattSingalIdEnum.getValue(alarmDto.getAlmId()));
+ });
+
+ //璁惧鍛婅淇℃伅缁熻
+ List<AlarmDto> devAlarmList = devAlarmService.getListByUserId(userId);
+ //瀵瑰憡璀﹀悕绉拌祴鍊�
+ devAlarmList.forEach(alarmDto -> {
+ alarmDto.setAlmName(DevAlarmEnum.getValue(alarmDto.getAlmId()));
+ });
+
+ //鐢垫簮鍛婅淇℃伅缁熻
+ List<AlarmDto> powerAlarmListNew = new ArrayList<>();
+ List<AlarmDto> powerAlarmList = powerAlarmService.getListByUserId(userId);
+ //鏁存祦鍣ㄦ�绘晠闅滃悎骞�
+ //ALARM_3300001(3300001,"鏁存祦鍣�1鎬绘晠闅滃憡璀�"),
+ // ALARM_3300002(3300002,"鏁存祦鍣�2鎬绘晠闅滃憡璀�"),
+ // ALARM_3300003(3300003,"鏁存祦鍣�3鎬绘晠闅滃憡璀�"),
+ // ALARM_3300004(3300004,"鏁存祦鍣�4鎬绘晠闅滃憡璀�"),
+ // ALARM_3300005(3300005,"鏁存祦鍣�5鎬绘晠闅滃憡璀�"),
+ // ALARM_3300006(3300006,"鏁存祦鍣�6鎬绘晠闅滃憡璀�"),
+ // ALARM_3300007(3300007,"鏁存祦鍣�7鎬绘晠闅滃憡璀�"),
+ // ALARM_3300008(3300008,"鏁存祦鍣�8鎬绘晠闅滃憡璀�"),
+ // ALARM_3300009(3300009,"鏁存祦鍣�9鎬绘晠闅滃憡璀�"),
+ // ALARM_3300010(3300010,"鏁存祦鍣�10鎬绘晠闅滃憡璀�"),
+ // ALARM_3300011(3300011,"鏁存祦鍣�11鎬绘晠闅滃憡璀�"),
+ // ALARM_3300012(3300012,"鏁存祦鍣�12鎬绘晠闅滃憡璀�"),
+ // ALARM_3300013(3300013,"鏁存祦鍣�13鎬绘晠闅滃憡璀�"),
+ // ALARM_3300014(3300014,"鏁存祦鍣�14鎬绘晠闅滃憡璀�"),
+ // ALARM_3300015(3300015,"鏁存祦鍣�15鎬绘晠闅滃憡璀�"),
+ // ALARM_3300016(3300016,"鏁存祦鍣�16鎬绘晠闅滃憡璀�"),
+ Map<Integer, List<AlarmDto>> powerMergeMap = powerAlarmList.stream()
+ .filter(alarm -> alarm.getAlmId() >= 3300001 && alarm.getAlmId() <= 3300016)
+ .collect(Collectors.groupingBy(AlarmDto::getPowerId));
+ powerMergeMap.forEach((powerId, list) -> {
+ //瀵筶ist鍐呯殑瀛楁 鏁存祦鍣ㄧ紪鍙疯繘琛屽悎骞�,鍚堝苟鍒皉ectifierName. 鏃堕棿鍙栨渶灏忕殑
+ List<AlarmDto> mergeList = list.stream()
+ .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
+ .collect(Collectors.toList());
+ AlarmDto alarmDto = mergeList.get(0);
+ //鎸夊憡璀d鎺掑簭
+ mergeList.sort(Comparator.comparing(AlarmDto::getAlmId));
+ StringBuilder rectifierNameSb = new StringBuilder();
+ rectifierNameSb.append("鏁存祦鍣�");
+ for (int i = 0; i < list.size(); i++) {
+ int almId = list.get(i).getAlmId();
+ switch (almId){
+ case 3300001:
+ rectifierNameSb.append("1,");
+ break;
+ case 3300002:
+ rectifierNameSb.append("2,");
+ break;
+ case 3300003:
+ rectifierNameSb.append("3,");
+ break;
+ case 3300004:
+ rectifierNameSb.append("4,");
+ break;
+ case 3300005:
+ rectifierNameSb.append("5,");
+ break;
+ case 3300006:
+ rectifierNameSb.append("6,");
+ break;
+ case 3300007:
+ rectifierNameSb.append("7,");
+ break;
+ case 3300008:
+ rectifierNameSb.append("8,");
+ break;
+ case 3300009:
+ rectifierNameSb.append("9,");
+ break;
+ case 3300010:
+ rectifierNameSb.append("10,");
+ break;
+ case 3300011:
+ rectifierNameSb.append("11,");
+ break;
+ case 3300012:
+ rectifierNameSb.append("12,");
+ break;
+ case 3300013:
+ rectifierNameSb.append("13,");
+ break;
+ case 3300014:
+ rectifierNameSb.append("14,");
+ break;
+ case 3300015:
+ rectifierNameSb.append("15,");
+ break;
+ case 3300016:
+ rectifierNameSb.append("16,");
+ break;
+
+ }
+ }
+ //鏈�鍚庝竴涓�,鍘绘帀
+ rectifierNameSb.deleteCharAt(rectifierNameSb.length()-1);
+ rectifierNameSb.append("鎬绘晠闅滃憡璀�");
+ alarmDto.setRectifierName(rectifierNameSb.toString());
+ powerAlarmListNew.add(alarmDto);
+ });
+
+ //鏁存祦鍣ㄨ繃鍘嬪悎骞�
+ //ALARM_3300017(3300017,"鏁存祦鍣�1杩囧帇鍛婅"),
+ // ALARM_3300018(3300018,"鏁存祦鍣�2杩囧帇鍛婅"),
+ // ALARM_3300019(3300019,"鏁存祦鍣�3杩囧帇鍛婅"),
+ // ALARM_3300020(3300020,"鏁存祦鍣�4杩囧帇鍛婅"),
+ // ALARM_3300021(3300021,"鏁存祦鍣�5杩囧帇鍛婅"),
+ // ALARM_3300022(3300022,"鏁存祦鍣�6杩囧帇鍛婅"),
+ // ALARM_3300023(3300023,"鏁存祦鍣�7杩囧帇鍛婅"),
+ // ALARM_3300024(3300024,"鏁存祦鍣�8杩囧帇鍛婅"),
+ // ALARM_3300025(3300025,"鏁存祦鍣�9杩囧帇鍛婅"),
+ // ALARM_3300026(3300026,"鏁存祦鍣�10杩囧帇鍛婅"),
+ // ALARM_3300027(3300027,"鏁存祦鍣�11杩囧帇鍛婅"),
+ // ALARM_3300028(3300028,"鏁存祦鍣�12杩囧帇鍛婅"),
+ // ALARM_3300029(3300029,"鏁存祦鍣�13杩囧帇鍛婅"),
+ // ALARM_3300030(3300030,"鏁存祦鍣�14杩囧帇鍛婅"),
+ // ALARM_3300031(3300031,"鏁存祦鍣�15杩囧帇鍛婅"),
+ // ALARM_3300032(3300032,"鏁存祦鍣�16杩囧帇鍛婅"),
+ Map<Integer, List<AlarmDto>> powerOverVolMergeMap = powerAlarmList.stream()
+ .filter(alarm -> alarm.getAlmId() >= 3300017 && alarm.getAlmId() <= 3300032)
+ .collect(Collectors.groupingBy(AlarmDto::getPowerId));
+ powerOverVolMergeMap.forEach((powerId, list) -> {
+ //瀵筶ist鍐呯殑瀛楁 鏁存祦鍣ㄧ紪鍙疯繘琛屽悎骞�,鍚堝苟鍒皉ectifierName. 鏃堕棿鍙栨渶灏忕殑
+ List<AlarmDto> mergeList = list.stream()
+ .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
+ .collect(Collectors.toList());
+ AlarmDto alarmDto = mergeList.get(0);
+ //鎸夊憡璀d鎺掑簭
+ mergeList.sort(Comparator.comparing(AlarmDto::getAlmId));
+ StringBuilder rectifierNameSb = new StringBuilder();
+ rectifierNameSb.append("鏁存祦鍣�");
+ for (int i = 0; i < list.size(); i++) {
+ int almId = list.get(i).getAlmId();
+ switch (almId){
+ case 3300017:
+ rectifierNameSb.append("1,");
+ break;
+ case 3300018:
+ rectifierNameSb.append("2,");
+ break;
+ case 3300019:
+ rectifierNameSb.append("3,");
+ break;
+ case 3300020:
+ rectifierNameSb.append("4,");
+ break;
+ case 3300021:
+ rectifierNameSb.append("5,");
+ break;
+ case 3300022:
+ rectifierNameSb.append("6,");
+ break;
+ case 3300023:
+ rectifierNameSb.append("7,");
+ break;
+ case 3300024:
+ rectifierNameSb.append("8,");
+ break;
+ case 3300025:
+ rectifierNameSb.append("9,");
+ break;
+ case 3300026:
+ rectifierNameSb.append("10,");
+ break;
+ case 3300027:
+ rectifierNameSb.append("11,");
+ break;
+ case 3300028:
+ rectifierNameSb.append("12,");
+ break;
+ case 3300029:
+ rectifierNameSb.append("13,");
+ break;
+ case 3300030:
+ rectifierNameSb.append("14,");
+ break;
+ case 3300031:
+ rectifierNameSb.append("15,");
+ break;
+ case 3300032:
+ rectifierNameSb.append("16,");
+ break;
+ }
+ }
+ //鏈�鍚庝竴涓�,鍘绘帀
+ rectifierNameSb.deleteCharAt(rectifierNameSb.length()-1);
+ rectifierNameSb.append("杩囧帇鍛婅");
+ alarmDto.setRectifierName(rectifierNameSb.toString());
+ powerAlarmListNew.add(alarmDto);
+ });
+ //鏁存祦鍣ㄦ瑺鍘嬪悎骞�
+ //ALARM_3300033(3300033,"鏁存祦鍣�1娆犲帇鍛婅"),
+ // ALARM_3300034(3300034,"鏁存祦鍣�2娆犲帇鍛婅"),
+ // ALARM_3300035(3300035,"鏁存祦鍣�3娆犲帇鍛婅"),
+ // ALARM_3300036(3300036,"鏁存祦鍣�4娆犲帇鍛婅"),
+ // ALARM_3300037(3300037,"鏁存祦鍣�5娆犲帇鍛婅"),
+ // ALARM_3300038(3300038,"鏁存祦鍣�6娆犲帇鍛婅"),
+ // ALARM_3300039(3300039,"鏁存祦鍣�7娆犲帇鍛婅"),
+ // ALARM_3300040(3300040,"鏁存祦鍣�8娆犲帇鍛婅"),
+ // ALARM_3300041(3300041,"鏁存祦鍣�9娆犲帇鍛婅"),
+ // ALARM_3300042(3300042,"鏁存祦鍣�10娆犲帇鍛婅"),
+ // ALARM_3300043(3300043,"鏁存祦鍣�11娆犲帇鍛婅"),
+ // ALARM_3300044(3300044,"鏁存祦鍣�12娆犲帇鍛婅"),
+ // ALARM_3300045(3300045,"鏁存祦鍣�13娆犲帇鍛婅"),
+ // ALARM_3300046(3300046,"鏁存祦鍣�14娆犲帇鍛婅"),
+ // ALARM_3300047(3300047,"鏁存祦鍣�15娆犲帇鍛婅"),
+ // ALARM_3300048(3300048,"鏁存祦鍣�16娆犲帇鍛婅"),
+ Map<Integer, List<AlarmDto>> powerBellowVolMergeMap = powerAlarmList.stream()
+ .filter(alarm -> alarm.getAlmId() >= 3300033 && alarm.getAlmId() <= 3300048)
+ .collect(Collectors.groupingBy(AlarmDto::getPowerId));
+ powerBellowVolMergeMap.forEach((powerId, list) -> {
+ //瀵筶ist鍐呯殑瀛楁 鏁存祦鍣ㄧ紪鍙疯繘琛屽悎骞�,鍚堝苟鍒皉ectifierName. 鏃堕棿鍙栨渶灏忕殑
+ List<AlarmDto> mergeList = list.stream()
+ .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
+ .collect(Collectors.toList());
+ AlarmDto alarmDto = mergeList.get(0);
+ //鎸夊憡璀d鎺掑簭
+ mergeList.sort(Comparator.comparing(AlarmDto::getAlmId));
+ StringBuilder rectifierNameSb = new StringBuilder();
+ rectifierNameSb.append("鏁存祦鍣�");
+ for (int i = 0; i < list.size(); i++) {
+ int almId = list.get(i).getAlmId();
+ switch (almId){
+ case 3300033:
+ rectifierNameSb.append("1,");
+ break;
+ case 3300034:
+ rectifierNameSb.append("2,");
+ break;
+ case 3300035:
+ rectifierNameSb.append("3,");
+ break;
+ case 3300036:
+ rectifierNameSb.append("4,");
+ break;
+ case 3300037:
+ rectifierNameSb.append("5,");
+ break;
+ case 3300038:
+ rectifierNameSb.append("6,");
+ break;
+ case 3300039:
+ rectifierNameSb.append("7,");
+ break;
+ case 3300040:
+ rectifierNameSb.append("8,");
+ break;
+ case 3300041:
+ rectifierNameSb.append("9,");
+ break;
+ case 3300042:
+ rectifierNameSb.append("10,");
+ break;
+ case 3300043:
+ rectifierNameSb.append("11,");
+ break;
+ case 3300044:
+ rectifierNameSb.append("12,");
+ break;
+ case 3300045:
+ rectifierNameSb.append("13,");
+ break;
+ case 3300046:
+ rectifierNameSb.append("14,");
+ break;
+ case 3300047:
+ rectifierNameSb.append("15,");
+ break;
+ case 3300048:
+ rectifierNameSb.append("16,");
+ break;
+ }
+ }
+ //鏈�鍚庝竴涓�,鍘绘帀
+ rectifierNameSb.deleteCharAt(rectifierNameSb.length()-1);
+ rectifierNameSb.append("娆犲帇鍛婅");
+ alarmDto.setRectifierName(rectifierNameSb.toString());
+ powerAlarmListNew.add(alarmDto);
+ });
+
+ //鏁存祦鍣ㄨ繃娴佸憡璀﹀悎骞�
+ //ALARM_3300049(3300049,"鏁存祦鍣�1杩囨祦鍛婅"),
+ // ALARM_3300050(3300050,"鏁存祦鍣�2杩囨祦鍛婅"),
+ // ALARM_3300051(3300051,"鏁存祦鍣�3杩囨祦鍛婅"),
+ // ALARM_3300052(3300052,"鏁存祦鍣�4杩囨祦鍛婅"),
+ // ALARM_3300053(3300053,"鏁存祦鍣�5杩囨祦鍛婅"),
+ // ALARM_3300054(3300054,"鏁存祦鍣�6杩囨祦鍛婅"),
+ // ALARM_3300055(3300055,"鏁存祦鍣�7杩囨祦鍛婅"),
+ // ALARM_3300056(3300056,"鏁存祦鍣�8杩囨祦鍛婅"),
+ // ALARM_3300057(3300057,"鏁存祦鍣�9杩囨祦鍛婅"),
+ // ALARM_3300058(3300058,"鏁存祦鍣�10杩囨祦鍛婅"),
+ // ALARM_3300059(3300059,"鏁存祦鍣�11杩囨祦鍛婅"),
+ // ALARM_3300060(3300060,"鏁存祦鍣�12杩囨祦鍛婅"),
+ // ALARM_3300061(3300061,"鏁存祦鍣�13杩囨祦鍛婅"),
+ // ALARM_3300062(3300062,"鏁存祦鍣�14杩囨祦鍛婅"),
+ // ALARM_3300063(3300063,"鏁存祦鍣�15杩囨祦鍛婅"),
+ // ALARM_3300064(3300064,"鏁存祦鍣�16杩囨祦鍛婅"),
+ Map<Integer, List<AlarmDto>> powerOverCurrentMergeMap = powerAlarmList.stream()
+ .filter(alarm -> alarm.getAlmId() >= 3300049 && alarm.getAlmId() <= 3300064)
+ .collect(Collectors.groupingBy(AlarmDto::getPowerId));
+ powerOverCurrentMergeMap.forEach((powerId, list) -> {
+ //瀵筶ist鍐呯殑瀛楁 鏁存祦鍣ㄧ紪鍙疯繘琛屽悎骞�,鍚堝苟鍒皉ectifierName. 鏃堕棿鍙栨渶灏忕殑
+ List<AlarmDto> mergeList = list.stream()
+ .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
+ .collect(Collectors.toList());
+ AlarmDto alarmDto = mergeList.get(0);
+ //鎸夊憡璀d鎺掑簭
+ mergeList.sort(Comparator.comparing(AlarmDto::getAlmId));
+ StringBuilder rectifierNameSb = new StringBuilder();
+ rectifierNameSb.append("鏁存祦鍣�");
+ for (int i = 0; i < list.size(); i++) {
+ int almId = list.get(i).getAlmId();
+ switch (almId){
+ case 3300049:
+ rectifierNameSb.append("1,");
+ break;
+ case 3300050:
+ rectifierNameSb.append("2,");
+ break;
+ case 3300051:
+ rectifierNameSb.append("3,");
+ break;
+ case 3300052:
+ rectifierNameSb.append("4,");
+ break;
+ case 3300053:
+ rectifierNameSb.append("5,");
+ break;
+ case 3300054:
+ rectifierNameSb.append("6,");
+ break;
+ case 3300055:
+ rectifierNameSb.append("7,");
+ break;
+ case 3300056:
+ rectifierNameSb.append("8,");
+ break;
+ case 3300057:
+ rectifierNameSb.append("9,");
+ break;
+ case 3300058:
+ rectifierNameSb.append("10,");
+ break;
+ case 3300059:
+ rectifierNameSb.append("11,");
+ break;
+ case 3300060:
+ rectifierNameSb.append("12,");
+ break;
+ case 3300061:
+ rectifierNameSb.append("13,");
+ break;
+ case 3300062:
+ rectifierNameSb.append("14,");
+ break;
+ case 3300063:
+ rectifierNameSb.append("15,");
+ break;
+ case 3300064:
+ rectifierNameSb.append("16,");
+ break;
+ }
+ }
+ //鏈�鍚庝竴涓�,鍘绘帀
+ rectifierNameSb.deleteCharAt(rectifierNameSb.length()-1);
+ rectifierNameSb.append("杩囨祦鍛婅");
+ alarmDto.setRectifierName(rectifierNameSb.toString());
+ powerAlarmListNew.add(alarmDto);
+ });
+
+ //鏁存祦鍣ㄤ氦娴佸紓甯稿憡璀﹀悎骞�
+ //ALARM_3300065(3300065,"鏁存祦鍣�1浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300066(3300066,"鏁存祦鍣�2浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300067(3300067,"鏁存祦鍣�3浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300068(3300068,"鏁存祦鍣�4浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300069(3300069,"鏁存祦鍣�5浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300070(3300070,"鏁存祦鍣�6浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300071(3300071,"鏁存祦鍣�7浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300072(3300072,"鏁存祦鍣�8浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300073(3300073,"鏁存祦鍣�9浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300074(3300074,"鏁存祦鍣�10浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300075(3300075,"鏁存祦鍣�11浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300076(3300076,"鏁存祦鍣�12浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300077(3300077,"鏁存祦鍣�13浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300078(3300078,"鏁存祦鍣�14浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300079(3300079,"鏁存祦鍣�15浜ゆ祦寮傚父鍛婅"),
+ // ALARM_3300080(3300080,"鏁存祦鍣�16浜ゆ祦寮傚父鍛婅"),
+ Map<Integer, List<AlarmDto>> powerACMergeMap = powerAlarmList.stream()
+ .filter(alarm -> alarm.getAlmId() >= 3300065 && alarm.getAlmId() <= 3300080)
+ .collect(Collectors.groupingBy(AlarmDto::getPowerId));
+ powerACMergeMap.forEach((powerId, list) -> {
+ //瀵筶ist鍐呯殑瀛楁 鏁存祦鍣ㄧ紪鍙疯繘琛屽悎骞�,鍚堝苟鍒皉ectifierName. 鏃堕棿鍙栨渶灏忕殑
+ List<AlarmDto> mergeList = list.stream()
+ .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
+ .collect(Collectors.toList());
+ AlarmDto alarmDto = mergeList.get(0);
+ //鎸夊憡璀d鎺掑簭
+ mergeList.sort(Comparator.comparing(AlarmDto::getAlmId));
+ StringBuilder rectifierNameSb = new StringBuilder();
+ rectifierNameSb.append("鏁存祦鍣�");
+ for (int i = 0; i < list.size(); i++) {
+ int almId = list.get(i).getAlmId();
+ switch (almId){
+ case 3300065:
+ rectifierNameSb.append("1,");
+ break;
+ case 3300066:
+ rectifierNameSb.append("2,");
+ break;
+ case 3300067:
+ rectifierNameSb.append("3,");
+ break;
+ case 3300068:
+ rectifierNameSb.append("4,");
+ break;
+ case 3300069:
+ rectifierNameSb.append("5,");
+ break;
+ case 3300070:
+ rectifierNameSb.append("6,");
+ break;
+ case 3300071:
+ rectifierNameSb.append("7,");
+ break;
+ case 3300072:
+ rectifierNameSb.append("8,");
+ break;
+ case 3300073:
+ rectifierNameSb.append("9,");
+ break;
+ case 3300074:
+ rectifierNameSb.append("10,");
+ break;
+ case 3300075:
+ rectifierNameSb.append("11,");
+ break;
+ case 3300076:
+ rectifierNameSb.append("12,");
+ break;
+ case 3300077:
+ rectifierNameSb.append("13,");
+ break;
+ case 3300078:
+ rectifierNameSb.append("14,");
+ break;
+ case 3300079:
+ rectifierNameSb.append("15,");
+ break;
+ case 3300080:
+ rectifierNameSb.append("16,");
+ break;
+ }
+ }
+ //鏈�鍚庝竴涓�,鍘绘帀
+ rectifierNameSb.deleteCharAt(rectifierNameSb.length()-1);
+ rectifierNameSb.append("浜ゆ祦寮傚父鍛婅");
+ alarmDto.setRectifierName(rectifierNameSb.toString());
+ powerAlarmListNew.add(alarmDto);
+ });
+
+ //杩囨护鎺変骇鐢熷悎骞剁殑鍛婅
+ List<AlarmDto> powerAlarmListOther = powerAlarmList.stream().filter(alarm -> alarm.getAlmId() < 3300001 || alarm.getAlmId() > 3300080).collect(Collectors.toList());
+ powerAlarmListNew.addAll(powerAlarmListOther);
+ //瀵瑰憡璀﹀悕绉拌祴鍊�
+ powerAlarmListNew.forEach(alarmDto -> {
+ alarmDto.setAlmName(PowerAlarmEnum.getValue(alarmDto.getAlmId()));
+ });
+ //瀵瑰瓨鍦≧ectifierName鐨勫厓绱�,灏唕ectifierName瀛楁璧嬪�肩粰almName瀛楁
+ powerAlarmListNew.forEach(alarmDto -> {
+ if(alarmDto.getRectifierName() != null){
+ alarmDto.setAlmName(alarmDto.getRectifierName());
+ }
+ });
+
+
+ //鏁村悎鎵�鏈夌殑鍛婅
+ powerAlarmListNew.addAll(devAlarmList);
+ powerAlarmListNew.addAll(battAlarmListNew);
+
+ //鎸夌収鏃堕棿杩涜鍊掑簭
+ powerAlarmListNew.sort(Comparator.comparing(AlarmDto::getAlmStartTime).reversed());
+ map.put("alarmList",powerAlarmListNew);
+ }
+
private void testDataInfoStatistics(Integer userId, Map<String, Object> map) {
List<BatttestdataInf> testInfList = battTestDataInfService.getListByUserId(userId);
@@ -253,4 +780,347 @@
map.put("stationInfo_stationVol",stationVolList);
}
+ //鍚屼竴鏃堕棿鍚屼竴鍝佺墝鐢垫睜鎬ц兘缁熻
+ public Response getBattPerformanceOfSameTimeSameBrand(Integer userId, NameValueIntDto nameValueDto) {
+ String brand = nameValueDto.getName();
+ Integer year = nameValueDto.getValue();
+ //鎶曞叆浣跨敤鏃堕棿鏉′欢绛涢��
+ LocalDateTime startTime = LocalDateTime.now().minusYears(year);
+ Date inuseTimeStart = DateUtil.convertToDate(startTime);
+ BattInf battInf = new BattInf();
+ battInf.setInuseTime(inuseTimeStart);
+ battInf.setProduct(brand);
+ //鏌ヨ婊¤冻鏉′欢鐨勮搫鐢垫睜鍒楄〃
+ List<BattInf> battInfList = battInfService.getListByCondition(userId,battInf);
+ List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList);
+ //data,鍜宒ata2鍒嗗埆杩斿洖 缁熻鏁伴噺鍜� 绔欑偣浼樿壇,鍔ｅ寲,鎹熷潖 鍓嶄簩鐨勪俊鎭�
+ List<NameValueIntDto> data = new ArrayList<>();
+ List<NameValueListDto> data2 = new ArrayList<>();
+ //绛涢�夊嚭 绔欑偣浼樿壇,鍔ｅ寲,鎹熷潖 鐨勭數姹犵粍,骞舵寜鐓ц繖涓瓧娈靛垎缁�
+ List<BattCapInfoDto> goodList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_1.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap).reversed()).collect(Collectors.toList());
+ if(goodList.size()==0){
+ data.add(new NameValueIntDto("浼樿壇",0));
+ data2.add(new NameValueListDto("浼樿壇",goodList));
+ }else{
+ data.add(new NameValueIntDto("浼樿壇",goodList.size()));
+ data2.add(new NameValueListDto("浼樿壇",goodList.subList(0, Math.min(goodList.size(), 2))));
+ }
+ List<BattCapInfoDto> badList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ if(badList.size()==0){
+ data.add(new NameValueIntDto("鍔ｅ寲",0));
+ data2.add(new NameValueListDto("鍔ｅ寲",badList));
+ }else{
+ data.add(new NameValueIntDto("鍔ｅ寲",badList.size()));
+ data2.add(new NameValueListDto("鍔ｅ寲",badList.subList(0, Math.min(badList.size(), 2))));
+ }
+ List<BattCapInfoDto> damageList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_3.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ if(damageList.size()==0){
+ data.add(new NameValueIntDto("鎹熷潖",0));
+ data2.add(new NameValueListDto("鎹熷潖",damageList));
+ }else{
+ data.add(new NameValueIntDto("鎹熷潖",damageList.size()));
+ data2.add(new NameValueListDto("鎹熷潖",damageList.subList(0, Math.min(damageList.size(), 2))));
+ }
+ return new Response().setII(1,data,data2,"");
+
+ }
+
+ public Response getBattPerformanceOfSameTimeDiffBrand(Integer userId, int year) {
+ //鎶曞叆浣跨敤鏃堕棿鏉′欢绛涢��
+ LocalDateTime startTime = LocalDateTime.now().minusYears(year);
+ Date inuseTimeStart = DateUtil.convertToDate(startTime);
+ BattInf battInf = new BattInf();
+ battInf.setInuseTime(inuseTimeStart);
+ //鏌ヨ婊¤冻鏉′欢鐨勮搫鐢垫睜鍒楄〃
+ List<BattInf> battInfList = battInfService.getListByCondition(userId,battInf);
+ List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList);
+
+ //data,鏍规嵁鍝佺墝鍒嗙粍缁熻鐧惧垎姣�
+ Map<String, List<BattCapInfoDto>> brandMap = battCapInfoList.stream().collect(Collectors.groupingBy(BattCapInfoDto::getProduct));
+ List<NameValueListDto<NameValueDto>> data = new ArrayList<>();
+ brandMap.forEach((brand,battCapInfoListTemp)->{
+ //k -鍝佺墝
+ long goodCount = battCapInfoListTemp.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_1.getStateName())).count();
+ long badCount = battCapInfoListTemp.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName())).count();
+ long damageCount = battCapInfoListTemp.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_3.getStateName())).count();
+ long total = goodCount + badCount + damageCount;
+ //鑹ソ,鍔ｅ寲,鎹熷潖鐨勭櫨鍒嗘瘮.锛堜繚鐣�0浣嶅皬鏁帮級
+ int goodPercent = Math.round((float) goodCount / total * 100);
+ int badPercent = Math.round((float) badCount / total * 100);
+ int damagePercent = Math.round((float) damageCount / total * 100);
+
+ List<NameValueDto> performanceList = new ArrayList<>();
+ performanceList.add(new NameValueDto("浼樿壇",String.format("%d%%",goodPercent)));
+ performanceList.add(new NameValueDto("鍔ｅ寲",String.format("%d%%",badPercent)));
+ performanceList.add(new NameValueDto("鎹熷潖",String.format("%d%%",damagePercent)));
+
+ NameValueListDto brandPerformance = new NameValueListDto(brand,performanceList);
+ data.add(brandPerformance);
+ });
+ //data2,浼樿壇閲岄潰鏈�澶х殑鍜屾渶灏忕殑鍝佺墝
+ List<NameValueListDto<NameValueDto>> data2 = new ArrayList<>();
+ List<BattCapInfoDto> goodList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_1.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ NameValueListDto<NameValueDto> goodListDto = new NameValueListDto<>();
+ List<NameValueDto> goodListValue = new ArrayList<>();
+ NameValueDto goodMaxDto = new NameValueDto();
+ NameValueDto goodMinDto = new NameValueDto();
+ goodMaxDto.setName("max");
+ goodMinDto.setName("min");
+ if (goodList.size()==0){
+ goodMaxDto.setValue("-");
+ goodMinDto.setValue("-");
+ }else{
+ goodMinDto.setValue(goodList.get(0).getProduct());
+ goodMaxDto.setValue(goodList.get(goodList.size()-1).getProduct());
+ }
+ goodListValue.add(goodMaxDto);
+ goodListValue.add(goodMinDto);
+
+ goodListDto.setName("浼樿壇");
+ goodListDto.setValue(goodListValue);
+ data2.add(goodListDto);
+ //鍔ｅ寲閲岄潰鏈�澶х殑鍜屾渶灏忕殑鍝佺墝
+ List<BattCapInfoDto> badList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ NameValueListDto<NameValueDto> badListDto = new NameValueListDto<>();
+ List<NameValueDto> badListValue = new ArrayList<>();
+ NameValueDto badMaxDto = new NameValueDto();
+ NameValueDto badMinDto = new NameValueDto();
+ badMaxDto.setName("max");
+ badMinDto.setName("min");
+ if (badList.size()==0){
+ badMaxDto.setValue("-");
+ badMinDto.setValue("-");
+ }else{
+ badMinDto.setValue(badList.get(0).getProduct());
+ badMaxDto.setValue(badList.get(badList.size()-1).getProduct());
+ }
+ badListValue.add(badMaxDto);
+ badListValue.add(badMinDto);
+
+ badListDto.setName("鍔ｅ寲");
+ badListDto.setValue(badListValue);
+ data2.add(badListDto);
+
+ //鎹熷潖閲岄潰鏈�澶х殑鍜屾渶灏忕殑鍝佺墝
+ List<BattCapInfoDto> damageList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_3.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+
+ NameValueListDto<NameValueDto> damageListDto = new NameValueListDto<>();
+ List<NameValueDto> damageListValue = new ArrayList<>();
+ NameValueDto damageMaxDto = new NameValueDto();
+ NameValueDto damageMinDto = new NameValueDto();
+ damageMaxDto.setName("max");
+ damageMinDto.setName("min");
+ if (damageList.size()==0){
+ damageMaxDto.setValue("-");
+ damageMinDto.setValue("-");
+ }else if (damageList.size()==1){
+ damageMaxDto.setValue(damageList.get(0).getProduct());
+ damageMinDto.setValue(damageList.get(0).getProduct());
+ }else{
+ damageMinDto.setValue(damageList.get(0).getProduct());
+ damageMaxDto.setValue(damageList.get(damageList.size()-1).getProduct());
+ }
+ damageListValue.add(damageMaxDto);
+ damageListValue.add(damageMinDto);
+
+ damageListDto.setName("鎹熷潖");
+ damageListDto.setValue(damageListValue);
+ data2.add(damageListDto);
+
+ //data3. 鎬ц兘鏈�浣冲搧鐗� TODO 濞佸皵閫婄疆淇″尯闂存硶浠ュ強璐濆彾鏂钩鍧囨硶锛岄�氳繃璁剧疆鐨勬潈閲嶏紝璁＄畻鍚勪釜鍝佺墝鍦ㄦ寚瀹氭姇杩愭椂闂村唴鐨勫緱鍒�
+ return new Response().setIII(1,data,data2,"鎬ц兘鏈�浣冲搧鐗�:TODO 濞佸皵閫婄疆淇″尯闂存硶浠ュ強璐濆彾鏂钩鍧囨硶锛岄�氳繃璁剧疆鐨勬潈閲嶏紝璁＄畻鍚勪釜鍝佺墝鍦ㄦ寚瀹氭姇杩愭椂闂村唴鐨勫緱鍒�",null);
+
+ }
+
+ public Response getBattPerformanceOfDiffTimeSameBrand(Integer userId, String brand) {
+ BattInf battInf = new BattInf();
+ battInf.setProduct(brand);
+ //鏌ヨ婊¤冻鏉′欢鐨勮搫鐢垫睜鍒楄〃
+ List<BattInf> battInfList = battInfService.getListByCondition(userId,battInf);
+ List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList);
+
+ //data,TODO 鎶曡繍鏃堕棿鐨勭淮搴﹀弬鏁�,鍏堝浐瀹氬彉閲�,鍚庣画浠庢暟鎹簱鑾峰彇
+ //time1鍜宼ime2鐨勫崟浣嶄负骞�
+ int time1 = 3;
+ int time2 = 5;
+
+ //绛涢�塨attCapInfoList涓璞＄殑inuseTime灞炴�� 璺熷綋鍓嶆椂闂村姣�,骞翠唤宸湪time1涔嬪唴,time1-time2涔嬮棿,time2涔嬪悗鐨勬暟鎹�
+ // --------------time2Limit------time1Limit-------now
+ LocalDateTime time1DateLimit = LocalDateTime.now().minusYears(time1);
+ Date time1Limit = DateUtil.convertToDate(time1DateLimit);
+ LocalDateTime time2DateLimit = LocalDateTime.now().minusYears(time2);
+ Date time2Limit = DateUtil.convertToDate(time2DateLimit);
+
+ //澶т簬time1鐨勬暟鎹�
+ List<BattCapInfoDto> time1List = battCapInfoList.stream().
+ filter(battCapInfo -> battCapInfo.getInuseTime().compareTo(time1Limit)>=0).collect(Collectors.toList());
+ //鍦╰ime1鍜宼ime2涔嬮棿鐨勬暟鎹�
+ List<BattCapInfoDto> time12List = battCapInfoList.stream().
+ filter(battCapInfo -> battCapInfo.getInuseTime().compareTo(time2Limit)>0 && battCapInfo.getInuseTime().compareTo(time1Limit)<=0).collect(Collectors.toList());
+ //灏忎簬time2鐨勬暟鎹�
+ List<BattCapInfoDto> time2List = battCapInfoList.stream().
+ filter(battCapInfo -> battCapInfo.getInuseTime().compareTo(time2Limit)<0).collect(Collectors.toList());
+
+ //data
+ List<NameValueListDto<NameValueIntDto>> data = new ArrayList<>();
+ NameValueListDto<NameValueIntDto> time1Dto = new NameValueListDto<>();
+ time1Dto.setName(time1+"骞村唴");
+ List<BattCapInfoDto> badListOfTime1 = time1List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ List<BattCapInfoDto> damageListOfTime1 = time1List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_3.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ NameValueIntDto time1BadDto = new NameValueIntDto();
+ time1BadDto.setName("鍔ｅ寲");
+ time1BadDto.setValue(badListOfTime1.size());
+ NameValueIntDto time1DamageDto = new NameValueIntDto();
+ time1DamageDto.setName("鎹熷潖");
+ time1DamageDto.setValue(damageListOfTime1.size());
+ time1Dto.setValue(Arrays.asList(time1BadDto,time1DamageDto));
+
+ NameValueListDto<NameValueIntDto> time12Dto = new NameValueListDto<>();
+ time12Dto.setName(time1+"-"+time2+"骞�");
+ List<BattCapInfoDto> badListOfTime12 = time12List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ List<BattCapInfoDto> damageListOfTime12 = time12List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_3.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ NameValueIntDto time12BadDto = new NameValueIntDto();
+ time12BadDto.setName("鍔ｅ寲");
+ time12BadDto.setValue(badListOfTime12.size());
+ NameValueIntDto time12DamageDto = new NameValueIntDto();
+ time12DamageDto.setName("鎹熷潖");
+ time12DamageDto.setValue(damageListOfTime12.size());
+ time12Dto.setValue(Arrays.asList(time12BadDto,time12DamageDto));
+
+ NameValueListDto<NameValueIntDto> time2Dto = new NameValueListDto<>();
+ time2Dto.setName(time2+"骞翠互涓�");
+ List<BattCapInfoDto> badListOfTime2 = time2List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ List<BattCapInfoDto> damageListOfTime2 = time2List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_3.getStateName()))
+ .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
+ NameValueIntDto time2BadDto = new NameValueIntDto();
+ time2BadDto.setName("鍔ｅ寲");
+ time2BadDto.setValue(badListOfTime2.size());
+ NameValueIntDto time2DamageDto = new NameValueIntDto();
+ time2DamageDto.setName("鎹熷潖");
+ time2DamageDto.setValue(damageListOfTime2.size());
+ time2Dto.setValue(Arrays.asList(time2BadDto,time2DamageDto));
+
+ data.add(time1Dto);
+ data.add(time12Dto);
+ data.add(time2Dto);
+
+ //data2
+ List<NameValueListDto<NameValueObjectDto<BattCapInfoDto>>> data2 = new ArrayList<>();
+ NameValueListDto<NameValueObjectDto<BattCapInfoDto>> time1ObjectDto = new NameValueListDto<>();
+ time1ObjectDto.setName(time1+"骞村唴");
+ NameValueObjectDto<BattCapInfoDto> time1BadObjectDto = new NameValueObjectDto();
+ time1BadObjectDto.setName("鍔ｅ寲");
+ time1BadObjectDto.setValue(badListOfTime1.size()==0?new BattCapInfoDto():badListOfTime1.get(0));
+
+ NameValueObjectDto<BattCapInfoDto> time1DamageObjectDto = new NameValueObjectDto();
+ time1DamageObjectDto.setName("鎹熷潖");
+ time1DamageObjectDto.setValue(damageListOfTime1.size()==0?new BattCapInfoDto():damageListOfTime1.get(0));
+ time1ObjectDto.setValue(Arrays.asList(time1BadObjectDto,time1DamageObjectDto));
+ data2.add(time1ObjectDto);
+
+ NameValueListDto<NameValueObjectDto<BattCapInfoDto>> time12ObjectDto = new NameValueListDto<>();
+ time12ObjectDto.setName(time1+"-"+time2+"骞�");
+ NameValueObjectDto<BattCapInfoDto> time12BadObjectDto = new NameValueObjectDto();
+ time12BadObjectDto.setName("鍔ｅ寲");
+ time12BadObjectDto.setValue(badListOfTime12.size()==0?new BattCapInfoDto():badListOfTime12.get(0));
+ NameValueObjectDto<BattCapInfoDto> time12DamageObjectDto = new NameValueObjectDto();
+ time12DamageObjectDto.setName("鎹熷潖");
+ time12DamageObjectDto.setValue(damageListOfTime12.size()==0?new BattCapInfoDto():damageListOfTime12.get(0));
+ time12ObjectDto.setValue(Arrays.asList(time12BadObjectDto,time12DamageObjectDto));
+ data2.add(time12ObjectDto);
+
+ NameValueListDto<NameValueObjectDto<BattCapInfoDto>> time2ObjectDto = new NameValueListDto<>();
+ time2ObjectDto.setName(time2+"骞翠互涓�");
+ NameValueObjectDto<BattCapInfoDto> time2BadObjectDto = new NameValueObjectDto();
+ time2BadObjectDto.setName("鍔ｅ寲");
+ time2BadObjectDto.setValue(badListOfTime2.size()==0?new BattCapInfoDto():badListOfTime2.get(0));
+ NameValueObjectDto<BattCapInfoDto> time2DamageObjectDto = new NameValueObjectDto();
+ time2DamageObjectDto.setName("鎹熷潖");
+ time2DamageObjectDto.setValue(damageListOfTime2.size()==0?new BattCapInfoDto():damageListOfTime2.get(0));
+ time2ObjectDto.setValue(Arrays.asList(time2BadObjectDto,time2DamageObjectDto));
+ data2.add(time2ObjectDto);
+
+ return new Response().setII(1,data,data2,"");
+
+ }
+
+ public List<BattCapInfoDto> getBattCapInfo(List<BattInf> battInfList) {
+ //鑾峰彇鏍稿浼樺姡锛屾崯鍧忓弬鏁�
+ List<AppParam> paramList=appParamService.getHrParam();
+ Float badValue=0f;
+ Float damageValue=0f;
+ if(paramList!=null){
+ for (AppParam param:paramList) {
+ if(param.getParamNamePsx().equals("batt_mon_deteriorate_val")){
+ badValue=param.getParamValue();
+ }
+ if(param.getParamNamePsx().equals("batt_mon_damage_val")){
+ damageValue=param.getParamValue();
+ }
+
+ }
+ }
+ //1鏌ヨ绗﹀悎鏉′欢鐨勭數姹犵粍
+ if(battInfList==null||battInfList.size()==0){
+ //return new Response().set(1,false,"褰撳墠鐢ㄦ埛鏈鐞嗘弧瓒虫潯浠剁殑鐢垫睜缁�");
+ }
+ List<BattCapInfoDto> capInfoList = new ArrayList<>();
+
+ for (BattInf battInf:battInfList) {
+ BattCapInfoDto capInfo = new BattCapInfoDto();
+ capInfo.setStationName(battInf.getStationName());
+ capInfo.setBattGroupName(battInf.getBattgroupName());
+ capInfo.setDeviceName(battInf.getDevName());
+ capInfo.setProduct(battInf.getProduct());
+ capInfo.setInuseTime(battInf.getInuseTime());
+
+ //2.鑾峰彇鐢垫睜缁勫湪缁欏畾鏃堕棿娈电殑鏀剧數璁板綍(鎸囧畾鏃堕棿娈电殑鏍囧噯鏍稿鏀剧數)
+ BatttestdataInf testInf = battTestDataInfService.getLastStandardTestDataByTime(battInf.getBattgroupId(), battInf.getInuseTime(),null);
+ if (testInf == null) {
+ capInfo.setRealCap(0f);
+ capInfo.setCapPercentage("0");
+ capInfo.setPerformance(Capperformance.BATTSTATE_4.getStateName());
+ continue;
+ }
+ //鎵捐繖娆℃斁鐢电殑鏈�鍚庝竴绗旀暟鎹�
+ List<BatttestdataId> idDataList = battTestDataIdService.getLastDataByBattgroupId(testInf.getBattgroupId(), testInf.getTestRecordCount(), testInf.getRecordNum());
+ if (idDataList == null || idDataList.size() == 0) {
+ capInfo.setRealCap(0f);
+ capInfo.setCapPercentage("0");
+ capInfo.setPerformance(Capperformance.BATTSTATE_4.getStateName());
+ continue;
+ }
+ Float moncapStd = battInf.getMoncapstd();
+ int hourRate = BattCapFactory.GetHourRate(testInf.getTestCap(), testInf.getTestCurr());
+ Float groupRealCap = (float) BattCapFactory.GetMonomerCap(testInf.getTestCap(), hourRate, testInf.getTestCap(), testInf.getMaxMonvol(), testInf.getMinMonvol(), testInf.getGroupVol(), BattCapFactory.CapType_Real);
+ capInfo.setRealCap(groupRealCap);
+ if (groupRealCap >= moncapStd * badValue) {
+ capInfo.setPerformance(Capperformance.BATTSTATE_1.getStateName());
+ }
+ if (groupRealCap <= moncapStd * damageValue) {
+ capInfo.setPerformance(Capperformance.BATTSTATE_3.getStateName());
+ }
+ if ((groupRealCap > moncapStd * damageValue) && (groupRealCap < moncapStd * badValue)) {
+ capInfo.setPerformance(Capperformance.BATTSTATE_2.getStateName());
+ }
+ //淇濈暀5浣嶅皬鏁�
+ String capPercentage = String.format("%.5f", (groupRealCap / battInf.getMoncapstd() * 100));
+ capInfo.setCapPercentage(capPercentage);
+
+ capInfoList.add(capInfo);
+ }
+ return capInfoList;
+ }
+
}
--
Gitblit v1.9.1