.gitignore

@@ -4,4 +4,5 @@
target/
/src/main/webapp/
powerIntelligenceSystem.iml
.class
.class
/web_logs/

 src/main/java/com/whyc/controller/DeviceSetparamController.java

@@ -40,6 +40,11 @@
    public Response startDis(@RequestParam int devId, @RequestParam int battGroupNum) {
        return service.startDis(devId, battGroupNum);
    }
    @ApiOperation("远程停止核容测试")
    @GetMapping("stopDis")
    public Response stopDis(@RequestParam int devId, @RequestParam int battGroupNum) {
        return service.stopDis(devId, battGroupNum);
    }

    @ApiOperation("内阻测试")
    @GetMapping("startRes")

 src/main/java/com/whyc/dto/AlarmDto.java

New file
@@ -0,0 +1,62 @@
package com.whyc.dto;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;

import java.util.Date;

/**
 * 告警信息的统计字段,便于三种类型告警信息的统一统计
 */
@Data
@ToString
public class AlarmDto {

    private Integer stationId;

    private String stationName;

    private Integer powerId;

    private String powerName;

    private Integer devId;

    private String devName;

    private Integer battGroupId;

    private String battGroupName;

    @ApiModelProperty("告警属于哪种设备.1-电源,2-设备,3-电池")
    private String type;

    @ApiModelProperty("单体编号")
    private Integer monNum;

    @ApiModelProperty("单体编号集合,多个单体编号用,隔开")
    private String monNumStr;

    @ApiModelProperty("告警id,其中电池告警中代表alm_signal_id")
    private int almId;

    @ApiModelProperty("告警名称")
    private String almName;

    @ApiModelProperty("告警值")
    private Float almValue;

    @ApiModelProperty("整流器名合并")
    private String rectifierName;

    @ApiModelProperty("电池告警的告警id字段,保留")
    private Integer almIdOrigin;

    private Integer almLevel;
    private Date almStartTime;



}

 src/main/java/com/whyc/dto/BattCapInfoDto.java

New file
@@ -0,0 +1,39 @@
package com.whyc.dto;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;

import java.util.Date;

/**
 * 蓄电池容量计算信息
 */
@ToString
@Data
@ApiModel(description="蓄电池容量计算信息")
public class BattCapInfoDto {

    private String stationName;

    private String deviceName;

    private String battGroupName;

    @ApiModelProperty(value = "品牌")
    private String product;

    @ApiModelProperty(value = "使用时间")
    private Date inuseTime;

    @ApiModelProperty(value = "电池性能判断:优良,劣化,损坏")
    private String performance;



    private Float realCap;

    private String capPercentage;

}

 src/main/java/com/whyc/dto/NameValueIntDto.java

New file
@@ -0,0 +1,20 @@
package com.whyc.dto;

import lombok.Data;
import lombok.ToString;

@ToString
@Data
public class NameValueIntDto {

    private String name;
    private Integer value;

    public NameValueIntDto() {
    }

    public NameValueIntDto(String name, Integer value) {
        this.name = name;
        this.value = value;
    }
}

 src/main/java/com/whyc/dto/NameValueListDto.java

New file
@@ -0,0 +1,22 @@
package com.whyc.dto;

import lombok.Data;
import lombok.ToString;

import java.util.List;

@ToString
@Data
public class NameValueListDto<T> {

    private String name;
    private List<T> value;

    public NameValueListDto() {
    }

    public NameValueListDto(String name, List<T> value) {
        this.name = name;
        this.value = value;
    }
}

 src/main/java/com/whyc/dto/NameValueObjectDto.java

New file
@@ -0,0 +1,20 @@
package com.whyc.dto;

import lombok.Data;
import lombok.ToString;

@ToString
@Data
public class NameValueObjectDto<T> {

    private String name;
    private T value;

    public NameValueObjectDto() {
    }

    public NameValueObjectDto(String name, T value) {
        this.name = name;
        this.value = value;
    }
}

 src/main/java/com/whyc/mapper/BattInfMapper.java

