导出中英文切换日志

lxw

2023-05-25 f3c27fb78447449a950ba73c5e72ceda64ad8a12

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

@@ -3,23 +3,20 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.dto.BattCapFactory;
import com.whyc.dto.BattState;
import com.whyc.dto.BattTestData;
import com.whyc.dto.Response;
import com.whyc.dto.*;
import com.whyc.dto.paramter.GroupTestCapPar;
import com.whyc.dto.result.GroupTestCapRes;
import com.whyc.dto.result.ReportBattTestDTO;
import com.whyc.mapper.BattParamLowMapper;
import com.whyc.mapper.BattTestDataStopMapper;
import com.whyc.mapper.BatttestdataInfMapper;
import com.whyc.pojo.BattParamLow;
import com.whyc.pojo.BattTestDataStop;
import com.whyc.pojo.Battinf;
import com.whyc.pojo.BatttestdataInf;
import com.whyc.mapper.*;
import com.whyc.pojo.*;
import com.whyc.util.ActionUtil;
import com.whyc.util.MessageUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class BatttestdataInfService {
@@ -33,32 +30,52 @@
    @Resource
    private BattParamLowMapper battParamLowMapper;

    @Resource
    AlarmParamMapper alarmParamMapper;

    @Resource
    BattInfMapper binfMapper;

    //在线监测-历史监控-获取充放电记录
    public Response searchBattTestInfDataById(int battGroupId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("BattGroupId",battGroupId);
        wrapper.eq("data_available",1);
        int judgeNum=mapper.judge(battGroupId);
        if(judgeNum>0){
            List<BatttestdataInf> list=mapper.selectList(wrapper);
            list.stream().forEach(tinf->{
    public Response searchBattTestInfDataById(int battGroupId, int fbsDeviceId) {
        String lang = ActionUtil.getLang();
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("BattGroupId", battGroupId);
        wrapper.eq("data_available", 1);
        wrapper.orderByDesc("test_starttime");
        int judgeNum = mapper.judge(battGroupId);
        if (judgeNum > 0) {
            List<BatttestdataInf> list = mapper.selectList(wrapper);
            list.stream().forEach(tinf -> {
                //放电终止原因
                if(battGroupId/100000==6185){
                if (fbsDeviceId / 100000 == 6185) {
                    //61850设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_6185(tinf.getTestStoptype()));
                }else if(battGroupId/100000==4016){
                } else if (fbsDeviceId / 100000 == 4016) {
                    //6度设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_4016(tinf.getTestStoptype()));
                }else if(battGroupId/100000==9110){
                } else if (fbsDeviceId / 100000 == 9110) {
                    //假负载设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_9110(tinf.getTestStoptype()));
                }else if(battGroupId/100000==9120){
                } else if ((fbsDeviceId / 100000 == 9120) || (fbsDeviceId / 100000 == 9140)) {
                    // 逆变设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_9120(tinf.getTestStoptype()));
                }else if(battGroupId/100000==8059){
                } else if (fbsDeviceId / 100000 == 8059) {
                    //一体机设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_8059(tinf.getTestStoptype()));
                }else{
                } else if (fbsDeviceId / 100000 == 6087) {
                    //电操核容设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_6087(tinf.getTestStoptype()));
                } else if (fbsDeviceId / 100000 == 4830) {
                    //FBO4830设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_4830(tinf.getTestStoptype()));
                } else if (fbsDeviceId / 100000 == 4831) {
                    //FBO4831设备放电停止原因
                    tinf.setTestStoptypeReason(MessageUtils.getMessageSocket(BattTestData.getStopType_4831(tinf.getTestStoptype()), lang));
                } else if (fbsDeviceId / 100000 == 4815) {
                    //FBO4815设备放电停止原因
                    tinf.setTestStoptypeReason(BattTestData.getStopType_4815(tinf.getTestStoptype()));
                } else {
                    tinf.setTestStoptypeReason(BattTestData.getStopType(tinf.getTestStarttype(), tinf.getTestStoptype()));
                }
            });
@@ -70,21 +87,52 @@
    }

    //最后一次核容放电数据
    public Response searchBattLastHrDataById(int battGroupId) {
        PageHelper.startPage(1,1);
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("BattGroupId",battGroupId);
        wrapper.eq("data_available",1);
        wrapper.eq("test_type",3);
        wrapper.eq("test_starttype",3);
    public Response searchBattLastHrDataById(int battGroupId, int devId, String lang) {
        PageHelper.startPage(1, 1);
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("BattGroupId", battGroupId);
        wrapper.eq("data_available", 1);
        wrapper.eq("test_type", 3);
        wrapper.eq("test_starttype", 3);
        wrapper.orderByDesc("test_starttime");
        BatttestdataInf tinf=mapper.selectOne(wrapper);
        List<BattTestDataStop> list=new ArrayList<BattTestDataStop>();
        if(tinf!=null){
            list=stopMapper.getTestDataStop(tinf.getBattGroupId(),tinf.getTestStarttime());
        BatttestdataInf tinf = mapper.selectOne(wrapper);
        List<BattTestDataStop> list = new ArrayList<BattTestDataStop>();
        if (tinf != null) {
            //放电终止原因
            if (devId / 100000 == 6185) {
                //61850设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_6185(tinf.getTestStoptype()));
            } else if (devId / 100000 == 4016) {
                //6度设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_4016(tinf.getTestStoptype()));
            } else if (devId / 100000 == 9110) {
                //假负载设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_9110(tinf.getTestStoptype()));
            } else if ((devId / 100000 == 9120) || (devId / 100000 == 9140)) {
                // 逆变设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_9120(tinf.getTestStoptype()));
            } else if (devId / 100000 == 8059) {
                //一体机设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_8059(tinf.getTestStoptype()));
            } else if(devId / 100000 == 6087) {
                //电操核容设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_6087(tinf.getTestStoptype()));
            }else if (devId / 100000 == 4830) {
                // FBO4830设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_4830(tinf.getTestStoptype()));
            } else if (devId / 100000 == 4831) {
                // FBO4830设备放电停止原因
                tinf.setTestStoptypeReason(MessageUtils.getMessageSocket(BattTestData.getStopType_4831(tinf.getTestStoptype()), lang));
            } else if (devId / 100000 == 4815) {
                //FBO4815设备放电停止原因
                tinf.setTestStoptypeReason(BattTestData.getStopType_4815(tinf.getTestStoptype()));
            } else {
                tinf.setTestStoptypeReason(BattTestData.getStopType(tinf.getTestStarttype(), tinf.getTestStoptype()));
            }
            list = stopMapper.getTestDataStop(tinf.getBattGroupId(), tinf.getTestStarttime());
            tinf.setBatttestdataList(list);
        }
        return new Response().set(1,tinf);
        return new Response().setII(1, tinf != null ? true : false, tinf, "");
    }

    //报表分析使用
@@ -104,6 +152,7 @@
    //1.4电池组性能评估(根据电池组id查询所有的放电记录求出放电总次数，最高历史容量,最低历史容量，平均容量，最新测试容量)
    public List searchDischargeTest(BatttestdataInf tinf){
        List<BatttestdataInf> list = mapper.searchDischargeTest(tinf);
        List<BatttestdataInf> testList = new LinkedList<>();
        int sum=0;//总测试次数
        float cap=0f;//实际容量
        float allCap=0f;//总容量
@@ -115,6 +164,8 @@
            BatttestdataInf binf = list.get(i);
            int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(),binf.getTestCurr());
            cap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate,binf.getTestCap(), binf.getMaxMonvol(), binf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Real);
            binf.setRealCap(cap);
            testList.add(binf);
            if(sum==0){
                lastCap=cap;
            }
@@ -140,56 +191,300 @@
        list1.add(avgCap);
        list1.add(minCap);
        list1.add(lastCap);
        list1.add(testList);
        return list1;
    }

    //public Response searchBattLifeNow(int pageNum,int pageSize,Battinf binf){
    //    PageHelper.startPage(pageNum,pageSize);
    //    List<BattState> list = mapper.searchBattLifeNow(binf);
    //    PageInfo<BattState> pageInfo = new PageInfo<>(list);
    //    return new Response().set(1,pageInfo,"查询成功");
    //}
    //
    //public Response searchBattLife(int pageNum,int pageSize,Battinf binf){
    //    PageHelper.startPage(pageNum,pageSize);
    //    List<ReportBattTestDTO> list = mapper.searchBattLife(binf);
    //    float param = 0;//容量有效参数
    //    double STDAH = 0;//标存容量
    //    BattParamLow capLow=new BattParamLow();
    //    capLow.setLowType(BattCapFactory.CapType_type);;
    //    capLow.setLowNametype(BattCapFactory.CapType_name);
    //    capLow.setLowMethod(BattCapFactory.CapType_method);
    //    List<BattParamLow> listC = battParamLowMapper.serchByLow(capLow);
    //    if (listC!=null && listC.size()>0){
    //        param = listC.get(listC.size()-1).getLowValue();
    //    }
    //    int flag=0;//该次放电是否有效判断
    //    List<ReportBattTestDTO> listE=new ArrayList();//存放放电有效的测试
    //    if (list!=null &&list.size()>0){
    //        for(int i=0;i<list.size();i++){
    //            STDAH=list.get(i).getBinf().getMonCapStd();
    //            float testCap=list.get(i).getTdata().getTestCap();//此次放电量统计
    //            //System.out.println(list.get(i).getTdata().getBattGroupId()+"  "+list.get(i).getTdata().getTest_record_count()+"   "+testCap+"  "+param+"  "+STDAH);
    //            flag=BattCapFactory.Judge(testCap, param, STDAH);
    //            if(flag==1){
    //                if(listE.size()>0){
    //                    int tdata_battgroupid=list.get(i).getTdata().getBattGroupId();
    //                    int e_battgroupid=listE.get(listE.size()-1).getTdata().getBattGroupId();
    //                    if(tdata_battgroupid!=e_battgroupid){
    //                        listE.add(list.get(i));
    //                    }else{
    //                        continue;
    //                    }
    //                }else{
    //                    listE.add(list.get(i));
    //                }
    //                flag=0;
    //            }
    //        }
    //    }
    //    PageInfo<ReportBattTestDTO> pageInfo = new PageInfo<>(list);
    //    return new Response().set(1,pageInfo,"查询成功");
    //}
    public Response searchBattLifeNow(int pageNum,int pageSize,Battinf binf){
        PageHelper.startPage(pageNum,pageSize);
        List<BattState> list = mapper.searchBattLifeNow(binf);
        PageInfo<BattState> pageInfo = new PageInfo<>(list);
        return new Response().set(1,pageInfo,"查询成功");
    }

    public Response searchBattLife(int pageNum,int pageSize,Battinf binf){
        //PageHelper.startPage(pageNum,pageSize);
        List<ReportBattTestDTO> list = mapper.searchBattLife(binf);
        float param = 0;//容量有效参数
        double STDAH = 0;//标存容量
        BattParamLow capLow=new BattParamLow();
        capLow.setLowType(BattCapFactory.CapType_type);;
        capLow.setLowNametype(BattCapFactory.CapType_name);
        capLow.setLowMethod(BattCapFactory.CapType_method);
        List<BattParamLow> listC = battParamLowMapper.serchByLow(capLow);
        if (listC!=null && listC.size()>0){
            param = listC.get(listC.size()-1).getLowValue();
        }
        int flag=0;//该次放电是否有效判断
        List<ReportBattTestDTO> listE=new ArrayList();//存放放电有效的测试
        //当前页记录列表
        LinkedList<ReportBattTestDTO> data = new LinkedList<>();
        //对结果进行分页
        Page page = new Page();
        if (list!=null &&list.size()>0){
            for(int i=0;i<list.size();i++){
                if (list.get(i).getBinf().getMonCapStd() != null) {
                    STDAH = list.get(i).getBinf().getMonCapStd();
                }
                float testCap=list.get(i).getTdata().getTestCap();//此次放电量统计
                //System.out.println(list.get(i).getTdata().getBattGroupId()+"  "+list.get(i).getTdata().getTest_record_count()+"   "+testCap+"  "+param+"  "+STDAH);
                flag=BattCapFactory.Judge(testCap, param, STDAH);
                if(flag==1){
                    if(listE.size()>0){
                        int tdata_battgroupid=list.get(i).getTdata().getBattGroupId();
                        int e_battgroupid=listE.get(listE.size()-1).getTdata().getBattGroupId();
                        if(tdata_battgroupid!=e_battgroupid){
                            listE.add(list.get(i));
                        }else{
                            continue;
                        }
                    }else{
                        listE.add(list.get(i));
                    }
                    flag=0;
                }
            }

            page.setPageCurr(pageNum);
            page.setPageSize(pageSize);
            //总页数
            page.setPageAll(listE.size());
            if(listE.size()>pageSize*pageNum) {
                for (int i = (pageNum-1)*pageSize; i < pageSize*pageNum; i++) {
                    data.add(listE.get(i));
                }
            }else {
                int a1 = (pageNum - 1) * pageSize;
                int a2 = (listE.size() - ((pageNum - 1) * pageSize));
                for (int i = (pageNum - 1) * pageSize; i < listE.size(); i++) {
                    data.add(listE.get(i));
                }
            }
        }
        page.setData(data);
        return new Response().set(1, page, "查询成功");
    }

    //统计时间段内设备的测试容量
    public Response searchGroupTestCap(GroupTestCapPar groupCapPar) {
        PageHelper.startPage(groupCapPar.getPageCurr(), groupCapPar.getPageSize());
        List<GroupTestCapRes> list = mapper.searchGroupTestCap(groupCapPar);
        PageInfo pageInfo = new PageInfo(list);
        return new Response().setII(1, list.size() > 0 ? true : false, pageInfo, "统计时间段内设备的测试容量");
    }

    //管理员首页头部信息加入
    public int getYearAnalysis(int userId) {
        //Map<String, Integer> map = new HashMap<>();
        //本年已核容放电电池组数
        int hrdisNum = mapper.getHrQuarter(userId);
        //本年已停电放电电池组数
        //int jcdisNum = mapper.getJcQuarter(userId);
        //map.put("hrdisNum", hrdisNum);
        // map.put("jcdisNum", jcdisNum);
        return hrdisNum;
    }

    //获取本年已核容电池组
    public Response getHrYeardisBatt() {
        UserInf uinf = ActionUtil.getUser();
        String userId = uinf.getUId().toString();
        List<Battinf> list = mapper.getHrYeardisBatt(userId);
        return new Response().setII(1, list.size() > 0, list, "获取本年已核容电池组");
    }

    //获取实时停电放电电池组
    public Response getJcdisBatt() {
        UserInf uinf = ActionUtil.getUser();
        String userId = uinf.getUId().toString();
        List<Battinf> list = mapper.getJcdisBatt(userId);
        for (Battinf binf : list) {
            int battgroupId = 0;
            battgroupId = binfMapper.searchBattGroupId(binf.getStationId());
            binf.setBattGroupId(battgroupId);
        }
        return new Response().setII(1, list.size() > 0, list, "获取本年已核容电池组");
    }

    //测试信息
    @Transactional
    public Response getTestdataInfAnalysis(int userId) {
        try {
            Map<String, Object> map = new HashMap<>();
            //本月数据
            List<BatttestdataInf> listMonth = mapper.selectMonth(userId);
            map.put("month", analysisTestData(listMonth));
            //本季度
            List<BatttestdataInf> listQuarter = mapper.selectQuarter(userId);
            map.put("quarter", analysisTestData(listQuarter));
            //本年
            List<BatttestdataInf> listYear = mapper.selectYear(userId);
            map.put("year", analysisTestData(listYear));
            return new Response().setII(1, true, map, "测试信息");
        } catch (Exception e) {
            return new Response().set(1, false, "发生异常:" + e.getCause());
        }
    }

    //管理员首页统计测试信息
    public Map<String, Integer> analysisTestData(List<BatttestdataInf> list) {
        Map<String, Integer> map = new HashMap<>();
        int disNum = 0;//放电
        int chNum = 0;//充电
        int hrdisNum = 0;//核容放电
        int hrchNum = 0;//核容充电
        Map<Integer, List<BatttestdataInf>> listDisMap = list.stream().collect(Collectors.groupingBy(tinf -> tinf.getTestType()));
        for (Integer dis : listDisMap.keySet()) {
            //放电
            if (dis == 3) {
                disNum = listDisMap.get(dis).size();
            }
            //充电
            if (dis == 2) {
                chNum = listDisMap.get(dis).size();
            }
        }
        Map<String, List<BatttestdataInf>> listMap = list.stream().collect(Collectors.groupingBy(tinf -> tinf.getTestType() + "_" + tinf.getTestStarttype()));
        for (String type : listMap.keySet()) {
            //核容放电
            if (type.equals("3_3")) {
                hrdisNum = listMap.get(type).size();

            }
            //核容充电
            if (type.equals("2_3")) {
                hrchNum = listMap.get(type).size();
            }
        }
        map.put("hrdisNum", hrdisNum);
        map.put("hrchNum", hrchNum);
        map.put("jcdisNum", disNum - hrdisNum);
        map.put("jcchNum", chNum - hrchNum);
        return map;
    }

    //查询今天所有正在放电的机房总数
    public int getPlanStaticToday(int userId) {
        int num = mapper.getPlanStaticToday(userId);
        return num;
    }

    //本年度核容放电电池组(testdate_inf中test_type=3,test_startType=3)
    public int getHrQuarter(int userId) {
        //本年度
        int hrQuarter = mapper.getHrQuarter(userId);
        return hrQuarter;
    }

    /*领导层本年度已放数 仅需要统计放电正常停止的 正常停止的条件如下：
                stop_type:
                2-放电时间到终止
                3-放电容量到终止
                4-单体电压下限到终止
                6-组端电压下限到终止*/
    public int getHrQuarterZC(int userId) {
        int hrQuarter = mapper.getHrQuarterZC(userId);
        return hrQuarter;
    }

    //蓄电池组优劣分析(用蓄电池组组后评估的统计)
    public Response getGroupAnalysis(int userId) {
        try {
            //0.查询劣化(告警)和损坏(更换)的阈值
            QueryWrapper<AlarmParam> alarmWrapper = new QueryWrapper();
            alarmWrapper.and(wrapper -> {
                return wrapper.eq("alm_name", "Batt_Alarm_Type_CapAlarm").or().eq("alm_name", "Batt_Alarm_Type_CapChange");
            });
            alarmWrapper.orderByAsc("alm_id");
            List<AlarmParam> paramList = alarmParamMapper.selectList(alarmWrapper);
            float capAlarm = 0f;
            float capChange = 0f;
            if (paramList != null && paramList.size() > 0) {
                capAlarm = paramList.get(0).getAlmLowCoe();//劣化参数0.8
                capChange = paramList.get(1).getAlmLowCoe();//损坏参数0.6
            } else {
                capAlarm = 0.8f;
                capChange = 0.6f;
            }
            //1.查出符合条件的电池组(核容数据)按照时间倒叙排序
            List<BatttestdataInf> list = mapper.getGroupAnalysis(userId);
            //2.分组取出每个电池组的最新一笔数据(取电池组放电数据的第一个)
            //Map<String, String> map = new HashedMap();
            //小于capAlarm
            int alarmNum = 0;
            //小于capChange
            int changeNum = 0;
            String battGroupId = "0";
            if (list != null && list.size() > 0) {
                for (BatttestdataInf inf : list) {
                    if (!battGroupId.equals(inf.getBattGroupId().toString())) {
                        int hourRate = BattCapFactory.GetHourRate(inf.getMonCapStd(), inf.getTestCurr());
                        float cap = (float) BattCapFactory.GetMonomerCap(inf.getMonCapStd(), hourRate, inf.getTestCap(), inf.getMaxMonvol(), inf.getMinMonvol(), inf.getMonVolStd(), BattCapFactory.CapType_Real);
                        if (cap < capAlarm * inf.getMonCapStd()) {
                            alarmNum = alarmNum + 1;
                        }
                        if (cap < capChange * inf.getMonCapStd()) {
                            changeNum = changeNum + 1;
                        }
                        battGroupId = inf.getBattGroupId().toString();
                        //map.put(battGroupId, inf.getMonCapStd() + " " + inf.getMonVolStd() + " " + cap + " " + capAlarm + " " + capChange);
                    }
                }
            }
            Map<String, Integer> numMap = new HashMap<>();
            numMap.put("alarmNum", (alarmNum - changeNum));
            numMap.put("changeNum", changeNum);
            //总电池组(分类)
            int groupNum = binfMapper.geGroupCount(userId);
            numMap.put("groupNum", groupNum);
            //蓄电池优良
            numMap.put("goodSum", (groupNum - alarmNum));
            return new Response().setII(1, true, numMap, "蓄电池组优劣分析");
        } catch (Exception e) {
            return new Response<>().set(1, false, "发生异常:" + e.getCause());
        }
    }

    //获取本年已核容放电电池组最新一次数据详情
    public Response getHrYeardisBattInfo() {
        int userId = Integer.parseInt(ActionUtil.getUser().getUId().toString());
        try {
            //0.查询劣化(告警)和损坏(更换)的阈值
            QueryWrapper<AlarmParam> alarmWrapper = new QueryWrapper();
            alarmWrapper.and(wrapper -> {
                return wrapper.eq("alm_name", "Batt_Alarm_Type_CapAlarm").or().eq("alm_name", "Batt_Alarm_Type_CapChange");
            });
            alarmWrapper.orderByAsc("alm_id");
            List<AlarmParam> paramList = alarmParamMapper.selectList(alarmWrapper);
            float capAlarm = 0f;
            float capChange = 0f;
            if (paramList != null && paramList.size() > 0) {
                capAlarm = paramList.get(0).getAlmLowCoe();//劣化参数0.8
                capChange = paramList.get(1).getAlmLowCoe();//损坏参数0.6
            } else {
                capAlarm = 0.8f;
                capChange = 0.6f;
            }
            //1.查出符合条件的电池组(核容数据)按照时间倒叙排序
            List<BatttestdataInf> list = mapper.getGroupAnalysis(userId);
            //2.分组取出每个电池组的最新一笔数据(取电池组放电数据的第一个)
            List<BatttestdataInf> infoList = new ArrayList<>();
            String battGroupId = "0";
            if (list != null && list.size() > 0) {
                for (BatttestdataInf inf : list) {
                    if (!battGroupId.equals(inf.getBattGroupId().toString())) {
                        int hourRate = BattCapFactory.GetHourRate(inf.getMonCapStd(), inf.getTestCurr());
                        float cap = (float) BattCapFactory.GetMonomerCap(inf.getMonCapStd(), hourRate, inf.getTestCap(), inf.getMaxMonvol(), inf.getMinMonvol(), inf.getMonVolStd(), BattCapFactory.CapType_Real);
                        inf.setRealCap(cap);
                        infoList.add(inf);
                        battGroupId = inf.getBattGroupId().toString();
                    }
                }
            }

            return new Response().setII(1, true, infoList, "获取本年已核容放电电池组最新一次数据详情");
        } catch (Exception e) {
            return new Response<>().set(1, false, "发生异常:" + e.getCause());
        }
    }
}