文档类型管理更新

whycxzp

89 分钟以前 e5b3e3492a7d5f079cad2ca5958a724cabfec401

 src/main/java/com/whyc/service/LeaderHomeService.java

@@ -1,7 +1,9 @@
package com.whyc.service;

import com.sun.org.glassfish.gmbal.NameValue;
import com.whyc.constant.Capperformance;
import com.whyc.constant.BattSingalIdEnum;
import com.whyc.constant.BattCapperformanceEnum;
import com.whyc.constant.DevAlarmEnum;
import com.whyc.constant.PowerAlarmEnum;
import com.whyc.dto.*;
import com.whyc.factory.BattCapFactory;
import com.whyc.factory.ThreadPoolExecutorFactory;
@@ -15,6 +17,8 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
@@ -57,7 +61,6 @@
    private BatttestdataIdService battTestDataIdService;



    public Response getAll(Integer userId) {
        Response response = new Response();
        Map<String,Object> map = new HashMap<>();
@@ -86,25 +89,606 @@
            testDataInfoStatistics(userId, map);
            latch.countDown();
        });
        //TODO 设备数量信息统计
        //10类基础资产信息统计
        poolExecutor.execute(() -> {
            //deviceInfoStatistics(userId, map);
            deviceInfoStatistics(userId, map);
            latch.countDown();
        });
        //TODO 实时告警信息统计

        /**
         * 实时告警信息统计
         * 逻辑更新:
         * 电池里面的单体(单体1,单体2..)单项,可以合并. 电源里面的整流器(整流器1,整流器2..)告警单项可以合并
         * 合并后时间采用最先产生报警的那个时间
         */
        poolExecutor.execute(() -> {
            //alarmRealtimeStatistics(userId, map);
            alarmRealtimeStatistics(userId, map);
            latch.countDown();
        });

        return response;
    }

    private void deviceInfoStatistics(Integer userId, Map<String, Object> map) {
        NameValueIntDto baseDto = new NameValueIntDto();
        int powerCount = powerInfService.getListByUserId(userId).size();
        map.put("powerCount", powerCount);
        List<BattInf> battInfList = battInfService.getListByUserId(userId);
        int battCount = battInfList.size();
        Map<Integer, List<BattInf>> devIdMap = battInfList.stream().collect(Collectors.groupingBy(BattInf::getDevId));
        map.put("devCount", devIdMap.size());
        map.put("battCount",battCount);
        int monCountTotal = 0;
        for (int i = 0; i < battCount; i++) {
            int monCount = battInfList.get(i).getMoncount().intValue();
            monCountTotal += monCount;
        }
        map.put("monCount", monCountTotal);

    private void testDataInfoStatistics(Integer userId, Map<String, Object> map) {
        LocalDateTime now = LocalDateTime.now();
        //本年第一天
        LocalDateTime yearStart = now.withDayOfYear(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
        Date yearStartTime = DateUtil.convertToDate(yearStart);
        //去年的第一天
        LocalDateTime lastYearStart = now.minusYears(1).withDayOfYear(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
        //去年的最后一天
        int lastYear = now.minusYears(1).getYear();
        LocalDate lastDayOfLastYear = LocalDate.of(lastYear, 12, 31);
        LocalDateTime lastYearEnd = lastDayOfLastYear.atTime(LocalTime.MAX);
        Date lastYearStartTime = DateUtil.convertToDate(lastYearStart);
        Date lastYearEndTime = DateUtil.convertToDate(lastYearEnd);

        //本年已放电电池数量
        //本年未放电电池数量
        //去年已放电电池数量
        //去年未放电电池数量
        int hrDisBattCount = battTestDataInfService.getHrDisCount(userId,yearStartTime,null);
        int hrNoDisBattCount = battCount - hrDisBattCount;
        int hrDisBattCountLastYear = battTestDataInfService.getHrDisCount(userId,lastYearStartTime,lastYearEndTime);
        int hrNoDisBattCountLastYear = battCount - hrDisBattCountLastYear;
        map.put("hrDisBattCount", hrDisBattCount);
        map.put("hrNoDisBattCount", hrNoDisBattCount);
        map.put("hrDisBattCountLastYear", hrDisBattCountLastYear);
        map.put("hrNoDisBattCountLastYear", hrNoDisBattCountLastYear);

        //本年优良劣化损坏数量
        List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList,yearStartTime,null);
        long battGoodCount = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_1.getStateName())).count();
        long battBadCount = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_2.getStateName())).count();
        long battDamageCount = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName())).count();
        //去年优良劣化损坏数量
        List<BattCapInfoDto> battCapInfoListLastYear = getBattCapInfo(battInfList,lastYearStartTime,lastYearEndTime);
        long battGoodCountLastYear = battCapInfoListLastYear.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_1.getStateName())).count();
        long battBadCountLastYear = battCapInfoListLastYear.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_2.getStateName())).count();
        long battDamageCountLastYear = battCapInfoListLastYear.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName())).count();
        map.put("battGoodCount", battGoodCount);
        map.put("battBadCount", battBadCount);
        map.put("battDamageCount", battDamageCount);
        map.put("battGoodCountLastYear", battGoodCountLastYear);
        map.put("battBadCountLastYear", battBadCountLastYear);
        map.put("battDamageCountLastYear", battDamageCountLastYear);
        //TODO 优良电源数量
        map.put("powerGoodCount","优良判定标准待确定" );
    }


    private void alarmRealtimeStatistics(Integer userId, Map<String, Object> map) {
        //电池告警信息统计
        List<AlarmDto> battAlarmListNew = new ArrayList<>();
        List<AlarmDto> battAlarmList = battAlarmService.getListByUserId(userId, null);
        //合并单体告警的告警信息,对AlarmDto中AlmId 在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) -> {
            //对list内的字段 单体编号进行合并. 时间取最小的
            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,null);
        //对告警名称赋值
        devAlarmList.forEach(alarmDto -> {
            alarmDto.setAlmName(DevAlarmEnum.getValue(alarmDto.getAlmId()));
        });

        //电源告警信息统计
        List<AlarmDto> powerAlarmListNew = new ArrayList<>();
        List<AlarmDto> powerAlarmList = powerAlarmService.getListByUserId(userId,null);
        //整流器总故障合并
        //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) -> {
            //对list内的字段 整流器编号进行合并,合并到rectifierName. 时间取最小的
            List<AlarmDto> mergeList = list.stream()
                    .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
                    .collect(Collectors.toList());
            AlarmDto alarmDto = mergeList.get(0);
            //按告警id排序
            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) -> {
            //对list内的字段 整流器编号进行合并,合并到rectifierName. 时间取最小的
            List<AlarmDto> mergeList = list.stream()
                    .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
                    .collect(Collectors.toList());
            AlarmDto alarmDto = mergeList.get(0);
            //按告警id排序
            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) -> {
            //对list内的字段 整流器编号进行合并,合并到rectifierName. 时间取最小的
            List<AlarmDto> mergeList = list.stream()
                    .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
                    .collect(Collectors.toList());
            AlarmDto alarmDto = mergeList.get(0);
            //按告警id排序
            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) -> {
            //对list内的字段 整流器编号进行合并,合并到rectifierName. 时间取最小的
            List<AlarmDto> mergeList = list.stream()
                    .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
                    .collect(Collectors.toList());
            AlarmDto alarmDto = mergeList.get(0);
            //按告警id排序
            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) -> {
            //对list内的字段 整流器编号进行合并,合并到rectifierName. 时间取最小的
            List<AlarmDto> mergeList = list.stream()
                    .sorted(Comparator.comparing(AlarmDto::getAlmStartTime))
                    .collect(Collectors.toList());
            AlarmDto alarmDto = mergeList.get(0);
            //按告警id排序
            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()));
        });
        //对存在RectifierName的元素,将rectifierName字段赋值给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);
    }


    protected void testDataInfoStatistics(Integer userId, Map<String, Object> map) {
        List<BatttestdataInf> testInfList = battTestDataInfService.getListByUserId(userId);
        //过滤出本月的
        LocalDateTime startOfMonth = DateUtil.getStartOfMonth();
@@ -181,7 +765,7 @@
        return testInfOfMonth;
    }

    private void batteryInfoStatistics(Integer userId, Map<String, Object> map) {
    protected void batteryInfoStatistics(Integer userId, Map<String, Object> map) {
        List<BattInf> battInfList = battInfService.getListByUserId(userId);
        Map<String, List<BattInf>> brandMap = battInfList.stream().collect(Collectors.groupingBy(BattInf::getProduct));
        Map<Float, List<BattInf>> volMap = battInfList.stream().collect(Collectors.groupingBy(BattInf::getMonvolstd));
@@ -201,7 +785,7 @@
        map.put("battGroupInfo_vol",volList);
    }

    private void powerInfoStatistics(Integer userId, Map<String, Object> map) {
    protected void powerInfoStatistics(Integer userId, Map<String, Object> map) {
        List<PowerInf> powerInfList = powerInfService.getListByUserId(userId);
        Map<String, List<PowerInf>> brandMap = powerInfList.stream().collect(Collectors.groupingBy(PowerInf::getCompany));
        Map<Integer, List<PowerInf>> typeMap = powerInfList.stream().collect(Collectors.groupingBy(PowerInf::getPowerType));
@@ -271,12 +855,12 @@
        battInf.setProduct(brand);
        //查询满足条件的蓄电池列表
        List<BattInf> battInfList = battInfService.getListByCondition(userId,battInf);
        List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList);
        List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList,null,null);
        //data,和data2分别返回 统计数量和 站点优良,劣化,损坏 前二的信息
        List<NameValueIntDto> data = new ArrayList<>();
        List<NameValueListDto> data2 = new ArrayList<>();
        //筛选出 站点优良,劣化,损坏 的电池组,并按照这个字段分组
        List<BattCapInfoDto> goodList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_1.getStateName()))
        List<BattCapInfoDto> goodList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_1.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap).reversed()).collect(Collectors.toList());
        if(goodList.size()==0){
            data.add(new NameValueIntDto("优良",0));
@@ -285,7 +869,7 @@
            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()))
        List<BattCapInfoDto> badList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_2.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
        if(badList.size()==0){
            data.add(new NameValueIntDto("劣化",0));
@@ -294,7 +878,7 @@
            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()))
        List<BattCapInfoDto> damageList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
        if(damageList.size()==0){
            data.add(new NameValueIntDto("损坏",0));
@@ -315,16 +899,16 @@
        battInf.setInuseTime(inuseTimeStart);
        //查询满足条件的蓄电池列表
        List<BattInf> battInfList = battInfService.getListByCondition(userId,battInf);
        List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList);
        List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList,null,null);

        //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 goodCount = battCapInfoListTemp.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_1.getStateName())).count();
            long badCount = battCapInfoListTemp.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_2.getStateName())).count();
            long damageCount = battCapInfoListTemp.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName())).count();
            long total = goodCount  + badCount + damageCount;
            //良好,劣化,损坏的百分比.（保留0位小数）
            int goodPercent = Math.round((float) goodCount / total * 100);