@@ -56,6 +56,9 @@
    List<BattInf> getDischrChart(@Param("uid") Integer uid);

    List<BattInf> getListByUserId(Integer userId);

    List<BattInf> getListByCondition(Integer userId, BattInf battInf);

    //获取站点下的电池组(下拉)
    List<BattInf> getBattByUid(@Param("uid") Integer uid, @Param("provice") String provice, @Param("city") String city, @Param("country") String country, @Param("stationName") String stationName);
    //根据查询条件获取电池组集合

 src/main/java/com/whyc/mapper/BattalarmDataMapper.java

@@ -1,5 +1,6 @@
package com.whyc.mapper;

import com.whyc.dto.AlarmDto;
import com.whyc.dto.Real.AlmDto;
import com.whyc.pojo.db_alarm.BattalarmData;
import com.whyc.pojo.web_site.AlarmInspection;
@@ -12,4 +13,6 @@

    List<AlarmInspection> getListGreatThan(Long battAlarmId);

    List<AlarmDto> getListByUserId(Integer userId);

}

 src/main/java/com/whyc/mapper/DevalarmDataMapper.java

@@ -1,5 +1,6 @@
package com.whyc.mapper;

import com.whyc.dto.AlarmDto;
import com.whyc.dto.Real.AlmDto;
import com.whyc.pojo.db_alarm.BattalarmData;
import com.whyc.pojo.db_alarm.DevalarmData;
@@ -12,4 +13,7 @@
    List<DevalarmData> getDevAlmReal(AlmDto almDto);

    List<AlarmInspection> getListGreatThan(Long devAlarmId);

    List<AlarmDto> getListByUserId(Integer userId);

}

 src/main/java/com/whyc/mapper/PwrdevAlarmMapper.java

@@ -1,5 +1,6 @@
package com.whyc.mapper;

import com.whyc.dto.AlarmDto;
import com.whyc.dto.Real.AlmDto;
import com.whyc.pojo.db_pwrdev_alarm.PwrdevAlarm;
import com.whyc.pojo.web_site.AlarmInspection;
@@ -12,4 +13,6 @@

    List<AlarmInspection> getListGreatThan(Long id);

    List<AlarmDto> getListByUserId(Integer userId);

}

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

@@ -37,7 +37,7 @@
            PageHelper.startPage(1,1);
            QueryWrapper queryWrapper=new QueryWrapper();
            queryWrapper.eq("dev_id",devId);
            for(int n=0; n<40; n++)
            for(int n=0; n<1; n++)
            {

                AlmparamFromDevice param=mapper.selectOne(queryWrapper);

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

@@ -204,6 +204,9 @@
        if(sinf.getLatitude()!=null){
            wrapper1.set("latitude",sinf.getLatitude());
        }
        if(sinf.getNodeStation()!=null){
            wrapper1.set("node_station",sinf.getNodeStation());
        }
        wrapper1.eq("station_id",sinf.getStationId());

        //再修改电源信息
@@ -479,6 +482,10 @@
        return mapper.getListByUserId(userId);
    }

    public List<BattInf> getListByCondition(Integer userId, BattInf battInf) {
        return mapper.getListByCondition(userId, battInf);
    }

    //获取站点下的电池组(下拉)
    public Response getBattByUid(Integer uid, String provice, String city, String country, String stationName) {
        List<BattInf> list=mapper.getBattByUid(uid,provice,city,country,stationName);

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

@@ -8,6 +8,7 @@
import com.whyc.constant.BattAlarmIdEnum;
import com.whyc.constant.BattSingalIdEnum;
import com.whyc.constant.DevAlarmEnum;
import com.whyc.dto.AlarmDto;
import com.whyc.dto.Real.AlmDto;
import com.whyc.dto.Response;
import com.whyc.mapper.BattalarmDataMapper;
@@ -73,6 +74,10 @@
        return listGreatThan;
    }

    public List<AlarmDto> getListByUserId(Integer userId) {
        return mapper.getListByUserId(userId);
    }

    public List<Long> getNumListInDB(List<Long> battAlarmNumList) {
        QueryWrapper<BattalarmData> query = Wrappers.query();
        query.select("num");

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

@@ -121,7 +121,7 @@
    }

    //获取电池组在给定时间段的放电记录(指定时间段的标准核容放电)
    private BatttestdataInf getLastStandardTestDataByTime(Integer battgroupId, Date testStartTime, Date testEndTime) {
    protected BatttestdataInf getLastStandardTestDataByTime(Integer battgroupId, Date testStartTime, Date testEndTime) {
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("battgroup_id", battgroupId);
        wrapper.eq("test_type", 3);

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

@@ -8,6 +8,7 @@
import com.whyc.constant.BattAlarmIdEnum;
import com.whyc.constant.BattSingalIdEnum;
import com.whyc.constant.DevAlarmEnum;
import com.whyc.dto.AlarmDto;
import com.whyc.dto.Real.AlmDto;
import com.whyc.dto.Response;
import com.whyc.mapper.DevalarmDataMapper;
@@ -79,4 +80,8 @@
        query.in("num",devAlarmNumList);
        return mapper.selectList(query).stream().map(DevalarmData::getNum).collect(Collectors.toList());
    }

    public List<AlarmDto> getListByUserId(Integer userId) {
        return mapper.getListByUserId(userId);
    }
}

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

