package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.constant.AlarmConstant;
import com.whyc.dto.AlarmCountDTO;
import com.whyc.dto.AlarmDaoFactory;
import com.whyc.dto.BattMaintDealarm;
import com.whyc.dto.Response;
import com.whyc.dto.paramter.AlarmPar;
import com.whyc.dto.result.AlarmNumberRes;
import com.whyc.dto.result.AlarmRes;
import com.whyc.dto.result.AlarmStaticRes;
import com.whyc.mapper.BattalarmDataMapper;
import com.whyc.mapper.DevalarmDataMapper;
import com.whyc.mapper.PwrdevAlarmMapper;
import com.whyc.pojo.*;
import com.whyc.util.ActionUtil;
import com.whyc.util.MessageUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service
@Transactional
public class BattalarmDataService {

    @Resource
    private BattalarmDataMapper  mapper;
    @Resource
    private DevalarmDataMapper devalarmDataMapper;
    @Resource
    private PwrdevAlarmMapper pwrdevAlarmMapper;
    @Autowired
    private SubTablePageInfoService subService;

    @Autowired
    @Lazy
    private StationInfService stationInfService;

    //查询所有的告警
    public Response getAll() {
        QueryWrapper<BattalarmData> wrapper = new QueryWrapper<>();
        // 通过id进行排序
        wrapper.orderByAsc("BattGroupId");
        List<BattalarmData> list=mapper.selectList(wrapper);
        return new Response().set(1,list);
    }
    //分页查询所有的实时告警
    public Response<List<BattalarmData>> getAllByPage(com.whyc.dto.Page p) {
        Page page=new Page(p.getPageCurr(),p.getPageSize());
        QueryWrapper<BattalarmData> wrapper = new QueryWrapper<>();
        // 通过id进行排序
        wrapper.orderByAsc("BattGroupId");
        IPage iPage=mapper.selectPage(page,wrapper);
        return new Response<List<BattalarmData>>().set(1,iPage.getRecords(),String.valueOf(iPage.getTotal()));
    }
    //测试:根据电池组id查询所有的告警
    public Response<List<BattMaintDealarm>> test(BattalarmData balarm) {
        //分页信息
        PageHelper.startPage(1,20);
        List<BattMaintDealarm> list=mapper.test(balarm);
        PageInfo<BattMaintDealarm> pinfo=new PageInfo<BattMaintDealarm>(list);
        return new Response<List<BattMaintDealarm>>().set(1,list,String.valueOf(pinfo.getPages()));
    }