@@ -341,7 +925,7 @@
        });
        //data2,优良里面最大的和最小的品牌
        List<NameValueListDto<NameValueDto>> data2 = new ArrayList<>();
        List<BattCapInfoDto> goodList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_1.getStateName()))
        List<BattCapInfoDto> goodList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_1.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
        NameValueListDto<NameValueDto> goodListDto = new NameValueListDto<>();
        List<NameValueDto> goodListValue = new ArrayList<>();
@@ -363,7 +947,7 @@
        goodListDto.setValue(goodListValue);
        data2.add(goodListDto);
        //劣化里面最大的和最小的品牌
        List<BattCapInfoDto> badList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
        List<BattCapInfoDto> badList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_2.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
        NameValueListDto<NameValueDto> badListDto = new NameValueListDto<>();
        List<NameValueDto> badListValue = new ArrayList<>();
@@ -386,7 +970,7 @@
        data2.add(badListDto);

        //损坏里面最大的和最小的品牌
        List<BattCapInfoDto> damageList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_3.getStateName()))
        List<BattCapInfoDto> damageList = battCapInfoList.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());

        NameValueListDto<NameValueDto> damageListDto = new NameValueListDto<>();
@@ -422,7 +1006,7 @@
        battInf.setProduct(brand);
        //查询满足条件的蓄电池列表
        List<BattInf> battInfList = battInfService.getListByCondition(userId,battInf);
        List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList);
        List<BattCapInfoDto> battCapInfoList = getBattCapInfo(battInfList,null,null);

        //data,TODO 投运时间的维度参数,先固定变量,后续从数据库获取
        //time1和time2的单位为年
