去除电池状态-均充

whycxzp

2021-10-12 d5cf76188ad37f062f37ebce3464097203b4db05

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

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

import com.whyc.constant.PowerAlarmConstant;
import com.whyc.constant.AlarmConstant;
import com.whyc.dto.Response;
import com.whyc.mapper.PowerAlarmMapper;
import com.whyc.mapper.PowerInfoMapper;
import com.whyc.pojo.PowerAlarm;
import com.whyc.util.MathUtil;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestParam;

@@ -15,6 +17,9 @@

    @Resource
    private PowerAlarmMapper mapper;

    @Resource
    private PowerInfoMapper infoMapper;

    public Response<Map> getACInputAnalysis(@RequestParam int userId){
        //交流输入-跳闸,
@@ -28,33 +33,33 @@
        resultMap.put("频率异常",0);

        ArrayList<Integer> types = new ArrayList<>();
        types.add(PowerAlarmConstant.acIn1_trip);
        types.add(PowerAlarmConstant.acIn2_trip);
        types.add(PowerAlarmConstant.acIn1_fuse);
        types.add(PowerAlarmConstant.acIn2_fuse);
        types.add(PowerAlarmConstant.acIn1_unbanlance);
        types.add(PowerAlarmConstant.acIn2_unbanlance);
        types.add(PowerAlarmConstant.acIn1_freqerr);
        types.add(PowerAlarmConstant.acIn2_freqerr);
        types.add(AlarmConstant.acIn1_trip);
        types.add(AlarmConstant.acIn2_trip);
        types.add(AlarmConstant.acIn1_fuse);
        types.add(AlarmConstant.acIn2_fuse);
        types.add(AlarmConstant.acIn1_unbanlance);
        types.add(AlarmConstant.acIn2_unbanlance);
        types.add(AlarmConstant.acIn1_freqerr);
        types.add(AlarmConstant.acIn2_freqerr);

        List<PowerAlarm> data = mapper.getAnalysis(userId,types);

        for (int i = 0; i < data.size(); i++) {
            switch (data.get(i).getAlarmType()){
                case PowerAlarmConstant.acIn1_trip:
                case PowerAlarmConstant.acIn2_trip:
                case AlarmConstant.acIn1_trip:
                case AlarmConstant.acIn2_trip:
                    resultMap.put("跳闸",resultMap.get("跳闸")+(data.get(i).getNum()).intValue());
                    break;
                case PowerAlarmConstant.acIn1_fuse:
                case PowerAlarmConstant.acIn2_fuse:
                case AlarmConstant.acIn1_fuse:
                case AlarmConstant.acIn2_fuse:
                    resultMap.put("熔丝告警",resultMap.get("熔丝告警")+(data.get(i).getNum()).intValue());
                    break;
                case PowerAlarmConstant.acIn1_unbanlance:
                case PowerAlarmConstant.acIn2_unbanlance:
                case AlarmConstant.acIn1_unbanlance:
                case AlarmConstant.acIn2_unbanlance:
                    resultMap.put("三相不平衡",resultMap.get("三相不平衡")+(data.get(i).getNum()).intValue());
                    break;
                case PowerAlarmConstant.acIn1_freqerr:
                case PowerAlarmConstant.acIn2_freqerr:
                case AlarmConstant.acIn1_freqerr:
                case AlarmConstant.acIn2_freqerr:
                    resultMap.put("频率异常",resultMap.get("频率异常")+(data.get(i).getNum()).intValue());
                    break;
                default:
@@ -82,33 +87,33 @@
        resultMap.put("开关柜总报警",0);

        ArrayList<Integer> types = new ArrayList<>();
        types.add(PowerAlarmConstant.acIn_total_alarm);
        types.add(PowerAlarmConstant.dcOut_total_alarm);
        types.add(PowerAlarmConstant.acIn1_thunder_err);
        types.add(PowerAlarmConstant.acIn_monitorerr);
        types.add(PowerAlarmConstant.comm_err);
        types.add(PowerAlarmConstant.total_alarm);
        types.add(AlarmConstant.acIn_total_alarm);
        types.add(AlarmConstant.dcOut_total_alarm);
        types.add(AlarmConstant.acIn1_thunder_err);
        types.add(AlarmConstant.acIn_monitorerr);
        types.add(AlarmConstant.comm_err);
        types.add(AlarmConstant.total_alarm);

        List<PowerAlarm> data = mapper.getAnalysis(userId,types);

        for (int i = 0; i < data.size(); i++) {
            switch (data.get(i).getAlarmType()){
                case PowerAlarmConstant.acIn_total_alarm:
                case AlarmConstant.acIn_total_alarm:
                    resultMap.put("交流总故障",data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.dcOut_total_alarm:
                case AlarmConstant.dcOut_total_alarm:
                    resultMap.put("直流总故障",data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acIn1_thunder_err:
                case AlarmConstant.acIn1_thunder_err:
                    resultMap.put("防雷器故障",data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acIn_monitorerr:
                case AlarmConstant.acIn_monitorerr:
                    resultMap.put("监控器故障",data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.comm_err:
                case AlarmConstant.comm_err:
                    resultMap.put("通讯故障",data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.total_alarm:
                case AlarmConstant.total_alarm:
                    resultMap.put("开关柜总报警",data.get(i).getNum().intValue());
                    break;
                default:
@@ -125,7 +130,7 @@
     * @return
     * @param userId
     */
    public Response<Map> getAcABCAnalysis(int userId){
    public Response<List> getAcABCAnalysis(int userId){

        //交流A/B/C-过压,
        //交流A/B/C-欠压,
@@ -138,41 +143,41 @@
        resultMap.put("过流",0);

        List<Integer> types = Arrays.asList(
                PowerAlarmConstant.acIn1_over_volA,
                PowerAlarmConstant.acIn1_over_volB,
                PowerAlarmConstant.acIn1_over_volC,
                PowerAlarmConstant.acIn1_under_volA,
                PowerAlarmConstant.acIn1_under_volB,
                PowerAlarmConstant.acIn1_under_volC,
                PowerAlarmConstant.acIn1_less_A,
                PowerAlarmConstant.acIn1_less_B,
                PowerAlarmConstant.acIn1_less_C,
                PowerAlarmConstant.acb1_over_currA,
                PowerAlarmConstant.acb1_over_currB,
                PowerAlarmConstant.acb1_over_currC);
                AlarmConstant.acIn1_over_volA,
                AlarmConstant.acIn1_over_volB,
                AlarmConstant.acIn1_over_volC,
                AlarmConstant.acIn1_under_volA,
                AlarmConstant.acIn1_under_volB,
                AlarmConstant.acIn1_under_volC,
                AlarmConstant.acIn1_less_A,
                AlarmConstant.acIn1_less_B,
                AlarmConstant.acIn1_less_C,
                AlarmConstant.acb1_over_currA,
                AlarmConstant.acb1_over_currB,
                AlarmConstant.acb1_over_currC);

        List<PowerAlarm> data = mapper.getAnalysis(userId,types);

        for (int i = 0; i < data.size(); i++) {
            switch (data.get(i).getAlarmType()){
                case PowerAlarmConstant.acIn1_over_volA:
                case PowerAlarmConstant.acIn1_over_volB:
                case PowerAlarmConstant.acIn1_over_volC:
                case AlarmConstant.acIn1_over_volA:
                case AlarmConstant.acIn1_over_volB:
                case AlarmConstant.acIn1_over_volC:
                    resultMap.put("过压",resultMap.get("过压")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acIn1_under_volA:
                case PowerAlarmConstant.acIn1_under_volB:
                case PowerAlarmConstant.acIn1_under_volC:
                case AlarmConstant.acIn1_under_volA:
                case AlarmConstant.acIn1_under_volB:
                case AlarmConstant.acIn1_under_volC:
                    resultMap.put("欠压",resultMap.get("欠压")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acIn1_less_A:
                case PowerAlarmConstant.acIn1_less_B:
                case PowerAlarmConstant.acIn1_less_C:
                case AlarmConstant.acIn1_less_A:
                case AlarmConstant.acIn1_less_B:
                case AlarmConstant.acIn1_less_C:
                    resultMap.put("缺相",resultMap.get("缺相")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acb1_over_currA:
                case PowerAlarmConstant.acb1_over_currB:
                case PowerAlarmConstant.acb1_over_currC:
                case AlarmConstant.acb1_over_currA:
                case AlarmConstant.acb1_over_currB:
                case AlarmConstant.acb1_over_currC:
                    resultMap.put("过流",resultMap.get("过流")+data.get(i).getNum().intValue());
                    break;
                default:
@@ -181,7 +186,17 @@

        }

        return new Response<Map>().set(1,resultMap);
        //告警机房总数和比例
        HashMap<String, Integer> map2 = new HashMap<>();

        //int alarmStationCount = mapper.getAlarmStationCountSpec(userId,types);
        //int stationCount = infoMapper.getStationCount(userId);

        //map2.put("告警机房总数",alarmStationCount);
        //map2.put("告警机房数比例",(int)MathUtil.divide(alarmStationCount,stationCount,2));

        List<Map<String, Integer>> mapList = Arrays.asList(resultMap, map2);
        return new Response<List>().set(1,mapList);
    }

    public Response<Map> getRectifierAnalysis(int userId){
@@ -192,188 +207,188 @@
        //整流器-交流异常,
        //整流器-过压
        Map<String,Integer> resultMap = new HashMap<>();
        resultMap.put("总故障",0);
        resultMap.put("欠压",0);
        resultMap.put("过流",0);
        resultMap.put("交流异常",0);
        resultMap.put("过压",0);
        resultMap.put("整流器总故障",0);
        resultMap.put("整流器欠压",0);
        resultMap.put("整流器过流",0);
        resultMap.put("整流器交流异常",0);
        resultMap.put("整流器过压",0);

        List<Integer> types = Arrays.asList(
            PowerAlarmConstant.acdcMod1_err,
            PowerAlarmConstant.acdcMod2_err,
            PowerAlarmConstant.acdcMod3_err,
            PowerAlarmConstant.acdcMod4_err,
            PowerAlarmConstant.acdcMod5_err,
            PowerAlarmConstant.acdcMod6_err,
            PowerAlarmConstant.acdcMod7_err,
            PowerAlarmConstant.acdcMod8_err,
            PowerAlarmConstant.acdcMod9_err,
            PowerAlarmConstant.acdcMod10_err,
            PowerAlarmConstant.acdcMod11_err,
            PowerAlarmConstant.acdcMod12_err,
            PowerAlarmConstant.acdcMod13_err,
            PowerAlarmConstant.acdcMod14_err,
            PowerAlarmConstant.acdcMod15_err,
            PowerAlarmConstant.acdcMod16_err,
            PowerAlarmConstant.acdcMod1_underVol,
            PowerAlarmConstant.acdcMod2_underVol,
            PowerAlarmConstant.acdcMod3_underVol,
            PowerAlarmConstant.acdcMod4_underVol,
            PowerAlarmConstant.acdcMod5_underVol,
            PowerAlarmConstant.acdcMod6_underVol,
            PowerAlarmConstant.acdcMod7_underVol,
            PowerAlarmConstant.acdcMod8_underVol,
            PowerAlarmConstant.acdcMod9_underVol,
            PowerAlarmConstant.acdcMod10_underVol,
            PowerAlarmConstant.acdcMod11_underVol,
            PowerAlarmConstant.acdcMod12_underVol,
            PowerAlarmConstant.acdcMod13_underVol,
            PowerAlarmConstant.acdcMod14_underVol,
            PowerAlarmConstant.acdcMod15_underVol,
            PowerAlarmConstant.acdcMod16_underVol,
            PowerAlarmConstant.acdcMod1_overCurr,
            PowerAlarmConstant.acdcMod2_overCurr,
            PowerAlarmConstant.acdcMod3_overCurr,
            PowerAlarmConstant.acdcMod4_overCurr,
            PowerAlarmConstant.acdcMod5_overCurr,
            PowerAlarmConstant.acdcMod6_overCurr,
            PowerAlarmConstant.acdcMod7_overCurr,
            PowerAlarmConstant.acdcMod8_overCurr,
            PowerAlarmConstant.acdcMod9_overCurr,
            PowerAlarmConstant.acdcMod10_overCurr,
            PowerAlarmConstant.acdcMod11_overCurr,
            PowerAlarmConstant.acdcMod12_overCurr,
            PowerAlarmConstant.acdcMod13_overCurr,
            PowerAlarmConstant.acdcMod14_overCurr,
            PowerAlarmConstant.acdcMod15_overCurr,
            PowerAlarmConstant.acdcMod16_overCurr,
            PowerAlarmConstant.acdcMod1_acErr,
            PowerAlarmConstant.acdcMod2_acErr,
            PowerAlarmConstant.acdcMod3_acErr,
            PowerAlarmConstant.acdcMod4_acErr,
            PowerAlarmConstant.acdcMod5_acErr,
            PowerAlarmConstant.acdcMod6_acErr,
            PowerAlarmConstant.acdcMod7_acErr,
            PowerAlarmConstant.acdcMod8_acErr,
            PowerAlarmConstant.acdcMod9_acErr,
            PowerAlarmConstant.acdcMod10_acErr,
            PowerAlarmConstant.acdcMod11_acErr,
            PowerAlarmConstant.acdcMod12_acErr,
            PowerAlarmConstant.acdcMod13_acErr,
            PowerAlarmConstant.acdcMod14_acErr,
            PowerAlarmConstant.acdcMod15_acErr,
            PowerAlarmConstant.acdcMod16_acErr,
            PowerAlarmConstant.acdcMod1_overVol,
            PowerAlarmConstant.acdcMod2_overVol,
            PowerAlarmConstant.acdcMod3_overVol,
            PowerAlarmConstant.acdcMod4_overVol,
            PowerAlarmConstant.acdcMod5_overVol,
            PowerAlarmConstant.acdcMod6_overVol,
            PowerAlarmConstant.acdcMod7_overVol,
            PowerAlarmConstant.acdcMod8_overVol,
            PowerAlarmConstant.acdcMod9_overVol,
            PowerAlarmConstant.acdcMod10_overVol,
            PowerAlarmConstant.acdcMod11_overVol,
            PowerAlarmConstant.acdcMod12_overVol,
            PowerAlarmConstant.acdcMod13_overVol,
            PowerAlarmConstant.acdcMod14_overVol,
            PowerAlarmConstant.acdcMod15_overVol,
            PowerAlarmConstant.acdcMod16_overVol
            AlarmConstant.acdcMod1_err,
            AlarmConstant.acdcMod2_err,
            AlarmConstant.acdcMod3_err,
            AlarmConstant.acdcMod4_err,
            AlarmConstant.acdcMod5_err,
            AlarmConstant.acdcMod6_err,
            AlarmConstant.acdcMod7_err,
            AlarmConstant.acdcMod8_err,
            AlarmConstant.acdcMod9_err,
            AlarmConstant.acdcMod10_err,
            AlarmConstant.acdcMod11_err,
            AlarmConstant.acdcMod12_err,
            AlarmConstant.acdcMod13_err,
            AlarmConstant.acdcMod14_err,
            AlarmConstant.acdcMod15_err,
            AlarmConstant.acdcMod16_err,
            AlarmConstant.acdcMod1_underVol,
            AlarmConstant.acdcMod2_underVol,
            AlarmConstant.acdcMod3_underVol,
            AlarmConstant.acdcMod4_underVol,
            AlarmConstant.acdcMod5_underVol,
            AlarmConstant.acdcMod6_underVol,
            AlarmConstant.acdcMod7_underVol,
            AlarmConstant.acdcMod8_underVol,
            AlarmConstant.acdcMod9_underVol,
            AlarmConstant.acdcMod10_underVol,
            AlarmConstant.acdcMod11_underVol,
            AlarmConstant.acdcMod12_underVol,
            AlarmConstant.acdcMod13_underVol,
            AlarmConstant.acdcMod14_underVol,
            AlarmConstant.acdcMod15_underVol,
            AlarmConstant.acdcMod16_underVol,
            AlarmConstant.acdcMod1_overCurr,
            AlarmConstant.acdcMod2_overCurr,
            AlarmConstant.acdcMod3_overCurr,
            AlarmConstant.acdcMod4_overCurr,
            AlarmConstant.acdcMod5_overCurr,
            AlarmConstant.acdcMod6_overCurr,
            AlarmConstant.acdcMod7_overCurr,
            AlarmConstant.acdcMod8_overCurr,
            AlarmConstant.acdcMod9_overCurr,
            AlarmConstant.acdcMod10_overCurr,
            AlarmConstant.acdcMod11_overCurr,
            AlarmConstant.acdcMod12_overCurr,
            AlarmConstant.acdcMod13_overCurr,
            AlarmConstant.acdcMod14_overCurr,
            AlarmConstant.acdcMod15_overCurr,
            AlarmConstant.acdcMod16_overCurr,
            AlarmConstant.acdcMod1_acErr,
            AlarmConstant.acdcMod2_acErr,
            AlarmConstant.acdcMod3_acErr,
            AlarmConstant.acdcMod4_acErr,
            AlarmConstant.acdcMod5_acErr,
            AlarmConstant.acdcMod6_acErr,
            AlarmConstant.acdcMod7_acErr,
            AlarmConstant.acdcMod8_acErr,
            AlarmConstant.acdcMod9_acErr,
            AlarmConstant.acdcMod10_acErr,
            AlarmConstant.acdcMod11_acErr,
            AlarmConstant.acdcMod12_acErr,
            AlarmConstant.acdcMod13_acErr,
            AlarmConstant.acdcMod14_acErr,
            AlarmConstant.acdcMod15_acErr,
            AlarmConstant.acdcMod16_acErr,
            AlarmConstant.acdcMod1_overVol,
            AlarmConstant.acdcMod2_overVol,
            AlarmConstant.acdcMod3_overVol,
            AlarmConstant.acdcMod4_overVol,
            AlarmConstant.acdcMod5_overVol,
            AlarmConstant.acdcMod6_overVol,
            AlarmConstant.acdcMod7_overVol,
            AlarmConstant.acdcMod8_overVol,
            AlarmConstant.acdcMod9_overVol,
            AlarmConstant.acdcMod10_overVol,
            AlarmConstant.acdcMod11_overVol,
            AlarmConstant.acdcMod12_overVol,
            AlarmConstant.acdcMod13_overVol,
            AlarmConstant.acdcMod14_overVol,
            AlarmConstant.acdcMod15_overVol,
            AlarmConstant.acdcMod16_overVol
        );

        List<PowerAlarm> data = mapper.getAnalysis(userId,types);

        for (int i = 0; i < data.size(); i++) {
            switch (data.get(i).getAlarmType()){
                case PowerAlarmConstant.acdcMod1_err:
                case PowerAlarmConstant.acdcMod2_err:
                case PowerAlarmConstant.acdcMod3_err:
                case PowerAlarmConstant.acdcMod4_err:
                case PowerAlarmConstant.acdcMod5_err:
                case PowerAlarmConstant.acdcMod6_err:
                case PowerAlarmConstant.acdcMod7_err:
                case PowerAlarmConstant.acdcMod8_err:
                case PowerAlarmConstant.acdcMod9_err:
                case PowerAlarmConstant.acdcMod10_err:
                case PowerAlarmConstant.acdcMod11_err:
                case PowerAlarmConstant.acdcMod12_err:
                case PowerAlarmConstant.acdcMod13_err:
                case PowerAlarmConstant.acdcMod14_err:
                case PowerAlarmConstant.acdcMod15_err:
                case PowerAlarmConstant.acdcMod16_err:
                    resultMap.put("总故障",data.get(i).getNum().intValue());
                case AlarmConstant.acdcMod1_err:
                case AlarmConstant.acdcMod2_err:
                case AlarmConstant.acdcMod3_err:
                case AlarmConstant.acdcMod4_err:
                case AlarmConstant.acdcMod5_err:
                case AlarmConstant.acdcMod6_err:
                case AlarmConstant.acdcMod7_err:
                case AlarmConstant.acdcMod8_err:
                case AlarmConstant.acdcMod9_err:
                case AlarmConstant.acdcMod10_err:
                case AlarmConstant.acdcMod11_err:
                case AlarmConstant.acdcMod12_err:
                case AlarmConstant.acdcMod13_err:
                case AlarmConstant.acdcMod14_err:
                case AlarmConstant.acdcMod15_err:
                case AlarmConstant.acdcMod16_err:
                    resultMap.put("整流器总故障",resultMap.get("整流器总故障")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acdcMod1_underVol:
                case PowerAlarmConstant.acdcMod2_underVol:
                case PowerAlarmConstant.acdcMod3_underVol:
                case PowerAlarmConstant.acdcMod4_underVol:
                case PowerAlarmConstant.acdcMod5_underVol:
                case PowerAlarmConstant.acdcMod6_underVol:
                case PowerAlarmConstant.acdcMod7_underVol:
                case PowerAlarmConstant.acdcMod8_underVol:
                case PowerAlarmConstant.acdcMod9_underVol:
                case PowerAlarmConstant.acdcMod10_underVol:
                case PowerAlarmConstant.acdcMod11_underVol:
                case PowerAlarmConstant.acdcMod12_underVol:
                case PowerAlarmConstant.acdcMod13_underVol:
                case PowerAlarmConstant.acdcMod14_underVol:
                case PowerAlarmConstant.acdcMod15_underVol:
                case PowerAlarmConstant.acdcMod16_underVol:
                    resultMap.put("欠压",data.get(i).getNum().intValue());
                case AlarmConstant.acdcMod1_underVol:
                case AlarmConstant.acdcMod2_underVol:
                case AlarmConstant.acdcMod3_underVol:
                case AlarmConstant.acdcMod4_underVol:
                case AlarmConstant.acdcMod5_underVol:
                case AlarmConstant.acdcMod6_underVol:
                case AlarmConstant.acdcMod7_underVol:
                case AlarmConstant.acdcMod8_underVol:
                case AlarmConstant.acdcMod9_underVol:
                case AlarmConstant.acdcMod10_underVol:
                case AlarmConstant.acdcMod11_underVol:
                case AlarmConstant.acdcMod12_underVol:
                case AlarmConstant.acdcMod13_underVol:
                case AlarmConstant.acdcMod14_underVol:
                case AlarmConstant.acdcMod15_underVol:
                case AlarmConstant.acdcMod16_underVol:
                    resultMap.put("整流器欠压",resultMap.get("整流器欠压")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acdcMod1_overCurr:
                case PowerAlarmConstant.acdcMod2_overCurr:
                case PowerAlarmConstant.acdcMod3_overCurr:
                case PowerAlarmConstant.acdcMod4_overCurr:
                case PowerAlarmConstant.acdcMod5_overCurr:
                case PowerAlarmConstant.acdcMod6_overCurr:
                case PowerAlarmConstant.acdcMod7_overCurr:
                case PowerAlarmConstant.acdcMod8_overCurr:
                case PowerAlarmConstant.acdcMod9_overCurr:
                case PowerAlarmConstant.acdcMod10_overCurr:
                case PowerAlarmConstant.acdcMod11_overCurr:
                case PowerAlarmConstant.acdcMod12_overCurr:
                case PowerAlarmConstant.acdcMod13_overCurr:
                case PowerAlarmConstant.acdcMod14_overCurr:
                case PowerAlarmConstant.acdcMod15_overCurr:
                case PowerAlarmConstant.acdcMod16_overCurr:
                    resultMap.put("过流",data.get(i).getNum().intValue());
                case AlarmConstant.acdcMod1_overCurr:
                case AlarmConstant.acdcMod2_overCurr:
                case AlarmConstant.acdcMod3_overCurr:
                case AlarmConstant.acdcMod4_overCurr:
                case AlarmConstant.acdcMod5_overCurr:
                case AlarmConstant.acdcMod6_overCurr:
                case AlarmConstant.acdcMod7_overCurr:
                case AlarmConstant.acdcMod8_overCurr:
                case AlarmConstant.acdcMod9_overCurr:
                case AlarmConstant.acdcMod10_overCurr:
                case AlarmConstant.acdcMod11_overCurr:
                case AlarmConstant.acdcMod12_overCurr:
                case AlarmConstant.acdcMod13_overCurr:
                case AlarmConstant.acdcMod14_overCurr:
                case AlarmConstant.acdcMod15_overCurr:
                case AlarmConstant.acdcMod16_overCurr:
                    resultMap.put("整流器过流",resultMap.get("整流器过流")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acdcMod1_acErr:
                case PowerAlarmConstant.acdcMod2_acErr:
                case PowerAlarmConstant.acdcMod3_acErr:
                case PowerAlarmConstant.acdcMod4_acErr:
                case PowerAlarmConstant.acdcMod5_acErr:
                case PowerAlarmConstant.acdcMod6_acErr:
                case PowerAlarmConstant.acdcMod7_acErr:
                case PowerAlarmConstant.acdcMod8_acErr:
                case PowerAlarmConstant.acdcMod9_acErr:
                case PowerAlarmConstant.acdcMod10_acErr:
                case PowerAlarmConstant.acdcMod11_acErr:
                case PowerAlarmConstant.acdcMod12_acErr:
                case PowerAlarmConstant.acdcMod13_acErr:
                case PowerAlarmConstant.acdcMod14_acErr:
                case PowerAlarmConstant.acdcMod15_acErr:
                case PowerAlarmConstant.acdcMod16_acErr:
                    resultMap.put("交流异常",data.get(i).getNum().intValue());
                case AlarmConstant.acdcMod1_acErr:
                case AlarmConstant.acdcMod2_acErr:
                case AlarmConstant.acdcMod3_acErr:
                case AlarmConstant.acdcMod4_acErr:
                case AlarmConstant.acdcMod5_acErr:
                case AlarmConstant.acdcMod6_acErr:
                case AlarmConstant.acdcMod7_acErr:
                case AlarmConstant.acdcMod8_acErr:
                case AlarmConstant.acdcMod9_acErr:
                case AlarmConstant.acdcMod10_acErr:
                case AlarmConstant.acdcMod11_acErr:
                case AlarmConstant.acdcMod12_acErr:
                case AlarmConstant.acdcMod13_acErr:
                case AlarmConstant.acdcMod14_acErr:
                case AlarmConstant.acdcMod15_acErr:
                case AlarmConstant.acdcMod16_acErr:
                    resultMap.put("整流器交流异常",resultMap.get("整流器交流异常")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.acdcMod1_overVol:
                case PowerAlarmConstant.acdcMod2_overVol:
                case PowerAlarmConstant.acdcMod3_overVol:
                case PowerAlarmConstant.acdcMod4_overVol:
                case PowerAlarmConstant.acdcMod5_overVol:
                case PowerAlarmConstant.acdcMod6_overVol:
                case PowerAlarmConstant.acdcMod7_overVol:
                case PowerAlarmConstant.acdcMod8_overVol:
                case PowerAlarmConstant.acdcMod9_overVol:
                case PowerAlarmConstant.acdcMod10_overVol:
                case PowerAlarmConstant.acdcMod11_overVol:
                case PowerAlarmConstant.acdcMod12_overVol:
                case PowerAlarmConstant.acdcMod13_overVol:
                case PowerAlarmConstant.acdcMod14_overVol:
                case PowerAlarmConstant.acdcMod15_overVol:
                case PowerAlarmConstant.acdcMod16_overVol:
                    resultMap.put("过压",data.get(i).getNum().intValue());
                case AlarmConstant.acdcMod1_overVol:
                case AlarmConstant.acdcMod2_overVol:
                case AlarmConstant.acdcMod3_overVol:
                case AlarmConstant.acdcMod4_overVol:
                case AlarmConstant.acdcMod5_overVol:
                case AlarmConstant.acdcMod6_overVol:
                case AlarmConstant.acdcMod7_overVol:
                case AlarmConstant.acdcMod8_overVol:
                case AlarmConstant.acdcMod9_overVol:
                case AlarmConstant.acdcMod10_overVol:
                case AlarmConstant.acdcMod11_overVol:
                case AlarmConstant.acdcMod12_overVol:
                case AlarmConstant.acdcMod13_overVol:
                case AlarmConstant.acdcMod14_overVol:
                case AlarmConstant.acdcMod15_overVol:
                case AlarmConstant.acdcMod16_overVol:
                    resultMap.put("整流器过压",resultMap.get("整流器过压")+data.get(i).getNum().intValue());
                    break;
                default:
                    throw new IllegalStateException("Unexpected value: " + data.get(i));
@@ -390,35 +405,35 @@
        //状态-直流电压异常,
        //状态-负载熔断,
        //状态-直流过流
        Map<String,Integer> resultMap = new HashMap<>();
        Map<String,Object> resultMap = new HashMap<>();
        resultMap.put("交流停电",0);
        resultMap.put("直流电压异常",0);
        resultMap.put("负载熔断",0);
        resultMap.put("直流过流",0);

        List<Integer> types = Arrays.asList(
            PowerAlarmConstant.acIn1_powerdown,
            PowerAlarmConstant.dcOut_over_vol,
            PowerAlarmConstant.dcOut_under_vol,
            PowerAlarmConstant.loader_fuse,
            PowerAlarmConstant.dcOut_over_curr
            AlarmConstant.acIn1_powerdown,
            AlarmConstant.dcOut_over_vol,
            AlarmConstant.dcOut_under_vol,
            AlarmConstant.loader_fuse,
            AlarmConstant.dcOut_over_curr
        );

        List<PowerAlarm> data = mapper.getAnalysis(userId,types);

        for (int i = 0; i < data.size(); i++) {
            switch (data.get(i).getAlarmType()){
                case PowerAlarmConstant.acIn1_powerdown:
                case AlarmConstant.acIn1_powerdown:
                    resultMap.put("交流停电",data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.dcOut_over_vol:
                case PowerAlarmConstant.dcOut_under_vol:
                    resultMap.put("直流电压异常",resultMap.get("直流电压异常")+data.get(i).getNum().intValue());
                case AlarmConstant.dcOut_over_vol:
                case AlarmConstant.dcOut_under_vol:
                    resultMap.put("直流电压异常",(Integer)resultMap.get("直流电压异常")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.loader_fuse:
                case AlarmConstant.loader_fuse:
                    resultMap.put("负载熔断",data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.dcOut_over_curr:
                case AlarmConstant.dcOut_over_curr:
                    resultMap.put("直流过流",data.get(i).getNum().intValue());
                    break;
                default:
@@ -426,6 +441,16 @@
            }

        }

        /*======获取电源告警机房数和比例======*/
        /*//告警机房数
        int alarmStationCount = mapper.getAlarmStationCount(userId);
        //总机房数
        int stationCount = infoMapper.getStationCount(userId);
        //比例
        String alarmStationRate = (String) MathUtil.divide(alarmStationCount, stationCount,3);
        resultMap.put("告警机房数",alarmStationCount);
        resultMap.put("告警机房比例",alarmStationRate);*/

        return new Response<Map>().set(1,resultMap);
    }
@@ -443,34 +468,34 @@
        resultMap.put("充电过流",0);

        List<Integer> types = Arrays.asList(
                PowerAlarmConstant.battgroup1_fuse,
                PowerAlarmConstant.battgroup2_fuse,
                PowerAlarmConstant.battgroup1_volLow,
                PowerAlarmConstant.battgroup2_volLow,
                PowerAlarmConstant.battgroup1_down,
                PowerAlarmConstant.battgroup2_down,
                PowerAlarmConstant.battgroup1_overChgCurr,
                PowerAlarmConstant.battgroup2_overChgCurr
                AlarmConstant.battgroup1_fuse,
                AlarmConstant.battgroup2_fuse,
                AlarmConstant.battgroup1_volLow,
                AlarmConstant.battgroup2_volLow,
                AlarmConstant.battgroup1_down,
                AlarmConstant.battgroup2_down,
                AlarmConstant.battgroup1_overChgCurr,
                AlarmConstant.battgroup2_overChgCurr
        );

        List<PowerAlarm> data = mapper.getAnalysis(userId,types);

        for (int i = 0; i < data.size(); i++) {
            switch (data.get(i).getAlarmType()){
                case PowerAlarmConstant.battgroup1_fuse:
                case PowerAlarmConstant.battgroup2_fuse:
                case AlarmConstant.battgroup1_fuse:
                case AlarmConstant.battgroup2_fuse:
                    resultMap.put("熔断",resultMap.get("熔断")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.battgroup1_volLow:
                case PowerAlarmConstant.battgroup2_volLow:
                case AlarmConstant.battgroup1_volLow:
                case AlarmConstant.battgroup2_volLow:
                    resultMap.put("电压低",resultMap.get("电压低")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.battgroup1_down:
                case PowerAlarmConstant.battgroup2_down:
                case AlarmConstant.battgroup1_down:
                case AlarmConstant.battgroup2_down:
                    resultMap.put("下电",resultMap.get("下电")+data.get(i).getNum().intValue());
                    break;
                case PowerAlarmConstant.battgroup1_overChgCurr:
                case PowerAlarmConstant.battgroup2_overChgCurr:
                case AlarmConstant.battgroup1_overChgCurr:
                case AlarmConstant.battgroup2_overChgCurr:
                    resultMap.put("充电过流",resultMap.get("充电过流")+data.get(i).getNum().intValue());
                    break;
                default:
@@ -487,7 +512,7 @@
        //告警机房数
        int alarmStationCount = mapper.getAlarmStationCount(userId);
        //总机房数
        int stationCount = mapper.getStationCount(userId);
        int stationCount = infoMapper.getStationCount(userId);

        List<Integer> counts = Arrays.asList(alarmStationCount, stationCount);