@@ -107,6 +107,11 @@
        boolean bl = sendCmdToDev(DevCmd.CMD_Start,DevCmd.CMD_StartDischarge, devId, battGroupNum);
        return new Response().set(1,bl,bl==true?"远程核容成功!":"远程核容失败!");
    }
    //远程停止核容测试
    public Response stopDis(int devId, int battGroupNum) {
        boolean bl = sendCmdToDev(DevCmd.CMD_Stop,DevCmd.CMD_StopDischarge, devId, battGroupNum);
        return new Response().set(1,bl,bl==true?"远程停止核容成功!":"远程停止核容失败!");
    }
    //内阻测试
    public Response startRes(int devId, int battGroupNum) {
        boolean bl = sendCmdToDev(DevCmd.CMD_Start,DevCmd.CMD_StartResDischarge, devId, battGroupNum);
@@ -114,7 +119,8 @@
    }
    //停止内阻测试
    public Response stopRes(int devId, int battGroupNum) {
        boolean bl = sendCmdToDev(DevCmd.CMD_Stop,DevCmd.CMD_StopDischarge, devId, battGroupNum);
        boolean bl = sendCmdToDev(DevCmd.CMD_Stop,DevCmd.CMD_StopResDischarge, devId, battGroupNum);
        return new Response().set(1,bl,bl==true?"停止内阻测试成功!":"停止内阻测试失败!");
    }

}

 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);
        //合并单体告警的告警信息,对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);
        //对告警名称赋值
        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) -> {
            //对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);
    }


    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,和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()))
                .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和time2的单位为年
        int time1 = 3;
        int time2 = 5;

        //筛选battCapInfoList中对象的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());
        //在time1和time2之间的数据
        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;
    }

}

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

@@ -7,6 +7,7 @@
import com.github.pagehelper.PageInfo;
import com.whyc.constant.DevAlarmEnum;
import com.whyc.constant.PowerAlarmEnum;
import com.whyc.dto.AlarmDto;
import com.whyc.dto.Real.AlmDto;
import com.whyc.dto.Response;
import com.whyc.mapper.PwrdevAlarmMapper;
@@ -79,4 +80,8 @@
        query.in("num",powerAlarmNumList);
        return mapper.selectList(query).stream().map(PwrdevAlarm::getNum).collect(Collectors.toList());
    }

    public List<AlarmDto> getListByUserId(Integer userId) {
        return mapper.getListByUserId(userId);
    }
}

 src/main/java/com/whyc/util/DateUtil.java

@@ -743,4 +743,11 @@
                .atZone(ZoneId.systemDefault())
                .toLocalDateTime();
    }

    /**
     * LocalDateTime转 Date
     */
    public static Date convertToDate(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }
}

 src/main/java/com/whyc/webSocket/LeaderHomeSocket.java

@@ -14,7 +14,6 @@

/**
 * 领导层首页
 * 不关联包机组,查看的是所有的数据
 */