@@ -450,9 +1034,9 @@
        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()))
        List<BattCapInfoDto> badListOfTime1 = time1List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.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()))
        List<BattCapInfoDto> damageListOfTime1 = time1List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
        NameValueIntDto time1BadDto = new NameValueIntDto();
        time1BadDto.setName("劣化");
@@ -464,9 +1048,9 @@

        NameValueListDto<NameValueIntDto> time12Dto = new NameValueListDto<>();
        time12Dto.setName(time1+"-"+time2+"年");
        List<BattCapInfoDto> badListOfTime12 = time12List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
        List<BattCapInfoDto> badListOfTime12 = time12List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.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()))
        List<BattCapInfoDto> damageListOfTime12 = time12List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
        NameValueIntDto time12BadDto = new NameValueIntDto();
        time12BadDto.setName("劣化");
@@ -478,9 +1062,9 @@

        NameValueListDto<NameValueIntDto> time2Dto = new NameValueListDto<>();
        time2Dto.setName(time2+"年以上");
        List<BattCapInfoDto> badListOfTime2 = time2List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(Capperformance.BATTSTATE_2.getStateName()))
        List<BattCapInfoDto> badListOfTime2 = time2List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.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()))
        List<BattCapInfoDto> damageListOfTime2 = time2List.stream().filter(battCapInfo -> battCapInfo.getPerformance().equals(BattCapperformanceEnum.BATTSTATE_3.getStateName()))
                .sorted(Comparator.comparing(BattCapInfoDto::getRealCap)).collect(Collectors.toList());
        NameValueIntDto time2BadDto = new NameValueIntDto();
        time2BadDto.setName("劣化");
