电源表和电池信息表加入新的字段，添加，编辑需要修改

whyclxw

1 天以前 add5c816a5281cf6b1df4a0988e8b3a0c2b59bee

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

@@ -4,120 +4,548 @@
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.dto.PowerDto;
import com.whyc.constant.BattCapperformanceEnum;
import com.whyc.dto.BattDto;
import com.whyc.dto.InfoDto;
import com.whyc.dto.Param.ParamAlmDto;
import com.whyc.dto.Real.QuarterDto;
import com.whyc.dto.Response;
import com.whyc.dto.SocreHehaviorDto;
import com.whyc.dto.Statistic.*;
import com.whyc.factory.InfoFactory;
import com.whyc.mapper.BattInfMapper;
import com.whyc.pojo.db_station.BattInf;
import com.whyc.pojo.db_station.PowerInf;
import com.whyc.pojo.db_station.StationInf;
import com.whyc.mapper.PowerInfMapper;
import com.whyc.mapper.StationInfMapper;
import com.whyc.pojo.db_station.*;
import com.whyc.pojo.db_user.User;
import com.whyc.util.ActionUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Service
public class BattInfService {
    @Autowired(required = false)
    private BattInfMapper mapper;
/*

    //添加电源
    @Autowired(required = false)
    private PowerInfMapper pinfMapper;

    @Autowired(required = false)
    private StationInfMapper sinfMapper;

    @Autowired(required = false)
    private BaojigroupService bjService;

    @Autowired(required = false)
    private InfoChangeService changeService;

    /*新建电池组（新的设备新的电池组）
     * @param binf
     * 1.在电源下新建设备，记录设备编号，devNum,设备名称为设备类型+devNum
     */
    @Transactional
    public Response addBatt(BattInf binf) {
        //先校验当前用户是否存在包机组不存在则不让添加电源
        User user= ActionUtil.getUser();
        int flag=bjService.checkUserBaojiGroup(user.getId());
        if(flag==0){
            return new Response().set(1,false,"当前用户不存在包机组");
    public void addDev(BattInf adddinf) {
        //检测电源下是否存在设备
        int devNum=mapper.getMaxDevNum(adddinf.getPowerId());
        if(devNum==0){
            devNum=1;
        }else{
            devNum+=1;
        }
        //机房信息
        StationInf addsinf= addpinf.getSinf();
        //判断添加锁的时候机房是不是新机房
        String fullName=addsinf.getProvice()+"_"+addsinf.getCity()+"_"+addsinf.getCountry()+"_"+addsinf.getStationName();
        //判断机房是否存在
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("full_name",fullName);
        wrapper.last("limit 1");
        StationInf sinf=sinfMapper.selectOne(wrapper);
        int stationId=0;
        int powerId=0;
        if(sinf!=null){
            stationId=sinf.getStationId();
        }else {
            //获取对应的机房id
            stationId = sinfMapper.getMaxStationId();
            if (stationId == 0) {//数据库中没有站点
                stationId = 40000001;
            } else {
                stationId += 1;
            }
            addsinf.setFullName(fullName);
            addsinf.setStationId(stationId);
            sinfMapper.insert(addsinf);
        }
        //判断机房是否存在
        QueryWrapper wrapper1=new QueryWrapper();
        wrapper1.eq("power_name",addpinf.getPowerName());
        wrapper1.eq("station_id",stationId);
        wrapper1.last("limit 1");
        PowerInf juegep=mapper.selectOne(wrapper);
        if(juegep==null){
            return new Response().set(1, false, "当前机房下已添加过该电源");
        }
        //再添加电源信息
        addpinf.setStationId(stationId);
        //获取对应的电源id
        powerId = mapper.getMaxPowerId();
        if (powerId == 0) {//数据库中没有站点
            powerId = 10001;
        adddinf.setDevNum(devNum);
        adddinf.setDevName(adddinf.getDevType()+devNum);
        //获取对应的设备id,电池组
        int devId = mapper.getMaxdevId();
        int battGroupId=mapper.getMaxBattGroupId();
        if (devId == 0) {//数据库中没有站点
            devId = 10001;
        } else {
            powerId += 1;
            devId += 1;
        }
        addpinf.setPowerId(powerId);
        mapper.insert(addpinf);
        return new Response().set(1, true, "添加电源");
        if (battGroupId == 0) {//数据库中没有站点
            battGroupId = 10001;
        } else {
            battGroupId += 1;
        }
        adddinf.setDevId(devId);
        adddinf.setBattgroupId(battGroupId);
        adddinf.setBattgroupName("电池组1");
        adddinf.setBattgroupNum(1);
        adddinf.setCreateTime(new Date());
        mapper.insert(adddinf);
    }
    //删除电源
    public Response delBatt(Integer bid) {
        UpdateWrapper wrapper=new UpdateWrapper();
        wrapper.eq("battgroup_id",bid);
        mapper.delete(wrapper);
    //设备下添加电池组
    @Transactional
    public void addBatt(BattInf  addbinf) {
        if(addbinf.getAddBinfFlag()==0){
            //获取设备的通用信息
            QueryWrapper wrapper=new QueryWrapper();
            wrapper.eq("dev_id",addbinf.getDevId());
            wrapper.select("dev_name","dev_type","dev_num","dev_ip","power_id","station_id");
            wrapper.last("limit 1");
            BattInf binf=mapper.selectOne(wrapper);
            addbinf.setPowerId(binf.getPowerId());
            addbinf.setStationId(binf.getStationId());
            addbinf.setDevName(binf.getDevName());
            addbinf.setDevType(binf.getDevType());
            addbinf.setDevNum(binf.getDevNum());
            addbinf.setDevIp(binf.getDevIp());
        }else{//电源下新建一个设备
            //检测电源下是否存在设备
            int devNum=mapper.getMaxDevNum(addbinf.getPowerId());
            if(devNum==0){
                devNum=1;
            }else{
                devNum+=1;
            }
            addbinf.setDevNum(devNum);
            addbinf.setDevName(addbinf.getDevType()+devNum);
            //获取对应的设备id,电池组
            int devId = mapper.getMaxdevId();
            int battGroupId=mapper.getMaxBattGroupId();
            if (devId == 0) {//数据库中没有站点
                devId = 10001;
            } else {
                devId += 1;
            }
            addbinf.setDevId(devId);
        }
        //检测设备下是否存在电池组
        int battgroupNum=mapper.getMaxBattgroupNum(addbinf.getDevId());
        if(battgroupNum==0){
            battgroupNum=1;
        }else{
            battgroupNum+=1;
        }
        int battGroupId=mapper.getMaxBattGroupId();
        if (battGroupId == 0) {//数据库中没有站点
            battGroupId = 10001;
        } else {
            battGroupId += 1;
        }
        addbinf.setBattgroupNum(battgroupNum);
        addbinf.setBattgroupId(battGroupId);
        addbinf.setBattgroupName("电池组"+battgroupNum);
        addbinf.setBattgroupNum(battgroupNum);
        addbinf.setCreateTime(new Date());
        mapper.insert(addbinf);
    }
    //删除电池组
    @Transactional
    public Response delBatt(Integer stationId,  Integer powerId,Integer battgroupId) {
        List<BattInf> binfList=new ArrayList<>();
        if(battgroupId!=null){
            UpdateWrapper wrapper=new UpdateWrapper();
            wrapper.eq("battgroup_id",battgroupId);
            mapper.delete(wrapper);
            //检测如果powerId下电池组删除完了,要将电源也删除掉
            QueryWrapper wrapper1=new QueryWrapper();
            wrapper1.eq("power_id",powerId);
            binfList=mapper.selectList(wrapper1);
        }
        if(binfList==null||binfList.size()==0){
            UpdateWrapper wrapper2=new UpdateWrapper();
            wrapper2.eq("power_id",powerId);
            pinfMapper.delete(wrapper2);
            //删除所有包机组下的电源
            bjService.delPowerInBaoji(powerId);
            //再检测如果机房下电源也全删除了，要将机房也删除
            QueryWrapper wrapper3=new QueryWrapper();
            wrapper3.eq("station_id",stationId);
            List<PowerInf> pinfList=pinfMapper.selectList(wrapper3);
            if(pinfList==null||pinfList.size()==0){
                UpdateWrapper wrapper4=new UpdateWrapper();
                wrapper4.eq("station_id",stationId);
                sinfMapper.delete(wrapper4);
                //删除所有包机组下的机房
                bjService.delStationInBaoji(stationId);
            }
        }
        return new Response().set(1,true);
    }
    //修改电源
    //编辑机房，电源，电池组信息
    @Transactional
    public Response updateInfo(InfoDto info) {
        //先修改机房信息
        PowerInf pinf=InfoFactory.infoToPower(info);
        StationInf sinf=pinf.getSinf();
        UpdateWrapper wrapper1=new UpdateWrapper();
        if(sinf.getStationName()!=null){
            //先查看机房名和stationid是不是匹配的
            QueryWrapper wrapper2=new QueryWrapper();
            wrapper2.eq("station_id",sinf.getStationId());
            wrapper2.last("limit 1");
            StationInf s=sinfMapper.selectOne(wrapper2);
            if(!s.getStationName().equalsIgnoreCase(sinf.getStationName())){
                wrapper1.set("station_name",sinf.getStationName());
                String fullName=sinf.getProvice()+"_"+sinf.getCity()+"_"+sinf.getCountry()+"_"+sinf.getStationName();
                //检测该机房下要修改的电源名是否存在
                QueryWrapper queryWrapper=new QueryWrapper();
                queryWrapper.eq("full_name",fullName);
                queryWrapper.last("limit 1");
                StationInf jueges=sinfMapper.selectOne(queryWrapper);
                if(jueges!=null){
                    return new Response().set(1,false,"已存在"+fullName+"的机房");
                }
                wrapper1.set("full_name",fullName);
            }
        }
        if(sinf.getStationType()!=null){
            wrapper1.set("station_type",sinf.getStationType());
        }
        if(sinf.getLongitude()!=null){
            wrapper1.set("longitude",sinf.getLongitude());
        }
        if(sinf.getLatitude()!=null){
            wrapper1.set("latitude",sinf.getLatitude());
        }
        if(sinf.getNodeStation()!=null){
            wrapper1.set("node_station",sinf.getNodeStation());
        }
        wrapper1.eq("station_id",sinf.getStationId());

        //再修改电源信息
        UpdateWrapper wrapper2=new UpdateWrapper();
        if(pinf.getCompany()!=null){
            wrapper2.set("company",pinf.getCompany());
        }
        if(pinf.getPowerModel()!=null){
            wrapper2.set("power_model",pinf.getPowerModel());
        }
        if(pinf.getProtocol()!=null){
            wrapper2.set("protocol",pinf.getProtocol());
        }
        if(pinf.getPowerIp()!=null){
            wrapper2.set("power_ip",pinf.getPowerIp());
        }
        if(pinf.getPowerType()!=null){
            wrapper2.set("power_type",pinf.getPowerType());
        }
        if(pinf.getPowerInuseTime()!=null){
            wrapper2.set("power_inuse_time",pinf.getPowerInuseTime());
        }
        if(pinf.getModelCfg()!=null){
            wrapper2.set("model_cfg",pinf.getModelCfg());
        }
        if(pinf.getAcvolHighLimit()!=null){
            wrapper2.set("acvol_high_limit",pinf.getAcvolHighLimit());
        }
        if(pinf.getAcvolLowLimit()!=null){
            wrapper2.set("acvol_low_limit",pinf.getAcvolLowLimit());
        }
        if(pinf.getDcoutvolLowLimit()!=null){
            wrapper2.set("dcoutvol_low_limit",pinf.getDcoutvolLowLimit());
        }
        /*if(pinf.getPowerName()!=null){
            //检测该机房下要修改的电源名是否存在
            QueryWrapper queryWrapper1=new QueryWrapper();
            queryWrapper1.eq("power_name",pinf.getPowerName());
            queryWrapper1.eq("station_id",sinf.getStationId());
            queryWrapper1.last("limit 1");
            PowerInf juegep=pinfMapper.selectOne(queryWrapper1);
            if(juegep!=null){
                return new Response().set(1,false,"该机房下已存在"+pinf.getPowerName()+"的电源");
            }
            wrapper2.set("power_name",pinf.getPowerName());
        }*/
        wrapper2.eq("power_id",pinf.getPowerId());

        //最后修改设备信息
        BattInf binf=InfoFactory.infoToBatt(info);
        if(binf.getDevId()!=null) {
            UpdateWrapper wrapper3 = new UpdateWrapper();
            if (binf.getDevIp() != null) {
                wrapper3.set("dev_ip", binf.getDevIp());
            }
           /* if (binf.getDevName() != null) {
                //检测该电源下修改的设备名是否存在
                QueryWrapper queryWrapper2 = new QueryWrapper();
                queryWrapper2.eq("dev_name", binf.getDevName());
                queryWrapper2.eq("power_id", pinf.getPowerId());
                queryWrapper2.last("limit 1");
                BattInf jueged = mapper.selectOne(queryWrapper2);
                if (jueged != null) {
                    return new Response().set(1, false, "该电源下已存在" + binf.getDevName() + "的设备");
                }
                wrapper3.set("dev_name", binf.getDevName());
            }*/
            /*if(binf.getDevType()!=null){
                wrapper3.set("dev_type",binf.getDevType());
            }*/
            wrapper3.eq("dev_id", binf.getDevId());

            //修改电池组信息
            UpdateWrapper wrapper4 = new UpdateWrapper();
            /*if (binf.getBattgroupName() != null) {
                //检测该机房下要修改的电源名是否粗在
                QueryWrapper queryWrapper3 = new QueryWrapper();
                queryWrapper3.eq("battgroup_name", binf.getBattgroupName());
                queryWrapper3.eq("dev_id", binf.getDevId());
                queryWrapper3.last("limit 1");
                BattInf juegeb = mapper.selectOne(queryWrapper3);
                if (juegeb != null) {
                    return new Response().set(1, false, "该设备下已存在" + binf.getBattgroupName() + "的电池组");
                }
                wrapper4.set("battgroup_name", binf.getBattgroupName());
            }*/
            if (binf.getMonvolstd() != null) {
                wrapper4.set("monvolstd", binf.getMonvolstd());
            }
            if (binf.getMoncapstd() != null) {
                wrapper4.set("moncapstd", binf.getMoncapstd());
            }
            if (binf.getMonresstd() != null) {
                wrapper4.set("monresstd", binf.getMonresstd());
            }
            if (binf.getProduct() != null) {
                wrapper4.set("product", binf.getProduct());
            }
            if (binf.getMoncount() != null) {
                wrapper4.set("moncount", binf.getMoncount());
            }
            if (binf.getBattModel() != null) {
                wrapper4.set("batt_model", binf.getBattModel());
            }
            if (binf.getInuseTime() != null) {
                wrapper4.set("inuse_time", binf.getInuseTime());
            }
            if (binf.getFloatVolLevel() != null) {
                wrapper4.set("float_vol_level", binf.getFloatVolLevel());
            }
            if (binf.getOfflinelineVolLevel() != null) {
                wrapper4.set("offlineline_vol_level", binf.getOfflinelineVolLevel());
            }
            if (binf.getFloatCurrLevel() != null) {
                wrapper4.set("float_curr_level", binf.getFloatCurrLevel());
            }
            if (binf.getMaxDisCurr() != null) {
                wrapper4.set("max_dis_curr", binf.getMaxDisCurr());
            }
            if (binf.getSignType()!= null) {
                wrapper4.set("sign_type", binf.getSignType());
            }
            if (binf.getCommPort()!= null) {
                wrapper4.set("comm_port", binf.getCommPort());
            }
            if (binf.getLoadCurr()!= null) {
                wrapper4.set("load_curr", binf.getLoadCurr());
            }
            if (binf.getVideoUrl()!= null) {
                wrapper4.set("video_url", binf.getVideoUrl());
            }
            wrapper4.eq("battgroup_id", binf.getBattgroupId());
            mapper.update((BattInf) ActionUtil.objeNull,wrapper3);
            mapper.update((BattInf) ActionUtil.objeNull,wrapper4);
        }
        sinfMapper.update((StationInf) ActionUtil.objeNull,wrapper1);
        pinfMapper.update((PowerInf) ActionUtil.objeNull,wrapper2);
        //存入变更信息记录
        pinf.setStationId(sinf.getStationId());
        binf.setStationId(sinf.getStationId());
        binf.setPowerId(pinf.getPowerId());
        changeService.addInfoChange(sinf,pinf,binf,info.getUpdateReason());
        return new Response().set(1,true,"修改信息成功");
    }
    /*//修改电池组
    public Response updateBatt(BattInf binf) {
        UpdateWrapper wrapper1=new UpdateWrapper();
        wrapper1.eq("dev_id",binf.getDevId());
        if(binf.getDevIp()!=null){
            wrapper1.set("dev_ip",binf.getDevIp());
        }
        if(binf.getDevName()!=null){
            wrapper1.set("dev_name",binf.getDevName());
        }
        UpdateWrapper wrapper=new UpdateWrapper();
        wrapper.eq("battgroup_id",binf.getBattgroupId());
        if(binf.getBattgroupName()!=null){
            //检测该机房下要修改的电源名是否粗在
            QueryWrapper queryWrapper=new QueryWrapper();
            queryWrapper.eq("battgroup_name",binf.getBattgroupName());
            queryWrapper.eq("dev_id",binf.getDevId());
            queryWrapper.last("limit 1");
            BattInf juegeb=mapper.selectOne(queryWrapper);
            if(juegeb!=null){
                return new Response().set(1,false,"该设备下已存在"+binf.getBattgroupName()+"的电池组");
            }
            wrapper.set("battgroup_name",binf.getBattgroupName());
        }
        if(binf.getCompany()!=null){
            wrapper.set("company",pinf.getCompany());
        if(binf.getMonvolstd()!=null){
            wrapper.set("monvolstd",binf.getMonvolstd());
        }
        if(pinf.getModel()!=null){
            wrapper.set("model",pinf.getModel());
        if(binf.getMoncapstd()!=null){
            wrapper.set("moncapstd",binf.getMoncapstd());
        }
        if(pinf.getProtocol()!=null){
            wrapper.set("protocol",pinf.getProtocol());
        if(binf.getMonresstd()!=null){
            wrapper.set("monresstd",binf.getMonresstd());
        }
        if(pinf.getPowerIp()!=null){
            wrapper.set("power_ip",pinf.getPowerIp());
        if(binf.getProduct()!=null){
            wrapper.set("product",binf.getProduct());
        }
        mapper.update((PowerInf) ActionUtil.objeNull,wrapper);
        if(binf.getMoncount()!=null){
            wrapper.set("moncount",binf.getMoncount());
        }
        if(binf.getBattModel()!=null){
            wrapper.set("batt_model",binf.getBattModel());
        }
        mapper.update((BattInf) ActionUtil.objeNull,wrapper);
        return new Response().set(1,true);
    }
    //查询电源
    public Response getBatt(PowerDto dto) {
    }*/
    //查询机房，电源，电池组信息
    public Response getInfo(BattDto dto) {
        User user= ActionUtil.getUser();
        dto.setUid(user.getId());
        PageHelper.startPage(dto.getPageNum(),dto.getPageSize());
        List<PowerInf> list=mapper.getPower(dto);
        List<InfoDto> list=mapper.getInfo(dto);
        PageInfo pageInfo=new PageInfo(list);
        return new Response().setII(1,list!=null,pageInfo,"查询电源");
        return new Response().setII(1,list!=null,pageInfo,"查询电池");
    }
*/

    //获取电池品牌(下拉)
    public Response getProductByUid(Integer uid) {
        List<String> list=mapper.getProductByUid(uid);
        return new Response().setII(1,list.size()>0,list,"获取电池品牌(下拉)");
    }
    //获取标称单体电压(下拉)
    public Response getMonVolByUid(Integer uid) {
        List<Float> list=mapper.getMonVolByUid(uid);
        return new Response().setII(1,list.size()>0,list,"获取标称单体电压(下拉)");
    }

    //获取标称容量(下拉)
    public Response getMonCapByUid(Integer uid) {
        List<Float> list=mapper.getMonCapByUid(uid);
        return new Response().setII(1,list.size()>0,list,"获取标称容量(下拉)");
    }

    //获取标称内阻(下拉)
    public Response getMonResByUid(Integer uid) {
        List<Float> list=mapper.getMonResByUid(uid);
        return new Response().setII(1,list.size()>0,list,"获取标称内阻(下拉)");
    }
    //获取设备型号(下拉)
    public Response getDevTypeByUid(Integer uid) {
        List<String> list=mapper.getDevTypeByUid(uid);
        return new Response().setII(1,list.size()>0,list,"获取设备型号(下拉)");
    }

    //根据电池组id获取电池组信息
    public BattInf getBinfByBattgroupId(Integer battgroupId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("battgroup_id",battgroupId);
        wrapper.last("limit 1");
        BattInf binf=mapper.selectOne(wrapper);
        List<BattInfChange> binfChangeList=changeService.getBinfChange(battgroupId);
        binf.setBinfChangeList(binfChangeList);
        return binf;
    }
   //当没有内助测试时初始内阻值为标称内阻
    public List<QuarterDto> getBinfResStd(Integer battgroupId) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("battgroup_id",battgroupId);
        wrapper.last("limit 1");
        BattInf binf=mapper.selectOne(wrapper);
        Float monresstd=binf.getMonresstd();
        List<QuarterDto> list=new ArrayList<>();
        for(int i=0;i<binf.getMoncount();i++){
            QuarterDto dto=new QuarterDto();
            dto.setRecordTime(binf.getCreateTime());
            dto.setMonNum(i+1);
            dto.setNumValue(monresstd);
        }
        return list;
    }

    //设备信息统计
    public Response getDevStatistic(StationStic stic) {
        PageHelper.startPage(stic.getPageNum(),stic.getPageSize());
        List<BattInf> list=mapper.getDevStatistic(stic);
        for (BattInf binf:list) {
            //获取设备下电池组个数
            int battCount=mapper.getBattCountBydevId(binf.getDevId());
            binf.setBattCount(battCount);
        }
        PageInfo<BattInf> pageInfo=new PageInfo<>(list);
        return new Response().setII(1,list.size()>0,pageInfo,"设备信息统计");
    }
    //蓄电池组信息统计
    public Response getBattStatistic(StationStic stic) {
        PageHelper.startPage(stic.getPageNum(),stic.getPageSize());
        List<BattInf> list=mapper.getBattStatistic(stic);
        PageInfo<BattInf> pageInfo=new PageInfo<>(list);
        return new Response().setII(1,list.size()>0,pageInfo,"蓄电池组信息统计");
    }
    //单体统计查询符合条件的电池组
    public List<BattInf> getMonStatistic(MonStic stic) {
        return mapper.getMonStatistic(stic);
    }
    //蓄电池组对比分析界面15
    public List<BattInf> getBattCompare15Statistic(BattCompareStic stic) {
        return mapper.getBattCompare15Statistic(stic);
    }
    //获取容量性能(下拉)
    public Response getCapperformance() {
        Map<Integer,String> map= BattCapperformanceEnum.getOpInfo();
        return new Response().setII(1,true,map,"获取容量性能(下拉)");
    }
    //蓄电池组对比分析界面16
    public List<BattInf> getBattCompare16Statistic(BattCompareStic stic) {
        return mapper.getBattCompare16Statistic(stic);
    }
    //蓄电池组对比分析界面17
    public List<BattInf> getBattCompare17Statistic(BattCompareStic stic) {
        return mapper.getBattCompare17Statistic(stic);
    }
    //本年度已放电数量统计(1.2.5)
    public List<BattInf> getDischr5Statistic(DisChargeStic stic) {
        return mapper.getDischr5Statistic(stic);
    }
    //本年度已放电数量统计(1.2.6)
    public List<BattInf> getDischr6Statistic(DisChargeStic stic) {
        return mapper.getDischr6Statistic(stic);
    }
    //电池组电池性能统计（未放电，优秀，劣化，损坏）统计(1.2.8/9/10)
    public List<BattInf> getPerformanceStatistic(PerformanceStic stic) {
        return mapper.getPerformanceStatistic(stic);
    }
    //本年度已/未放电数量统计右侧图表(1.2.5)
    public List<BattInf> getDischrChart(Integer uid) {
        return mapper.getDischrChart(uid);
    }

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

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

    //获取站点下的电池组(下拉)
    public Response getBattByUid(Integer uid, String provice, String city, String country, String stationName) {
        List<BattInf> list=mapper.getBattByUid(uid,provice,city,country,stationName);
        return new Response().setII(1,list.size()>0,list,"获取站点下的电池组(下拉)");
    }
    //根据查询条件获取电池组
    public  BattInf getBattgroupIdInf(Integer battgroupId) {
        return mapper.getBattgroupIdInf(battgroupId);
    }
    //查询电源下所有的电池组id
    public List<BattInf> getBattgroupIdListByPowerId(Integer powerId) {
        return mapper.getBattgroupIdListByPowerId(powerId);
    }
    //查询设备下所有的电池组id
    public List<BattInf> getBattgroupIdListByDevId(Integer devId) {
        return mapper.getBattgroupIdListByDevId(devId);
    }
    //询符合条件的电池组权重表格评分
    public List<BattInf> getScoreByHehavior(SocreHehaviorDto dto) {
        return mapper.getScoreByHehavior(dto);
    }
}