@Component
@ServerEndpoint(value = "/leaderHome",encoders = WebSocketEncoder.class,configurator = WebSocketConfig.class)

 src/main/java/com/whyc/webSocket/LeaderHomeSubModule1Socket.java

New file
@@ -0,0 +1,85 @@
package com.whyc.webSocket;

import com.whyc.config.WebSocketConfig;
import com.whyc.dto.NameValueIntDto;
import com.whyc.dto.Response;
import com.whyc.pojo.db_user.User;
import com.whyc.service.LeaderHomeService;
import com.whyc.util.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpSession;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

/**
 * 领导层首页 子模块
 * 同品牌同时间
 */
@Component
@ServerEndpoint(value = "/leaderHome/BattSameTimeSameBrand",encoders = WebSocketEncoder.class,configurator = WebSocketConfig.class)
public class LeaderHomeSubModule1Socket {

    private Session session;

    private Thread thread;

    private static HttpSession httpSession;
    private static LeaderHomeService leaderHomeService;

    @Autowired
    public void setLeaderHomeService(LeaderHomeService leaderHomeService) {
        LeaderHomeSubModule1Socket.leaderHomeService = leaderHomeService;
    }

    @OnOpen
    public void onOpen(Session session, EndpointConfig config){
        this.session = session;
        httpSession = (HttpSession) config.getUserProperties().get("httpSession");
    }

    @OnMessage
    public void onMessage(Session session, String message) {
        //value为投运时间,年为单位
        //name为品牌
        NameValueIntDto nameValueDto = JsonUtil.getGson().fromJson(message, NameValueIntDto.class);
        User user = (User) httpSession.getAttribute("user");
        Integer userId = user.getId();
        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    while (!currentThread().isInterrupted()) {
                        Response response = leaderHomeService.getBattPerformanceOfSameTimeSameBrand(userId, nameValueDto);
                        session.getBasicRemote().sendObject(new Response().set(1, response));
                        sleep(4000);
                    }
                } catch (Exception e) {
                    this.interrupt();
                }
            }
        };
        thread.start();
        this.thread = thread;
    }

    @OnClose
    public void onClose(CloseReason closeReason) throws IOException {
        System.err.println("closeReason = " + closeReason);
        if(session.isOpen()){
            session.close();
        }
    }

    @OnError
    public void onError(Throwable error) throws IOException {
        error.printStackTrace();
        thread.isInterrupted();
        if(session.isOpen()){
            session.close();
        }
    }

}

 src/main/java/com/whyc/webSocket/LeaderHomeSubModule2Socket.java

New file
@@ -0,0 +1,84 @@
package com.whyc.webSocket;

import com.whyc.config.WebSocketConfig;
import com.whyc.dto.NameValueIntDto;
import com.whyc.dto.Response;
import com.whyc.pojo.db_user.User;
import com.whyc.service.LeaderHomeService;
import com.whyc.util.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpSession;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

/**
 * 领导层首页 子模块
 * 同一时间不同品牌
 */
@Component
@ServerEndpoint(value = "/leaderHome/BattSameTimeDiffBrand",encoders = WebSocketEncoder.class,configurator = WebSocketConfig.class)
public class LeaderHomeSubModule2Socket {

    private Session session;

    private Thread thread;

    private static HttpSession httpSession;
    private static LeaderHomeService leaderHomeService;

    @Autowired
    public void setLeaderHomeService(LeaderHomeService leaderHomeService) {
        LeaderHomeSubModule2Socket.leaderHomeService = leaderHomeService;
    }

    @OnOpen
    public void onOpen(Session session, EndpointConfig config){
        this.session = session;
        httpSession = (HttpSession) config.getUserProperties().get("httpSession");
    }