    /**
     * @param userId
     * @param type 1,查询24小时内;0,查询所有
     * @return
     */
    public List<BattalarmData> getList(Long userId,int type){
        return mapper.getList(userId,type);
    }
    //电池告警实时查询
    public Response serchByCondition(AlarmPar par) {
        String lang = ActionUtil.getLang();
        //分页信息
        PageHelper.startPage(par.getPage().getPageCurr(), par.getPage().getPageSize());
        UserInf uinf = ActionUtil.getUser();
        par.setUId(uinf.getUId().intValue());
        List<AlarmRes> list = mapper.serchByCondition(par);
        for (AlarmRes a : list) {
            List<BattalarmData> l = a.getAdatas();
            for (BattalarmData adata : l) {
                adata.setAlmSignalIdName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(adata.getAlmSignalId()), lang));
                adata.setAlmLevelName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmType(adata.getAlmLevel()), lang));
            }
        }
        PageInfo<AlarmRes> pinfo = new PageInfo<AlarmRes>(list);
        return new Response().set(1, pinfo);
    }

    //电池告警实时查询-websocket使用
    @Transactional
    public Response serchByConditionOfWebSocket(AlarmPar par, String lang) {
        //分页信息
        PageHelper.startPage(par.getPage().getPageCurr(), par.getPage().getPageSize());
        List<AlarmRes> list = mapper.serchByCondition(par);
        for (AlarmRes a : list) {
            List<BattalarmData> l = a.getAdatas();
            for (BattalarmData adata : l) {
                adata.setAlmSignalIdName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(adata.getAlmSignalId()), lang));
                adata.setAlmLevelName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmType(adata.getAlmLevel()), lang));
            }
        }
        PageInfo<AlarmRes> pinfo = new PageInfo<AlarmRes>(list);
        return new Response().set(1, pinfo);
    }


    //电池告警实时查询-websocket使用
    @Transactional
    public Response getSendBattAlarmOfWebSocket(Integer uId, String lang) {
        List<BattalarmData> list = mapper.getSendBattAlarm(uId);
        Date now = new Date();
        ListIterator<BattalarmData> it = list.listIterator();
        while (it.hasNext()) {
            BattalarmData adata = it.next();
            if (adata.getAlmLevel() == 1 && adata.getRecordTime() != null && now.getTime() - adata.getRecordTime().getTime() < 24 * 3600000) {
                it.remove();
            }
            if (adata.getAlmLevel() == 2 && adata.getRecordTime() != null && now.getTime() - adata.getRecordTime().getTime() < 7 * 24 * 3600000) {
                it.remove();
            }
            if (adata.getAlmLevel() == 3 && adata.getRecordTime() != null && now.getTime() - adata.getRecordTime().getTime() < 30 * 7 * 24 * 3600000) {
                it.remove();
            }
            adata.setAlmSignalIdName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(adata.getAlmSignalId()), lang));
            adata.setAlmLevelName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmType(adata.getAlmLevel()), lang));
        }
        return new Response().set(1,list);
    }


    //根据电池组id查询所有的告警
    public Response<List<AlarmRes>> serchByInfo(AlarmPar par) {
        //分页信息
        PageHelper.startPage(par.getPage().getPageCurr(), par.getPage().getPageSize());
        UserInf uinf= ActionUtil.getUser();
        par.setUId(uinf.getUId().intValue());
        List<AlarmRes> list=mapper.serchByInfo(par);
        PageInfo<AlarmRes> pinfo=new PageInfo<AlarmRes>(list);
        return new Response<List<AlarmRes>>().set(1,list,String.valueOf(pinfo.getPages()));
    }
    //查询实时告警数
    public Response<AlarmNumberRes> serchAlm(AlarmPar par) {
        /*BattalarmData adata=new BattalarmData();
        adata.setNum(0l);//实时告警总数
        adata.setBattGroupId(0);//容量告警告警数
        adata.setMonNum(0);//组端电压告警数
        adata.setAlmId(0);//充电电流告警数
        adata.setAlmSignalId(0);//放电电流告警数
        adata.setAlmLevel(0);//单体电压告警数
        adata.setAlmIsConfirmed(0);//单体温度告警数
        adata.setAlmClearedType(0);//单体内阻告警数
        adata.setUsrId(0);//连接条阻抗告警数
        adata.setAlmValue(0f);//容量更换告警*/
        AlarmNumberRes ares=new AlarmNumberRes();
        //int numZ=0;//告警总数
        List<AlarmStaticRes> list=mapper.serchAlm(par);//各类告警数
        if(list!=null&&list.size()>0){
            for(int i=0;i<list.size();i++){
                if(list.get(i).getAlmId()== AlarmDaoFactory.Alarm_CapAlarm){
                    /*adata.setBattGroupId(list.get(i).getNumber());//容量告警告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberCapAlm(list.get(i).getNumber());//容量告警告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_vol_Group){
                    /*adata.setMonNum(list.get(i).getNumber());//组端电压告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberGroupVol(list.get(i).getNumber());//组端电压告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_curr_Charge){
                    /*adata.setAlmId(list.get(i).getNumber());//充电电流告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberCharge(list.get(i).getNumber());//充电电流告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_curr_Discharge){
                    /*adata.setAlmSignalId(list.get(i).getNumber());//放电电流告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberDischarge(list.get(i).getNumber());//放电电流告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_vol_Monomer){
                    /*adata.setAlmLevel(list.get(i).getNumber());//单体电压告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberMonVol(list.get(i).getNumber());//单体电压告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_tmp_Monomer){
                   /* adata.setAlmIsConfirmed(list.get(i).getNumber());//单体温度告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberTmp(list.get(i).getNumber());//单体温度告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_res_Monomer){
                   /* adata.setAlmClearedType(list.get(i).getNumber());//单体内阻告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberRes(list.get(i).getNumber());//单体内阻告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_res_Conn){
                   /* adata.setUsrId(list.get(i).getNumber());//连接条阻抗告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberSer(list.get(i).getNumber());//连接条阻抗告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
                if(list.get(i).getAlmId()==AlarmDaoFactory.Alarm_CapChange){
                   /* adata.setAlmValue((float)list.get(i).getNumber());//容量更换告警数
                    numZ+=list.get(i).getNumber();*/
                    ares.setNumberCapChange(list.get(i).getNumber());//容量更换告警数
                    ares.setNumberAll(ares.getNumberAll()+list.get(i).getNumber());
                }
            }
        }
        return new Response<AlarmNumberRes>().set(1,ares);
    }

    //根据num取消告警
    public Response cancelalarm(int num) {
        UpdateWrapper wrapper = new UpdateWrapper<>();
        //修改的属性
        //wrapper.set("record_id",adata.getRecordId());
        wrapper.set("alm_end_time", new SimpleDateFormat(ActionUtil.time_yyyyMMddHHmmss).format(new Date()));
        wrapper.set("alm_cleared_type",2);
        // 通过num修改
        wrapper.eq("num",num);
        int flag=mapper.update((BattalarmData) ActionUtil.objeNull,wrapper);
        return  new Response().set(flag);
    }

    //根据num取消告警(多条记录)
    @Transactional
    public Response cancelalarmPro(List<Integer> list) {
        int flag=0;
        for (Integer num:list) {
            //修改的属性
            UpdateWrapper wrapper = new UpdateWrapper<>();
            //wrapper.set("record_id",adata.getRecordId());
            wrapper.set("alm_end_time",new SimpleDateFormat(ActionUtil.time_yyyyMMddHHmmss).format(new Date()));
            wrapper.set("alm_cleared_type",2);
            // 通过num修改
            wrapper.eq("num",num);
            flag=mapper.update((BattalarmData) ActionUtil.objeNull,wrapper);
        }
        return  new Response().set(flag);
    }
    //实时告警记录总数查询
    public Response serchRealTime(int uId) {
        int number=mapper.serchRealTime(uId);
        return  new Response().set(number);
    }

    //实时1级告警记录总数查询
    public Response getRealTimeWithLevel1(int uId) {
        int number=mapper.getRealTimeWithLevel1(uId);
        return  new Response().set(number);
    }

    //山西晋源特定接口
    public Response getRealTimeWithLevel1JY() {
        int number=mapper.getRealTimeWithLevel1JY();
        return  new Response().set(number);
    }

    //实时1级告警记录查询
    public Response getRealAlarmListWithLevel1(int uId) {
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.YEAR, -100);
        Date yesterday = instance.getTime();
        int[] alarmParams = {AlarmDaoFactory.Alarm_CapAlarm, AlarmDaoFactory.Alarm_CapChange, AlarmDaoFactory.Alarm_res_Conn, AlarmDaoFactory.ALM_TYPE_DisChargeMonVol_ID};
        List<BattalarmData> lista = mapper.getRealAlarmListWithLevel1(uId);
        for (BattalarmData battAlarm : lista) {
            battAlarm.setAlarmName(MessageUtils.getMessage(AlarmDaoFactory.getAlarmName(battAlarm.getAlmSignalId())));
        }
        List<DevalarmData> listd = devalarmDataMapper.getRealAlarmListWithLevel1(uId);
        if (listd != null && listd.size() > 0) {
            for (DevalarmData ddata : listd) {
                BattalarmData data = new BattalarmData();
                data.setBattGroupId(ddata.getDevId());
                data.setAlarmType("1");//1表示设备告警
                data.setAlmId(ddata.getAlmType());
                data.setStationName(ddata.getStationName());
                data.setStationName1(ddata.getStationName1());
                data.setStationName2(ddata.getStationName2());
                data.setStationName3(ddata.getStationName3());
                data.setStationName4(ddata.getStationName4());
                data.setStationName5(ddata.getStationName5());
                data.setAlmLevel(ddata.getAlmLevel());
                //data.setNote(ddata.getNote());
                data.setNum(ddata.getNum());
                data.setAlmStartTime(ddata.getAlmStartTime());
                //data.setAlm_signal_id(ddata.getAlm_type());
                data.setAlarmName(MessageUtils.getMessage(AlarmDaoFactory.getdevName(ddata.getAlmType())));
                data.setAlmSeverity(ddata.getAlmSeverity());
                lista.add(data);
            }
        }
        //添加电源告警
        List<PwrdevAlarm> pwrAlarmList = pwrdevAlarmMapper.getRealAlarmListWithLevel1(uId);
        if (pwrAlarmList!=null && pwrAlarmList.size()>0){
            for (PwrdevAlarm pAlarm:pwrAlarmList ) {
                BattalarmData data=new BattalarmData();
                int powerId=pAlarm.getPowerDeviceId().intValue();
                int almType = pAlarm.getAlmType();
                data.setBattGroupId(powerId);
                data.setAlarmType("2");//2表示电源告警
                data.setAlmId(almType);
                data.setStationName(pAlarm.getStationName());
                data.setStationName1(pAlarm.getStationName1());
                data.setStationName2(pAlarm.getStationName2());
                data.setStationName3(pAlarm.getStationName3());
                data.setStationName4(pAlarm.getStationName4());
                data.setStationName5(pAlarm.getStationName5());
                data.setAlmLevel(pAlarm.getAlmLevel());
                data.setNum(pAlarm.getNum());
                data.setAlmStartTime(pAlarm.getAlmStartTime());
                //115南网
                if(powerId/100000==1150){
                    String alarmParamTableName="tb_pwrdev_alarm_param_"+powerId;
                    List<PwrdevAlarmParam>  paramList=subService.searchAll(alarmParamTableName);
                    data.setAlarmName("未知");
                    if(paramList!=null){
                        paramList.stream().forEach(param->{
                            if(param.getAlarmId() == almType){
                                data.setAlarmName(param.getAlarmName());
                                return;
                            }
                        });
                    }
                }else{
                    //110国网
                    data.setAlarmName(AlarmDaoFactory.getAllAlarmName(pAlarm.getAlmType()));
                }

                data.setAlmSeverity(pAlarm.getAlmSeverity());
                lista.add(data);
            }
        }
        //排序,按照时间或者说是num
        lista.sort(Comparator.comparing(BattalarmData::getAlmStartTime).reversed());
        return new Response().set(1, lista, "查询成功");

    }
    //电池告警实时查询(确认告警)
    public Response update(int num) {
        UpdateWrapper wrapper = new UpdateWrapper<>();
        wrapper.set("alm_is_confirmed",1);
        wrapper.set("alm_confirmed_time",new SimpleDateFormat(ActionUtil.time_yyyyMMddHHmmss).format(new Date()));
        // 通过num修改
        wrapper.eq("num",num);
        int flag=mapper.update((BattalarmData) ActionUtil.objeNull,wrapper);
        return  new Response().set(flag);
    }
    //电池告警实时查询(批量确认告警)
    @Transactional
    public Response updatePro(List<Integer> list) {
        int flag=0;
        for (Integer num:list) {
            //修改的属性
            UpdateWrapper wrapper = new UpdateWrapper<>();
            wrapper.set("alm_is_confirmed",1);
            wrapper.set("alm_confirmed_time",new SimpleDateFormat(ActionUtil.time_yyyyMMddHHmmss).format(new Date()));
            // 通过num修改
            wrapper.eq("num",num);
            flag=mapper.update((BattalarmData) ActionUtil.objeNull,wrapper);
        }
        return  new Response().set(1,true,"批量确认告警");
    }
    //电池告警实时查询(删除告警)
    public Response delete(int num) {
        UpdateWrapper wrapper = new UpdateWrapper<>();

        wrapper.eq("num",num);
        int flag=mapper.delete(wrapper);
        return  new Response().set(flag);
    }
    //批量删除告警记录
    @Transactional
    public Response deletePro(List<Integer> list) {
        int flag=0;
        for (Integer num:list) {
            UpdateWrapper wrapper = new UpdateWrapper<>();
            // 通过num删除
            wrapper.eq("num",num);
            flag=mapper.delete(wrapper);
        }
        return  new Response().set(flag);
    }
    //电池单体健康率
    public Response serchGood(int uId) {
        List list=mapper.serchGood(uId);
        return  new Response().set(1,list);
    }

    /**获取告警记录信息*/
    public List<WorkflowAlarm> getAlarmList() {
        return mapper.getAlarmList();
    }

    public void updateWorkFlag(List<WorkflowAlarm> battAlarmList) {
        mapper.updateWorkFlag(battAlarmList);
    }

    //根据机房信息查询该机房实时告警已确认总数和未确认总数  search2ByStationId
    public List<BattalarmData> getCountByStationId(String stationId){
        int[] alarmParams = {AlarmDaoFactory.Alarm_CapAlarm,AlarmDaoFactory.Alarm_CapChange,AlarmDaoFactory.Alarm_res_Conn,AlarmDaoFactory.ALM_TYPE_DisChargeMonVol_ID};
        List<BattalarmData> list = mapper.getCountByStationId(stationId,alarmParams);
        return list;
    }
    public List<BattMapInformation> findAllStation(){
        int[] alarmParams = {AlarmDaoFactory.Alarm_CapAlarm,AlarmDaoFactory.Alarm_CapChange,AlarmDaoFactory.Alarm_res_Conn,AlarmDaoFactory.ALM_TYPE_DisChargeMonVol_ID};
        List<BattMapInformation> list = mapper.findAllStation(alarmParams);
        return list;
    }


    //项目下方的滚动，查询30天的电池告警和设备告警和电源告警
    @Transactional
    public Response getRealAlarm(int uId, String lang) {
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.YEAR, -100);
        Date yesterday = instance.getTime();
        int[] alarmParams = {AlarmDaoFactory.Alarm_CapAlarm, AlarmDaoFactory.Alarm_CapChange, AlarmDaoFactory.Alarm_res_Conn, AlarmDaoFactory.ALM_TYPE_DisChargeMonVol_ID};
        List<BattalarmData> lista = mapper.getRealAlarm(yesterday, uId, alarmParams);
        for (BattalarmData battAlarm : lista) {
            battAlarm.setAlarmName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(battAlarm.getAlmSignalId()), lang));
        }
        List<DevalarmData> listd = devalarmDataMapper.getRealAlarm(yesterday, uId);
        if (listd != null && listd.size() > 0) {
            for (DevalarmData ddata : listd) {
                BattalarmData data = new BattalarmData();
                data.setBattGroupId(ddata.getDevId());
                data.setAlarmType("1");//1表示设备告警
                data.setAlmId(ddata.getAlmType());
                data.setStationName(ddata.getStationName());
                data.setStationName1(ddata.getStationName1());
                data.setStationName2(ddata.getStationName2());
                data.setStationName3(ddata.getStationName3());
                data.setStationName4(ddata.getStationName4());
                data.setStationName5(ddata.getStationName5());
                data.setAlmLevel(ddata.getAlmLevel());
                //data.setNote(ddata.getNote());
                data.setNum(ddata.getNum());
                data.setAlmStartTime(ddata.getAlmStartTime());
                //data.setAlm_signal_id(ddata.getAlm_type());
                data.setAlarmName(MessageUtils.getMessageSocket(AlarmDaoFactory.getdevName(ddata.getAlmType()), lang));
                data.setAlmSeverity(ddata.getAlmSeverity());
                lista.add(data);
            }
        }
        //添加电源告警
        List<PwrdevAlarm> pwrAlarmList = pwrdevAlarmMapper.getRealAlarmFoot(yesterday,uId);
        if (pwrAlarmList!=null && pwrAlarmList.size()>0){
            for (PwrdevAlarm pAlarm:pwrAlarmList ) {
                BattalarmData data=new BattalarmData();
                int powerId=pAlarm.getPowerDeviceId().intValue();
                int almType = pAlarm.getAlmType();
                data.setBattGroupId(powerId);
                data.setAlarmType("2");//2表示电源告警
                data.setAlmId(almType);
                data.setStationName(pAlarm.getStationName());
                data.setStationName1(pAlarm.getStationName1());
                data.setStationName2(pAlarm.getStationName2());
                data.setStationName3(pAlarm.getStationName3());
                data.setStationName4(pAlarm.getStationName4());
                data.setStationName5(pAlarm.getStationName5());
                data.setAlmLevel(pAlarm.getAlmLevel());
                data.setNum(pAlarm.getNum());
                data.setAlmStartTime(pAlarm.getAlmStartTime());
                //115南网
                if(powerId/100000==1150){
                    String alarmParamTableName="tb_pwrdev_alarm_param_"+powerId;
                    List<PwrdevAlarmParam>  paramList=subService.searchAll(alarmParamTableName);
                    data.setAlarmName("未知");
                    if(paramList!=null){
                        paramList.stream().forEach(param->{
                            if(param.getAlarmId() == almType){
                                data.setAlarmName(param.getAlarmName());
                                return;
                            }
                        });
                    }
                }else{
                    //110国网
                    data.setAlarmName(AlarmDaoFactory.getAllAlarmName(pAlarm.getAlmType()));
                }

                data.setAlmSeverity(pAlarm.getAlmSeverity());
                lista.add(data);
            }
        }
        //排序,按照时间或者说是num
        lista.sort(Comparator.comparing(BattalarmData::getAlmStartTime).reversed());
        return new Response().set(1, lista, "查询成功");

    }

    //查询分级告警的个数
    public Response serchByLevel(int uId) {
        List list = new ArrayList();
        //分四级查询个数
        for (int i = 1; i <= 4; i++) {
            int countLevel = mapper.serchByLevel(i, uId);
            list.add(countLevel);
        }
        return new Response().setII(1, list.size() > 0, list, "分级告警数");
    }

    /**
     * 单体容量 monCapStd
     * alm_id
     * Alarm_CapAlarm =119010
     * @param userId
     * @return
     */
    public Response getMonCapacityLowAnalysis(int userId) {
        Response response = new Response();
        Map<String, Object> resultMap = new HashMap<>();

        try {
            //单体容量低告警数和对应的告警机房数
            //BatteryAlarmDto batteryAlarmDto = mapper.getLowCapacityAlarms(userId,AlarmConstant.Alarm_IGNAL_ID_CapAlarmLow);
            //int alarmNum = batteryAlarmDto.getNum();
            Integer alarmLow = mapper.getAlarmHighLow(userId, AlarmConstant.Alarm_IGNAL_ID_CapAlarmLow);
            Integer alarmHigh = mapper.getAlarmHighLow(userId, AlarmConstant.Alarm_IGNAL_ID_CapAlarmHigh);
            //int stationNum = batteryAlarmDto.getStationNum();
            //总告警数
            //Integer totalAlarmNum = mapper.getTotalAlarms(userId);
            //总机房数
            //int totalStationNum = infoMapper.getStationCount(userId);

            //容量低告警占比
            //String capLowRateStr = (String) MathUtil.divide(alarmNum,totalAlarmNum,3);
            //容量低告警机房占比
            //String capLowStationRateStr = (String) MathUtil.divide(stationNum,totalStationNum,3);

            resultMap.put("单体容量低告警",alarmLow);
            resultMap.put("单体容量高告警",alarmHigh);
            //resultMap.put("告警总数",totalAlarmNum);
            //resultMap.put("告警占比",capLowRateStr);

            //resultMap.put("告警机房数",alarmNum);
            //resultMap.put("告警机房占比",capLowStationRateStr);

            response.setII(1,true, resultMap,"");
        } catch (Exception e) {
            return response.set(0,false,"发生异常:"+e.getCause());
        }
        return response;
    }

    /**
     * 单体电压、内阻和温度
     * alm_id 电池告警参数
     * 三个告警总数不同，带条件？电压、内阻、温度
     * @param userId
     * @return
     */
    public Response getMonVRTAnalysis(int userId) {

        Response response = new Response();
        try {
            HashMap<String, Object> resultMap = new HashMap<>();
            Map<String, Object> monVolMap = new HashMap<>();//单体电压  Alarm_vol_Monomer =119005;
            Map<String, Object> monResMap = new HashMap<>();//单体内阻  Alarm_res_Monomer =119007
            Map<String, Object> monTemMap = new HashMap<>();//单体温度  Alarm_tmp_Monomer =119006

            /*======单体电压======*/

            //高告警数量
            Integer volHighAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonVolHigh);
            //低告警数量
            Integer volLowAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonVolLow);

            //单体电压总告警数
            //Integer volTotalAlarmNum = volHighAlarmsNum+volLowAlarmsNum;

            //告警总数
            //Integer totalStationAlarmNum =mapper.getTotalAlarms(userId);

            //电压告警机房数
            //int volTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_vol_Monomer);

            //总机房数
            //int totalStationNum = infoMapper.getStationCount(userId);

            //电压告警占比
            //String volRateStr = (String) MathUtil.divide(volTotalAlarmNum,totalStationAlarmNum,3);
            //电压告警机房占比
            //String volStationRateStr = (String) MathUtil.divide(volTotalAlarmStations,totalStationNum,3);


            monVolMap.put("单体电压高告警", volHighAlarmsNum);     //高告警数量    alm_signal_id 9
            monVolMap.put("单体电压低告警", volLowAlarmsNum);     //低告警数量     alm_signal_id   10
            //monVolMap.put("告警总数", volTotalAlarmNum);        //告警总数
            //monVolMap.put("告警总数比例", volRateStr);      //告警总数比例
            //monVolMap.put("告警机房总数", volTotalAlarmStations);      //告警机房总数
            //monVolMap.put("告警机房数比例", volStationRateStr);    //告警机房数比例
            resultMap.put("单体电压", monVolMap);



            /*======单体内阻======*/

            //高告警数量
            Integer resHighAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonResHigh);
            //低告警数量
            Integer resLowAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonResLow);

            //单体内阻总告警数
            //Integer resTotalAlarmNum = resHighAlarmsNum+resLowAlarmsNum;

            //内阻告警机房数
            //int resTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_res_Monomer);

            //内阻告警占比
            //String resRateStr = (String) MathUtil.divide(resTotalAlarmNum,totalStationAlarmNum,3);
            //内阻告警机房占比
            //String resStationRateStr = (String) MathUtil.divide(resTotalAlarmStations,totalStationNum,3);

            monResMap.put("单体内阻高告警", resHighAlarmsNum);     //高告警数量    alm_signal_id 13
            monResMap.put("单体内阻低告警", resLowAlarmsNum);     //低告警数量     alm_signal_id 14
            //monResMap.put("告警总数", resTotalAlarmNum);        //告警总数
            //monResMap.put("告警总数比例", resRateStr);      //告警总数比例
            //monResMap.put("告警机房总数", resTotalAlarmStations);      //告警机房总数
            //monResMap.put("告警机房数比例", resStationRateStr);    //告警机房数比例
            resultMap.put("单体内阻", monResMap);

            /*======单体温度======*/

            //高告警数量
            Integer tempHighAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonTmpHigh);
            //低告警数量
            Integer tempLowAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonTmpLow);

            //单体温度总告警数
            //Integer tempTotalAlarmNum = tempHighAlarmsNum+tempLowAlarmsNum;

            //温度告警机房数
            //int tempTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_tmp_Monomer);

            //温度告警占比
            //String tempRateStr = (String) MathUtil.divide(tempTotalAlarmNum,totalStationAlarmNum,3);
            //温度告警机房占比
            //String tempStationRateStr = (String) MathUtil.divide(tempTotalAlarmStations,totalStationNum,3);

            monTemMap.put("单体温度高告警", tempHighAlarmsNum);     //高告警数量    alm_signal_id 13
            monTemMap.put("单体温度低告警", tempLowAlarmsNum);     //低告警数量     alm_signal_id 14
            //monTemMap.put("告警总数", tempTotalAlarmNum);        //告警总数
            //monTemMap.put("告警总数比例", tempRateStr);      //告警总数比例
            //monTemMap.put("告警机房总数", tempTotalAlarmStations);      //告警机房总数
            //monTemMap.put("告警机房数比例", tempStationRateStr);    //告警机房数比例
            resultMap.put("单体温度", monTemMap);

            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }

    //山西晋源特定接口
    public Response getMonVRTAnalysisJY() {

        Response response = new Response();
        try {
            HashMap<String, Object> resultMap = new HashMap<>();
            Map<String, Object> monVolMap = new HashMap<>();//单体电压  Alarm_vol_Monomer =119005;
            Map<String, Object> monResMap = new HashMap<>();//单体内阻  Alarm_res_Monomer =119007
            Map<String, Object> monTemMap = new HashMap<>();//单体温度  Alarm_tmp_Monomer =119006

            /*======单体电压======*/

            //高告警数量
            Integer volHighAlarmsNum = mapper.getAlarmHighLowJY(AlarmConstant.ALM_SIGNAL_ID_MonVolHigh);
            //低告警数量
            Integer volLowAlarmsNum = mapper.getAlarmHighLowJY(AlarmConstant.ALM_SIGNAL_ID_MonVolLow);

            //单体电压总告警数
            //Integer volTotalAlarmNum = volHighAlarmsNum+volLowAlarmsNum;

            //告警总数
            //Integer totalStationAlarmNum =mapper.getTotalAlarms(userId);

            //电压告警机房数
            //int volTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_vol_Monomer);

            //总机房数
            //int totalStationNum = infoMapper.getStationCount(userId);

            //电压告警占比
            //String volRateStr = (String) MathUtil.divide(volTotalAlarmNum,totalStationAlarmNum,3);
            //电压告警机房占比
            //String volStationRateStr = (String) MathUtil.divide(volTotalAlarmStations,totalStationNum,3);


            monVolMap.put("单体电压高告警", volHighAlarmsNum);     //高告警数量    alm_signal_id 9
            monVolMap.put("单体电压低告警", volLowAlarmsNum);     //低告警数量     alm_signal_id   10
            //monVolMap.put("告警总数", volTotalAlarmNum);        //告警总数
            //monVolMap.put("告警总数比例", volRateStr);      //告警总数比例
            //monVolMap.put("告警机房总数", volTotalAlarmStations);      //告警机房总数
            //monVolMap.put("告警机房数比例", volStationRateStr);    //告警机房数比例
            resultMap.put("单体电压", monVolMap);



            /*======单体内阻======*/

            //高告警数量
            Integer resHighAlarmsNum = mapper.getAlarmHighLowJY( AlarmConstant.ALM_SIGNAL_ID_MonResHigh);
            //低告警数量
            Integer resLowAlarmsNum = mapper.getAlarmHighLowJY(AlarmConstant.ALM_SIGNAL_ID_MonResLow);

            //单体内阻总告警数
            //Integer resTotalAlarmNum = resHighAlarmsNum+resLowAlarmsNum;

            //内阻告警机房数
            //int resTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_res_Monomer);

            //内阻告警占比
            //String resRateStr = (String) MathUtil.divide(resTotalAlarmNum,totalStationAlarmNum,3);
            //内阻告警机房占比
            //String resStationRateStr = (String) MathUtil.divide(resTotalAlarmStations,totalStationNum,3);

            monResMap.put("单体内阻高告警", resHighAlarmsNum);     //高告警数量    alm_signal_id 13
            monResMap.put("单体内阻低告警", resLowAlarmsNum);     //低告警数量     alm_signal_id 14
            //monResMap.put("告警总数", resTotalAlarmNum);        //告警总数
            //monResMap.put("告警总数比例", resRateStr);      //告警总数比例
            //monResMap.put("告警机房总数", resTotalAlarmStations);      //告警机房总数
            //monResMap.put("告警机房数比例", resStationRateStr);    //告警机房数比例
            resultMap.put("单体内阻", monResMap);

            /*======单体温度======*/

            //高告警数量
            Integer tempHighAlarmsNum = mapper.getAlarmHighLowJY(AlarmConstant.ALM_SIGNAL_ID_MonTmpHigh);
            //低告警数量
            Integer tempLowAlarmsNum = mapper.getAlarmHighLowJY(AlarmConstant.ALM_SIGNAL_ID_MonTmpLow);

            //单体温度总告警数
            //Integer tempTotalAlarmNum = tempHighAlarmsNum+tempLowAlarmsNum;

            //温度告警机房数
            //int tempTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_tmp_Monomer);

            //温度告警占比
            //String tempRateStr = (String) MathUtil.divide(tempTotalAlarmNum,totalStationAlarmNum,3);
            //温度告警机房占比
            //String tempStationRateStr = (String) MathUtil.divide(tempTotalAlarmStations,totalStationNum,3);

            monTemMap.put("单体温度高告警", tempHighAlarmsNum);     //高告警数量    alm_signal_id 13
            monTemMap.put("单体温度低告警", tempLowAlarmsNum);     //低告警数量     alm_signal_id 14
            //monTemMap.put("告警总数", tempTotalAlarmNum);        //告警总数
            //monTemMap.put("告警总数比例", tempRateStr);      //告警总数比例
            //monTemMap.put("告警机房总数", tempTotalAlarmStations);      //告警机房总数
            //monTemMap.put("告警机房数比例", tempStationRateStr);    //告警机房数比例
            resultMap.put("单体温度", monTemMap);

            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }

    //今日实时告警
    public Response getBalmToday(int userId) {
        try {
            Map<String, Object> map = new HashMap<>();
            int btatolNum = 0;
            Map<String, Integer> bAlmClearMap = new HashMap<>();
            bAlmClearMap.put("clear0", 0);
            bAlmClearMap.put("clear1", 0);
            List<BattalarmData> bAlmList = mapper.getBalmToday(userId);
            Map<Integer, List<BattalarmData>> bclearedMap = bAlmList.stream().collect(Collectors.groupingBy(BattalarmData::getAlmClearedType));
            for (Integer cleared : bclearedMap.keySet()) {
                bAlmClearMap.put("clear" + String.valueOf(cleared), bclearedMap.get(cleared).size());
                btatolNum += bclearedMap.get(cleared).size();
            }
            Map<String, Integer> bAlmLevelMap = new HashMap<>();
            bAlmLevelMap.put("level1", 0);
            bAlmLevelMap.put("level2", 0);
            bAlmLevelMap.put("level3", 0);
            bAlmLevelMap.put("level4", 0);
            Map<Integer, List<BattalarmData>> blevelMap = bAlmList.stream().collect(Collectors.groupingBy(BattalarmData::getAlmLevel));
            for (Integer level : blevelMap.keySet()) {
                bAlmLevelMap.put("level" + String.valueOf(level), blevelMap.get(level).size());
                //btatolNum += blevelMap.get(level).size();
            }
            map.put("bAlmClearMap", bAlmClearMap);
            map.put("bAlmLevelMap", bAlmLevelMap);
            map.put("btatolNum", btatolNum);
            return new Response().setII(1, true, map, "今日实时告警");
        } catch (Exception e) {
            return new Response().set(1, false, "出现异常" + e.getMessage());
        }
    }

    public List<Integer> getStationList(int userId) {
        return mapper.getStationList(userId);
    }

    public int getCapAlarmNum(int userId) {
        return mapper.getCapAlarmNum(userId);
    }

    public int getCountByStationIds(List<String> stationIdList, Integer level) {
        return mapper.getCountByStationIds(stationIdList,level);
    }

    public List<BattalarmData> getListByStationIds(List<String> stationIdList) {
        return mapper.getListByStationIds(stationIdList);
    }

    public BattalarmData getById(Integer num) {
        return mapper.selectById(num);
    }

    public Response getByLevel(int userId) {
        Map<String,AlarmCountDTO> levelMap = new HashMap<>();
        AlarmCountDTO alarmCount1 = new AlarmCountDTO();
        AlarmCountDTO alarmCount2 = new AlarmCountDTO();
        AlarmCountDTO alarmCount3 = new AlarmCountDTO();
        AlarmCountDTO alarmCount4 = new AlarmCountDTO();

        //电池
        List<BattalarmData> battAlarmList = getLevelListByUserId(userId);
        int battAlarmCountLevel1 = 0;
        int battAlarmCountLevel2 = 0;
        int battAlarmCountLevel3 = 0;
        int battAlarmCountLevel4 = 0;
        for (BattalarmData battalarmData : battAlarmList) {
            Integer almLevel = battalarmData.getAlmLevel();
            if(almLevel == 1){
                battAlarmCountLevel1++;
            }
            else if(almLevel == 2){
                battAlarmCountLevel2++;
            }
            else if(almLevel == 3){
                battAlarmCountLevel3++;
            }
            else if(almLevel == 4){
                battAlarmCountLevel4++;
            }
        }
        alarmCount1.setBattAlarmCount(battAlarmCountLevel1);
        alarmCount2.setBattAlarmCount(battAlarmCountLevel2);
        alarmCount3.setBattAlarmCount(battAlarmCountLevel3);
        alarmCount4.setBattAlarmCount(battAlarmCountLevel4);
        //设备
        List<DevalarmData> deviceAlarmList = devalarmDataMapper.getLevelListByUserId(userId);
        int deviceAlarmCountLevel1 = 0;
        int deviceAlarmCountLevel2 = 0;
        int deviceAlarmCountLevel3 = 0;
        int deviceAlarmCountLevel4 = 0;
        for (DevalarmData deviceAlarmData : deviceAlarmList) {
            Integer almLevel = deviceAlarmData.getAlmLevel();
            if(almLevel == 1){
                deviceAlarmCountLevel1++;
            }
            else if(almLevel == 2){
                deviceAlarmCountLevel2++;
            }
            else if(almLevel == 3){
                deviceAlarmCountLevel3++;
            }
            else if(almLevel == 4){
                deviceAlarmCountLevel4++;
            }
        }
        alarmCount1.setDeviceAlarmCount(deviceAlarmCountLevel1);
        alarmCount2.setDeviceAlarmCount(deviceAlarmCountLevel2);
        alarmCount3.setDeviceAlarmCount(deviceAlarmCountLevel3);
        alarmCount4.setDeviceAlarmCount(deviceAlarmCountLevel4);
        //电源
        List<PwrdevAlarm> powerAlarmList = pwrdevAlarmMapper.getLevelListByUserId(userId);
        int powerAlarmCountLevel1 = 0;
        int powerAlarmCountLevel2 = 0;
        int powerAlarmCountLevel3 = 0;
        int powerAlarmCountLevel4 = 0;
        for (PwrdevAlarm powerAlarmData : powerAlarmList) {
            Integer almLevel = powerAlarmData.getAlmLevel();
            if(almLevel == 1){
                powerAlarmCountLevel1++;
            }
            else if(almLevel == 2){
                powerAlarmCountLevel2++;
            }
            else if(almLevel == 3){
                powerAlarmCountLevel3++;
            }
            else if(almLevel == 4){
                powerAlarmCountLevel4++;
            }
        }
        alarmCount1.setPowerAlarmCount(powerAlarmCountLevel1);
        alarmCount2.setPowerAlarmCount(powerAlarmCountLevel2);
        alarmCount3.setPowerAlarmCount(powerAlarmCountLevel3);
        alarmCount4.setPowerAlarmCount(powerAlarmCountLevel4);

        levelMap.put("level1",alarmCount1);
        levelMap.put("level2",alarmCount2);
        levelMap.put("level3",alarmCount3);
        levelMap.put("level4",alarmCount4);
        return new Response().set(1,levelMap);

    }

    /**
     * 这里面的层级比getByLevel的层级要多一个层级,StationnName5,通过Map<String,levelMap>
     * @param userId
     * @return 返回的结构示例为:
     * {
     *     "1号线": {
     *         "level1":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         },
     *         "level2":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         },
     *         "level3":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         },
     *         "level4":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         }
     *     },
     *     "2号线": {
     *         "level1":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         },
     *         "level2":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         },
     *         "level3":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         },
     *         "level4":{
     *             battAlarmCount: 0,
     *             deviceAlarmCount: 0,
     *             powerAlarmCount: 0
     *         }
     *     }
     *
     * 步骤:
     * 1) 查询所有的区县
     * 2) 获取包含告警级别,区县的电池列表
     * 3) 根据区县分组
     *
     * }
     */
    public Response getByLevelAndStationName5(int userId) {
        //返回的结果结构初始化
        Map<String,Map<String,AlarmCountDTO>> subwayLineLevelMap = new LinkedHashMap<>();
        //查询所有的区县
        List<String> stationName5List = (List<String>) stationInfService.searchAllStationName5(userId,null,null).getData();
        List<BattalarmData> battAlarmListAll = getLevelListByUserId(userId);
        List<DevalarmData> deviceAlarmListAll = devalarmDataMapper.getLevelListByUserId(userId);
        List<PwrdevAlarm> powerAlarmListAll = pwrdevAlarmMapper.getLevelListByUserId(userId);

        for (String stationName5 : stationName5List) {

            Map<String,AlarmCountDTO> levelMap = new HashMap<>();
            AlarmCountDTO alarmCount1 = new AlarmCountDTO();
            AlarmCountDTO alarmCount2 = new AlarmCountDTO();
            AlarmCountDTO alarmCount3 = new AlarmCountDTO();
            AlarmCountDTO alarmCount4 = new AlarmCountDTO();

            //电池
            List<BattalarmData> battAlarmList = battAlarmListAll.stream().filter(battalarmData -> battalarmData.getStationName5().equals(stationName5)).collect(Collectors.toList());
            int battAlarmCountLevel1 = 0;
            int battAlarmCountLevel2 = 0;
            int battAlarmCountLevel3 = 0;
            int battAlarmCountLevel4 = 0;
            for (BattalarmData battalarmData : battAlarmList) {
                Integer almLevel = battalarmData.getAlmLevel();
                if(almLevel == 1){
                    battAlarmCountLevel1++;
                }
                else if(almLevel == 2){
                    battAlarmCountLevel2++;
                }
                else if(almLevel == 3){
                    battAlarmCountLevel3++;
                }
                else if(almLevel == 4){
                    battAlarmCountLevel4++;
                }
            }
            alarmCount1.setBattAlarmCount(battAlarmCountLevel1);
            alarmCount2.setBattAlarmCount(battAlarmCountLevel2);
            alarmCount3.setBattAlarmCount(battAlarmCountLevel3);
            alarmCount4.setBattAlarmCount(battAlarmCountLevel4);
            //设备
            List<DevalarmData> deviceAlarmList = deviceAlarmListAll.stream().filter(devalarmData -> devalarmData.getStationName5().equals(stationName5)).collect(Collectors.toList());
            int deviceAlarmCountLevel1 = 0;
            int deviceAlarmCountLevel2 = 0;
            int deviceAlarmCountLevel3 = 0;
            int deviceAlarmCountLevel4 = 0;
            for (DevalarmData deviceAlarmData : deviceAlarmList) {
                Integer almLevel = deviceAlarmData.getAlmLevel();
                if(almLevel == 1){
                    deviceAlarmCountLevel1++;
                }
                else if(almLevel == 2){
                    deviceAlarmCountLevel2++;
                }
                else if(almLevel == 3){
                    deviceAlarmCountLevel3++;
                }
                else if(almLevel == 4){
                    deviceAlarmCountLevel4++;
                }
            }
            alarmCount1.setDeviceAlarmCount(deviceAlarmCountLevel1);
            alarmCount2.setDeviceAlarmCount(deviceAlarmCountLevel2);
            alarmCount3.setDeviceAlarmCount(deviceAlarmCountLevel3);
            alarmCount4.setDeviceAlarmCount(deviceAlarmCountLevel4);
            //电源
            List<PwrdevAlarm> powerAlarmList = powerAlarmListAll.stream().filter(pwrdevAlarm -> pwrdevAlarm.getStationName5().equals(stationName5)).collect(Collectors.toList());
            int powerAlarmCountLevel1 = 0;
            int powerAlarmCountLevel2 = 0;
            int powerAlarmCountLevel3 = 0;
            int powerAlarmCountLevel4 = 0;
            for (PwrdevAlarm powerAlarmData : powerAlarmList) {
                Integer almLevel = powerAlarmData.getAlmLevel();
                if(almLevel == 1){
                    powerAlarmCountLevel1++;
                }
                else if(almLevel == 2){
                    powerAlarmCountLevel2++;
                }
                else if(almLevel == 3){
                    powerAlarmCountLevel3++;
                }
                else if(almLevel == 4){
                    powerAlarmCountLevel4++;
                }
            }
            alarmCount1.setPowerAlarmCount(powerAlarmCountLevel1);
            alarmCount2.setPowerAlarmCount(powerAlarmCountLevel2);
            alarmCount3.setPowerAlarmCount(powerAlarmCountLevel3);
            alarmCount4.setPowerAlarmCount(powerAlarmCountLevel4);

            levelMap.put("level1",alarmCount1);
            levelMap.put("level2",alarmCount2);
            levelMap.put("level3",alarmCount3);
            levelMap.put("level4",alarmCount4);
            subwayLineLevelMap.put(stationName5,levelMap);

        }
        return new Response().set(1,subwayLineLevelMap);

    }

    private List<BattalarmData> getLevelListByUserId(int userId) {
        return mapper.getLevelListByUserId(userId);
    }
    //61853检测是否存在告警
    public Response checkAlarmById(int devId, int battGroupId) {
        Map<String,Integer> map=new HashMap<>();

        /*  119001	1	在线电压高告警	默认检测
                2	在线电压低告警	默认检测
            119002	3	组端电压高告警	默认检测
                4	组端电压低告警	默认检测
            119004	7	放电电流高告警	默认检测
                8	放电电流低告警	默认关闭
            119005	9	单体电压高告警	默认检测
                10	单体电压低告警	默认检测
            119006	11	单体温度高告警	默认关闭
                12	单体温度低告警	默认关闭
            119007	13	单体内阻高告警	默认关闭
                14	单体内阻低告警	默认关闭
         */
        /*List battList=new ArrayList();
        battList.add(119001);
        battList.add(119002);
        battList.add(119004);
        battList.add(119005);
        battList.add(119006);
        battList.add(119007);
        //查询是否存在电池告警
        QueryWrapper battWrapper=new QueryWrapper();
        battWrapper.eq("BattGroupId",battGroupId);
        battWrapper.in("alm_id",battList);
        List<BattalarmData> battAlm=mapper.selectList(battWrapper);*/

        //查询是否存在设备告警
        /*  119020
            通信故障[平台与主机通信故障]
            618501
            继电器告警
            618502
            通讯告警[汇集器与主机通信故障]
            618503
            设备过温告警
            618504
            二极管D1告警
            618505
            干接点告警
         */
        List devList=new ArrayList();
        devList.add(119020);
        //devList.add(618501);
        devList.add(618502);
        //devList.add(618503);
        //devList.add(618504);
        //devList.add(618505);
        QueryWrapper devWrapper=new QueryWrapper();
        devWrapper.eq("dev_id",devId);
        devWrapper.in("alm_type",devList);
        List<DevalarmData> devAlm=devalarmDataMapper.selectList(devWrapper);
        map.put("battAlm",0);
        map.put("devAlm",devAlm.size());
        return new Response().set(1,map,"61853检测是否存在告警");
    }
}