@@ -534,7 +1118,7 @@

    }

    public List<BattCapInfoDto> getBattCapInfo(List<BattInf> battInfList) {
    public List<BattCapInfoDto> getBattCapInfo(List<BattInf> battInfList,Date startTime, Date endTime) {
        //获取核容优劣，损坏参数
        List<AppParam> paramList=appParamService.getHrParam();
        Float badValue=0f;
@@ -565,11 +1149,12 @@
            capInfo.setInuseTime(battInf.getInuseTime());

            //2.获取电池组在给定时间段的放电记录(指定时间段的标准核容放电)
            BatttestdataInf testInf = battTestDataInfService.getLastStandardTestDataByTime(battInf.getBattgroupId(), battInf.getInuseTime(),null);
            //BatttestdataInf testInf = battTestDataInfService.getLastStandardTestDataByTime(battInf.getBattgroupId(), battInf.getInuseTime(),null);
            BatttestdataInf testInf = battTestDataInfService.getLastStandardTestDataByTime(battInf.getBattgroupId(), startTime,endTime);
            if (testInf == null) {
                capInfo.setRealCap(0f);
                capInfo.setCapPercentage("0");
                capInfo.setPerformance(Capperformance.BATTSTATE_4.getStateName());
                capInfo.setPerformance(BattCapperformanceEnum.BATTSTATE_4.getStateName());
                continue;
            }
            //找这次放电的最后一笔数据
@@ -577,21 +1162,21 @@
            if (idDataList == null || idDataList.size() == 0) {
                capInfo.setRealCap(0f);
                capInfo.setCapPercentage("0");
                capInfo.setPerformance(Capperformance.BATTSTATE_4.getStateName());
                capInfo.setPerformance(BattCapperformanceEnum.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);
            Float groupRealCap = (float) BattCapFactory.GetMonomerCap(battInf.getMoncapstd(), 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());
                capInfo.setPerformance(BattCapperformanceEnum.BATTSTATE_1.getStateName());
            }
            if (groupRealCap <= moncapStd * damageValue) {
                capInfo.setPerformance(Capperformance.BATTSTATE_3.getStateName());
                capInfo.setPerformance(BattCapperformanceEnum.BATTSTATE_3.getStateName());
            }
            if ((groupRealCap > moncapStd * damageValue) && (groupRealCap < moncapStd * badValue)) {
                capInfo.setPerformance(Capperformance.BATTSTATE_2.getStateName());
                capInfo.setPerformance(BattCapperformanceEnum.BATTSTATE_2.getStateName());
            }
            //保留5位小数
            String capPercentage = String.format("%.5f", (groupRealCap / battInf.getMoncapstd() * 100));