    @OnMessage
    public void onMessage(Session session, String message) {
        //为投运时间,年为单位
        int year = Integer.parseInt(message);
        User user = (User) httpSession.getAttribute("user");
        Integer userId = user.getId();
        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    while (!currentThread().isInterrupted()) {
                        Response response = leaderHomeService.getBattPerformanceOfSameTimeDiffBrand(userId, year);
                        session.getBasicRemote().sendObject(new Response().set(1, response));
                        sleep(4000);
                    }
                } catch (Exception e) {
                    this.interrupt();
                }
            }
        };
        thread.start();
        this.thread = thread;
    }

    @OnClose
    public void onClose(CloseReason closeReason) throws IOException {
        System.err.println("closeReason = " + closeReason);
        if(session.isOpen()){
            session.close();
        }
    }

    @OnError
    public void onError(Throwable error) throws IOException {
        error.printStackTrace();
        thread.isInterrupted();
        if(session.isOpen()){
            session.close();
        }
    }

}

 src/main/java/com/whyc/webSocket/LeaderHomeSubModule3Socket.java

New file
@@ -0,0 +1,82 @@
package com.whyc.webSocket;

import com.whyc.config.WebSocketConfig;
import com.whyc.dto.Response;
import com.whyc.pojo.db_user.User;
import com.whyc.service.LeaderHomeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpSession;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

/**
 * 领导层首页 子模块
 * 不同时间同一品牌
 */
@Component
@ServerEndpoint(value = "/leaderHome/BattDiffTimeSameBrand",encoders = WebSocketEncoder.class,configurator = WebSocketConfig.class)
public class LeaderHomeSubModule3Socket {

    private Session session;

    private Thread thread;

    private static HttpSession httpSession;
    private static LeaderHomeService leaderHomeService;

    @Autowired
    public void setLeaderHomeService(LeaderHomeService leaderHomeService) {
        LeaderHomeSubModule3Socket.leaderHomeService = leaderHomeService;
    }

    @OnOpen
    public void onOpen(Session session, EndpointConfig config){
        this.session = session;
        httpSession = (HttpSession) config.getUserProperties().get("httpSession");
    }

    @OnMessage
    public void onMessage(Session session, String message) {
        //为品牌
        String brand = message;
        User user = (User) httpSession.getAttribute("user");
        Integer userId = user.getId();
        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    while (!currentThread().isInterrupted()) {
                        Response response = leaderHomeService.getBattPerformanceOfDiffTimeSameBrand(userId, brand);
                        session.getBasicRemote().sendObject(new Response().set(1, response));
                        sleep(4000);
                    }
                } catch (Exception e) {
                    this.interrupt();
                }
            }
        };
        thread.start();
        this.thread = thread;
    }

    @OnClose
    public void onClose(CloseReason closeReason) throws IOException {
        System.err.println("closeReason = " + closeReason);
        if(session.isOpen()){
            session.close();
        }
    }

    @OnError
    public void onError(Throwable error) throws IOException {
        error.printStackTrace();
        thread.isInterrupted();
        if(session.isOpen()){
            session.close();
        }
    }

}

 src/main/resources/mapper/BattInfMapper.xml

@@ -426,6 +426,20 @@
            and bu.uid = #{userId}
        )
    </select>
    <select id="getListByCondition" resultType="com.whyc.pojo.db_station.BattInf">
        select * from db_station.tb_batt_inf where
        <if test="product!=null">
            and product=#{product}
        </if>
        <if test="inuseTime!=null">
            and inuse_time >= #{inuseTime}
        </if>
        and battgroup_id in(
        select distinct battgroup_id from db_user.tb_baojigroup_usr bu,db_user.tb_baojigroup_power bp,db_station.tb_batt_inf bi
        where bu.baoji_group_id = bp.baoji_group_id
        and bp.station_id = bi.station_id
        and bu.uid = #{userId}
    </select>

    <select id="getBattByUid" resultType="com.whyc.pojo.db_station.BattInf">
        select distinct * from db_station.tb_batt_inf,db_station.tb_station_inf

 src/main/resources/mapper/BattalarmDataMapper.xml

@@ -51,4 +51,16 @@
        and bi.station_id=si.station_id
        and bd.num>#{id}
    </select>
    <select id="getListByUserId" resultType="com.whyc.dto.AlarmDto">
        select bd.mon_num,bd.alm_signal_id as alm_id,bd.alm_id as alm_id_origin,bd.alm_level,bd.alm_start_time,
        bd.num as alm_num,bi.battgroup_id,bi.battgroup_name,bi.dev_id,bi.dev_name,si.station_id,si.station_name from db_alarm.tb_battalarm_data bd,db_station.tb_batt_inf bi,db_station.tb_station_inf si
        where bd.battgroup_id=bi.battgroup_id
        and bi.station_id=si.station_id
        and bd.battgroup_id in(
            select distinct battgroup_id from db_user.tb_baojigroup_usr bu,db_user.tb_baojigroup_power bp,db_station.tb_batt_inf bi
            where bu.baoji_group_id = bp.baoji_group_id
            and bp.station_id = bi.station_id
            and bu.uid = #{userId}
        )
    </select>
</mapper>

 src/main/resources/mapper/DevalarmDataMapper.xml

@@ -49,4 +49,15 @@
        and bi.station_id=si.station_id
        and dd.num>#{id}
    </select>
    <select id="getListByUserId" resultType="com.whyc.dto.AlarmDto">
        select distinct dd.*,dd.num as alm_num,bi.dev_id,bi.dev_name,si.station_id,si.station_name from db_alarm.tb_devalarm_data dd,db_station.tb_batt_inf bi,db_station.tb_station_inf si
        where dd.dev_id=bi.dev_id
        and bi.station_id=si.station_id
        and dd.dev_id in (
            select distinct dev_id from db_user.tb_baojigroup_usr bu,db_user.tb_baojigroup_power bp,db_station.tb_batt_inf bi
            where bu.baoji_group_id = bp.baoji_group_id
            and bp.station_id = bi.station_id
            and bu.uid = #{userId}
        )
    </select>
</mapper>

 src/main/resources/mapper/PwrdevAlarmMapper.xml

@@ -50,4 +50,14 @@
        and pi.station_id=si.station_id
        and pa.num>#{id}
    </select>
    <select id="getListByUserId" resultType="com.whyc.dto.AlarmDto">
        select pa.*,pa.num as alm_num,pi.power_name,pi.power_id,si.station_id,si.station_name from db_pwrdev_alarm.tb_pwrdev_alarm pa,db_station.tb_power_inf pi,db_station.tb_station_inf si
        where pa.power_id=pi.power_id
        and pi.station_id=si.station_id
        and pa.power_id in (
            select distinct power_id from db_user.tb_baojigroup_usr bu,db_user.tb_baojigroup_power bp
            where bu.baoji_group_id = bp.baoji_group_id
            and bu.uid = #{userId}
        )
    </select>
</mapper>

 web_logs/battery_gwm-2025-05-14.0.log

File was deleted

 web_logs/battery_gwm-2025-05-15.0.log

File was deleted

 web_logs/battery_gwm-2025-05-16.0.log

File was deleted

 web_logs/battery_gwm-2025-05-17.0.log

File was deleted

 web_logs/battery_gwm-2025-05-19.0.log

File was deleted

 web_logs/battery_gwm-2025-05-20.0.log

File was deleted

 web_logs/battery_gwm-2025-05-21.0.log

File was deleted

 web_logs/battery_gwm-2025-05-22.0.log

File was deleted

 web_logs/battery_gwm-2025-05-23.0.log

File was deleted

 web_logs/battery_gwm-2025-05-26.0.log

File was deleted

 web_logs/battery_gwm-2025-05-27.0.log

File was deleted

 web_logs/battery_gwm-2025-05-28.0.log

File was deleted

 web_logs/battery_gwm-2025-05-29.0.log

File was deleted

 web_logs/battery_gwm-2025-05-30.0.log

File was deleted

 web_logs/battery_gwm-2025-06-03.0.log

File was deleted

 web_logs/battery_gwm-2025-06-04.0.log

File was deleted

 web_logs/battery_gwm-2025-06-05.0.log

File was deleted

 web_logs/battery_gwm-2025-06-06.0.log

File was deleted

 web_logs/battery_gwm-2025-06-07.0.log

File was deleted

 web_logs/battery_gwm-2025-06-09.0.log

File was deleted

 web_logs/battery_gwm-2025-06-10.0.log

File was deleted

 web_logs/battery_gwm-2025-06-11.0.log

File was deleted

 web_logs/battery_gwm-2025-06-12.0.log

File was deleted

 web_logs/battery_gwm.log

File was deleted