package com.whyc.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.whyc.constant.Capperformance;
|
import com.whyc.constant.StopReasonEnum;
|
import com.whyc.dto.Response;
|
import com.whyc.dto.Statistic.*;
|
import com.whyc.factory.BattCapFactory;
|
import com.whyc.mapper.BatttestdataInfMapper;
|
import com.whyc.pojo.db_batt_testdata.BatttestdataId;
|
import com.whyc.pojo.db_batt_testdata.BatttestdataInf;
|
import com.whyc.pojo.db_param.AppParam;
|
import com.whyc.pojo.db_ram_db.BattRtdata;
|
import com.whyc.pojo.db_ram_db.BattRtstate;
|
import com.whyc.pojo.db_station.BattInf;
|
import com.whyc.util.PageInfoUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.*;
|
|
@Service
|
public class BatttestdataInfService {
|
@Autowired(required = false)
|
private BatttestdataInfMapper mapper;
|
|
@Autowired(required = false)
|
private BattRtstateService rtstateService;
|
|
@Autowired(required = false)
|
private BattRtdataService rtdataService;
|
|
@Autowired(required = false)
|
private BattInfService battInfService;
|
|
@Autowired(required = false)
|
private BatttestdataIdService battTestdataIdService;
|
|
@Autowired(required = false)
|
private AppParamService appParamService;
|
|
|
|
|
//获取最后一次测试数据并计算剩余容量
|
public Float getLastTestDataRestCap(Integer battgroupId) {
|
//获取放电记录
|
QueryWrapper wrapper=new QueryWrapper();
|
wrapper.eq("battgroup_id",battgroupId);
|
wrapper.orderByDesc("test_starttime");
|
wrapper.last("limit 1");
|
BatttestdataInf tinf=mapper.selectOne(wrapper);
|
if(tinf!=null){
|
int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(), tinf.getTestCurr());
|
Float restcap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Rest);
|
return restcap;
|
}else{
|
return 0f;
|
}
|
}
|
//蓄电池核容信息统计
|
public Response getBattTinfStatistic(BattTinfStic stic) {
|
PageHelper.startPage(stic.getPageNum(), stic.getPageSize());
|
List<BatttestdataInf> list=mapper.getBattTinfStatistic(stic);
|
if(list!=null&&list.size()>0){
|
for (BatttestdataInf tinf:list) {
|
//剩余容量和剩余时间计算
|
int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(), tinf.getTestCurr());
|
Float restCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Rest);
|
Float realCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Real);
|
tinf.setRestCap(restCap);
|
tinf.setRealCap(realCap);
|
tinf.setRestTime(0f);
|
//获取电池组实时数据
|
BattRtstate battRtstate=rtstateService.getBattRealInfo(tinf.getBattgroupId());
|
//获取电池组信息
|
BattInf binf=battInfService.getBinfByBattgroupId(tinf.getBattgroupId());
|
//实时组端电流，剩余容量，标称容量
|
if(battRtstate!=null){
|
Float restTime= BattCapFactory.getTheoryTime(battRtstate.getGroupCurr(), restCap, binf.getMoncapstd());
|
tinf.setRestTime(restTime);
|
}
|
//保留5位小数
|
String precentCap = String.format("%.5f",(restCap/binf.getMoncapstd()*100));
|
tinf.setPrecentCap(precentCap);
|
}
|
}
|
|
PageInfo pageInfo=new PageInfo(list);
|
return new Response().setII(1,list.size()>0,pageInfo,"蓄电池核容信息统计");
|
}
|
//获取上一次标准核容信息(标准核容的界定为单测核容时间达 2小时及以上的核容测试)
|
public BatttestdataInf getLastStandardTestData(Integer battgroupId) {
|
QueryWrapper wrapper = new QueryWrapper();
|
wrapper.eq("battgroup_id", battgroupId);
|
wrapper.eq("test_type", 3);
|
wrapper.eq("test_starttype", 3);
|
wrapper.last(" and test_timelong >= 7200 ORDER BY test_starttime DESC ");
|
wrapper.last("limit 1");
|
BatttestdataInf tinf = mapper.selectOne(wrapper);
|
return tinf;
|
}
|
|
//获取电池组在给定时间段的放电记录(指定时间段的标准核容放电)
|
private BatttestdataInf getLastStandardTestDataByTime(Integer battgroupId, Date testStartTime, Date testEndTime) {
|
QueryWrapper wrapper = new QueryWrapper();
|
wrapper.eq("battgroup_id", battgroupId);
|
wrapper.eq("test_type", 3);
|
wrapper.eq("test_starttype", 3);
|
wrapper.gt("test_starttime",testStartTime);
|
wrapper.lt("test_starttime",testEndTime);
|
wrapper.last(" and test_timelong >= 7200 ORDER BY test_starttime DESC ");
|
wrapper.last("limit 1");
|
BatttestdataInf tinf = mapper.selectOne(wrapper);
|
return tinf;
|
}
|
/*单节数量统计
|
1筛选满足条件的电池组，找最近一次标准核容放电记录的最后一笔数据
|
2再按照公式计算单体实际容量，
|
3然后找到判断优秀，劣化，损坏的参数，得到结果。
|
4浮充电压图，需要显示单体+实时数据的单体电压，单体内阻
|
*/
|
public Response getMonStatistic(MonStic stic) {
|
Map<String,Object> map=new HashMap<>();
|
List<SticMonRes> goodlist=new ArrayList();
|
List<SticMonRes> badlist=new ArrayList();
|
List<SticMonRes> damagelist=new ArrayList();
|
map.put("goodlist",goodlist);
|
map.put("badlist",badlist);
|
map.put("damagelist",damagelist);
|
map.put("goodlistNum",0);
|
map.put("badlistNum",0);
|
map.put("damagelistNum",0);
|
//获取核容优劣，损坏参数
|
List<AppParam> paramList=appParamService.getHrParam();
|
Float badValue=0f;
|
Float damageValue=0f;
|
if(paramList!=null){
|
for (AppParam param:paramList) {
|
if(param.getParamNamePsx().equals("batt_mon_deteriorate_val")){
|
badValue=param.getParamValue();
|
}
|
if(param.getParamNamePsx().equals("batt_mon_damage_val")){
|
damageValue=param.getParamValue();
|
}
|
|
}
|
}
|
List<BattInf> binfList=battInfService.getMonStatistic(stic);
|
Float realCap=0f;
|
if(binfList==null){
|
return new Response().set(1,false,"当前用户未管理满足条件的电池组");
|
}
|
for (BattInf binf:binfList) {
|
BatttestdataInf tinf =getLastStandardTestData(binf.getBattgroupId());
|
if(tinf==null){
|
//将不满足条件的电池组的所有单体放入damage中
|
setDamage(damagelist,binf);
|
continue;
|
}
|
//找这次放电的最后一笔数据
|
List<BatttestdataId> idDataList=battTestdataIdService.getLastDataByBattgroupId(tinf.getBattgroupId(),tinf.getTestRecordCount(),tinf.getRecordNum());
|
if(idDataList==null||idDataList.size()==0){
|
//将不满足条件的电池组的所有单体放入damage中
|
setDamage(damagelist,binf);
|
continue;
|
}
|
int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(), tinf.getTestCurr());
|
Float moncapStd=binf.getMoncapstd();
|
for (BatttestdataId data:idDataList) {//求单体的 实际容量，最小值就是单体的单体电压
|
realCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(),data.getMonVol() , tinf.getGroupVol(), BattCapFactory.CapType_Real);
|
SticMonRes res=new SticMonRes();
|
res.setBattgroupId(binf.getBattgroupId());
|
res.setBattgroupName(binf.getBattgroupName());
|
res.setMonNum(data.getMonNum());
|
//获取单体的实时数据
|
BattRtdata rtdata=rtdataService.getRtdataByNum(binf.getBattgroupId(),data.getMonNum());
|
if(rtdata==null){
|
res.setMonVol(0f);
|
res.setMonRes(0f);
|
}else{
|
res.setMonVol(rtdata.getMonVol());
|
res.setMonRes(rtdata.getMonRes());
|
}
|
if(realCap>=moncapStd*badValue){
|
goodlist.add(res);
|
}
|
if(realCap<=moncapStd*damageValue){
|
damagelist.add(res);
|
}
|
if((realCap>moncapStd*damageValue)&&(realCap<moncapStd*badValue)){
|
badlist.add(res);
|
}
|
}
|
}
|
map.put("goodlist",goodlist);
|
map.put("badlist",badlist);
|
map.put("damagelist",damagelist);
|
map.put("goodlistNum",goodlist.size());
|
map.put("badlistNum",badlist.size());
|
map.put("damagelistNum",damagelist.size());
|
return new Response().setII(1,true,map,"单节数量统计");
|
}
|
//将不满足条件的电池组的所有单体放入damage中
|
private void setDamage(List damagelist, BattInf binf) {
|
//获取电池组的实时数据
|
List<BattRtdata> rtdataList=rtdataService.getRtdataRealInfo(binf.getBattgroupId());
|
if(rtdataList==null||rtdataList.size()==0){
|
for (int i=0;i<binf.getMoncount();i++){
|
SticMonRes res=new SticMonRes();
|
res.setBattgroupId(binf.getBattgroupId());
|
res.setBattgroupName(binf.getBattgroupName());
|
res.setMonNum(i+1);
|
res.setMonVol(0f);
|
res.setMonRes(0f);
|
damagelist.add(res);
|
}
|
}else {
|
for (BattRtdata rtdata:rtdataList) {
|
SticMonRes res=new SticMonRes();
|
res.setBattgroupId(binf.getBattgroupId());
|
res.setBattgroupName(binf.getBattgroupName());
|
res.setMonNum(rtdata.getMonNum());
|
res.setMonVol(rtdata.getMonVol());
|
res.setMonRes(rtdata.getMonRes());
|
damagelist.add(res);
|
}
|
}
|
}
|
/*蓄电池组对比分析界面（同一品牌同一时间）
|
*1.查询出符合条件的电池组信息
|
* 2.计算电池组的预估剩余容量
|
*3.判断性能和百分比
|
* 4.分页
|
*/
|
public Response getBattCompare15Statistic(BattCompareStic stic) {
|
//获取核容优劣，损坏参数
|
List<AppParam> paramList=appParamService.getHrParam();
|
Float badValue=0f;
|
Float damageValue=0f;
|
if(paramList!=null){
|
for (AppParam param:paramList) {
|
if(param.getParamNamePsx().equals("batt_mon_deteriorate_val")){
|
badValue=param.getParamValue();
|
}
|
if(param.getParamNamePsx().equals("batt_mon_damage_val")){
|
damageValue=param.getParamValue();
|
}
|
|
}
|
}
|
//1查询符合条件的电池组
|
List<BattInf> binfList=battInfService.getBattCompare15Statistic(stic);
|
if(binfList==null||binfList.size()==0){
|
return new Response().set(1,false,"当前用户未管理满足条件的电池组");
|
}
|
List<SticCompare15Res> reslist=new ArrayList<>();
|
for (BattInf binf:binfList) {
|
SticCompare15Res res=new SticCompare15Res();
|
res.setProvice(binf.getProvice());
|
res.setCity(binf.getCity());
|
res.setCountry(binf.getCountry());
|
res.setStationName(binf.getStationName());
|
res.setBattgroupName(binf.getBattgroupName());
|
res.setDevName(binf.getDevName());
|
res.setProduct(binf.getProduct());
|
res.setInuseTime(binf.getInuseTime());
|
res.setMonvolstd(binf.getMonvolstd());
|
//2.获取电池组在给定时间段的放电记录(指定时间段的标准核容放电)
|
BatttestdataInf tinf =getLastStandardTestDataByTime(binf.getBattgroupId(),stic.getTestStartTime(),stic.getTestEndTime());
|
if(tinf==null){
|
res.setRealCap(0f);
|
res.setPrecentCap("0");
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_3.getStateId()));
|
continue;
|
}
|
//找这次放电的最后一笔数据
|
List<BatttestdataId> idDataList=battTestdataIdService.getLastDataByBattgroupId(tinf.getBattgroupId(),tinf.getTestRecordCount(),tinf.getRecordNum());
|
if(idDataList==null||idDataList.size()==0){
|
res.setRealCap(0f);
|
res.setPrecentCap("0");
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_3.getStateId()));
|
continue;
|
}
|
Float moncapStd=binf.getMoncapstd();
|
int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(), tinf.getTestCurr());
|
Float grouprealCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Real);
|
//Float restCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Rest);
|
res.setRealCap(grouprealCap);
|
if(grouprealCap>=moncapStd*badValue){
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_1.getStateId()));
|
}
|
if(grouprealCap<=moncapStd*damageValue){
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_3.getStateId()));
|
}
|
if((grouprealCap>moncapStd*damageValue)&&(grouprealCap<moncapStd*badValue)){
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_2.getStateId()));
|
}
|
//保留5位小数
|
String precentCap = String.format("%.5f",(grouprealCap/binf.getMoncapstd()*100));
|
res.setPrecentCap(precentCap);
|
List<Integer> monNums=new ArrayList<>();
|
for (BatttestdataId data:idDataList) {//求单体的 实际容量，最小值就是单体的单体电压
|
Float monrealCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), data.getMonVol(), tinf.getGroupVol(), BattCapFactory.CapType_Real);
|
if (monrealCap <= moncapStd * damageValue) {//损坏的
|
monNums.add(data.getMonNum());
|
}
|
}
|
res.setMonNums(monNums);
|
if(stic.getPerformance()==null){
|
reslist.add(res);
|
}else{
|
if(res.getCapperformance().equals(Capperformance.getValue(stic.getPerformance()))){
|
reslist.add(res);
|
}
|
}
|
|
}
|
PageInfo pageInfo=PageInfoUtils.list2PageInfo(reslist, stic.getPageNum(), stic.getPageSize());
|
return new Response().setII(1,reslist.size()>0,pageInfo,"蓄电池组对比分析界面（同一品牌同一时间）");
|
}
|
|
//蓄电池组对比分析界面（不同品牌同一时间）(1.2.16)
|
public Response getBattCompare16Statistic(BattCompareStic stic) {
|
//获取核容优劣，损坏参数
|
List<AppParam> paramList=appParamService.getHrParam();
|
Float badValue=0f;
|
Float damageValue=0f;
|
if(paramList!=null){
|
for (AppParam param:paramList) {
|
if(param.getParamNamePsx().equals("batt_mon_deteriorate_val")){
|
badValue=param.getParamValue();
|
}
|
if(param.getParamNamePsx().equals("batt_mon_damage_val")){
|
damageValue=param.getParamValue();
|
}
|
|
}
|
}
|
//1查询符合条件的电池组
|
List<BattInf> binfList=battInfService.getBattCompare16Statistic(stic);
|
if(binfList==null||binfList.size()==0){
|
return new Response().set(1,false,"当前用户未管理满足条件的电池组");
|
}
|
List<SticCompare16Res> reslist=new ArrayList<>();
|
for (BattInf binf:binfList) {
|
SticCompare16Res res=new SticCompare16Res();
|
res.setProvice(binf.getProvice());
|
res.setCity(binf.getCity());
|
res.setCountry(binf.getCountry());
|
res.setStationName(binf.getStationName());
|
res.setBattgroupName(binf.getBattgroupName());
|
res.setDevName(binf.getDevName());
|
res.setProduct(binf.getProduct());
|
res.setInuseTime(binf.getInuseTime());
|
res.setMonvolstd(binf.getMonvolstd());
|
res.setMoncapstd(binf.getMoncapstd());
|
//2.获取电池组在给定时间段的放电记录(指定时间段的标准核容放电)
|
BatttestdataInf tinf =getLastStandardTestDataByTime(binf.getBattgroupId(),stic.getTestStartTime(),stic.getTestEndTime());
|
if(tinf==null){
|
res.setRealCap(0f);
|
res.setPrecentCap("0");
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_3.getStateId()));
|
res.setStopReason("--");
|
continue;
|
}
|
res.setStopReason(StopReasonEnum.getValue(tinf.getTestStoptype()));
|
Float moncapStd=binf.getMoncapstd();
|
int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(), tinf.getTestCurr());
|
Float grouprealCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Real);
|
//Float restCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), tinf.getMinMonvol(), tinf.getGroupVol(), BattCapFactory.CapType_Rest);
|
res.setRealCap(grouprealCap);
|
if(grouprealCap>=moncapStd*badValue){
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_1.getStateId()));
|
}
|
if(grouprealCap<=moncapStd*damageValue){
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_3.getStateId()));
|
}
|
if((grouprealCap>moncapStd*damageValue)&&(grouprealCap<moncapStd*badValue)){
|
res.setCapperformance(Capperformance.getValue(Capperformance.BATTSTATE_2.getStateId()));
|
}
|
//保留5位小数
|
String precentCap = String.format("%.5f",(grouprealCap/binf.getMoncapstd()*100));
|
//评分的逻辑
|
res.setScore(0f);
|
res.setPrecentCap(precentCap);
|
if(stic.getPerformance()==null){
|
reslist.add(res);
|
}else{
|
if(res.getCapperformance().equals(Capperformance.getValue(stic.getPerformance()))){
|
reslist.add(res);
|
}
|
}
|
|
}
|
PageInfo pageInfo=PageInfoUtils.list2PageInfo(reslist, stic.getPageNum(), stic.getPageSize());
|
return new Response().setII(1,reslist.size()>0,pageInfo,"蓄电池组对比分析界面（不同品牌同一时间）");
|
}
|
//蓄电池组对比分析界面（同一品牌不同时间）(1.2.17)
|
public Response getBattCompare17Statistic(BattCompareStic stic) {
|
//获取核容优劣，损坏参数
|
List<AppParam> paramList=appParamService.getHrParam();
|
Float badValue=0f;
|
Float damageValue=0f;
|
if(paramList!=null){
|
for (AppParam param:paramList) {
|
if(param.getParamNamePsx().equals("batt_mon_deteriorate_val")){
|
badValue=param.getParamValue();
|
}
|
if(param.getParamNamePsx().equals("batt_mon_damage_val")){
|
damageValue=param.getParamValue();
|
}
|
|
}
|
}
|
//1查询符合条件的电池组
|
List<BattInf> binfList=battInfService.getBattCompare15Statistic(stic);
|
if(binfList==null||binfList.size()==0){
|
return new Response().set(1,false,"当前用户未管理满足条件的电池组");
|
}
|
List<SticCompare17Res> reslist=new ArrayList<>();
|
for (BattInf binf:binfList) {
|
|
//2.获取电池组在给定时间段的放电记录(指定时间段的标准核容放电)
|
BatttestdataInf tinf =getLastStandardTestDataByTime(binf.getBattgroupId(),stic.getTestStartTime(),stic.getTestEndTime());
|
if(tinf==null){
|
//不存在放电记录则默认为实际预估容量全为0
|
setSticCompare17Res(binf,reslist,stic.getPerformance());
|
continue;
|
}
|
//找这次放电的最后一笔数据
|
List<BatttestdataId> idDataList=battTestdataIdService.getLastDataByBattgroupId(tinf.getBattgroupId(),tinf.getTestRecordCount(),tinf.getRecordNum());
|
if(idDataList==null||idDataList.size()==0){
|
//不存在放电记录则默认为实际预估容量全为0
|
setSticCompare17Res(binf,reslist,stic.getPerformance());
|
continue;
|
}
|
Float moncapStd=binf.getMoncapstd();
|
int hourRate = BattCapFactory.GetHourRate(tinf.getTestCap(), tinf.getTestCurr());
|
for (BatttestdataId data:idDataList) {//求单体的 实际容量，最小值就是单体的单体电压
|
SticCompare17Res res=new SticCompare17Res();
|
res.setProvice(binf.getProvice());
|
res.setCity(binf.getCity());
|
res.setCountry(binf.getCountry());
|
res.setStationName(binf.getStationName());
|
res.setDevName(binf.getDevName());
|
res.setBattgroupName(binf.getBattgroupName());
|
res.setProduct(binf.getProduct());
|
res.setInuseTime(binf.getInuseTime());
|
res.setMonvolstd(binf.getMonvolstd());
|
res.setMonNum(data.getMonNum());
|
Float monrealCap = (float) BattCapFactory.GetMonomerCap(tinf.getTestCap(), hourRate, tinf.getTestCap(), tinf.getMaxMonvol(), data.getMonVol(), tinf.getGroupVol(), BattCapFactory.CapType_Real);
|
res.setMonrealCap(monrealCap);
|
//保留5位小数
|
String monprecentCap = String.format("%.5f",(monrealCap/binf.getMoncapstd()*100));
|
res.setMonprecentCap(monprecentCap);
|
if(monrealCap>=moncapStd*badValue){
|
res.setMoncapperformance(Capperformance.getValue(Capperformance.BATTSTATE_1.getStateId()));
|
}
|
if (monrealCap <= moncapStd * damageValue) {//损坏的
|
res.setMoncapperformance(Capperformance.getValue(Capperformance.BATTSTATE_3.getStateId()));
|
}
|
if((monrealCap>moncapStd*damageValue)&&(monrealCap<moncapStd*badValue)){
|
res.setMoncapperformance(Capperformance.getValue(Capperformance.BATTSTATE_2.getStateId()));
|
}
|
if(stic.getPerformance()==null){
|
reslist.add(res);
|
}else{
|
if(res.getMoncapperformance().equals(Capperformance.getValue(stic.getPerformance()))){
|
reslist.add(res);
|
}
|
}
|
}
|
}
|
PageInfo pageInfo=PageInfoUtils.list2PageInfo(reslist, stic.getPageNum(), stic.getPageSize());
|
return new Response().setII(1,reslist.size()>0,pageInfo,"蓄电池组对比分析界面（同一品牌同一时间）");
|
}
|
//不存在放电记录则默认为实际预估容量全为0
|
private void setSticCompare17Res( BattInf binf, List<SticCompare17Res> reslist,Integer performance) {
|
for (int i=0;i<binf.getMoncount();i++){
|
SticCompare17Res res=new SticCompare17Res();
|
res.setProvice(binf.getProvice());
|
res.setCity(binf.getCity());
|
res.setCountry(binf.getCountry());
|
res.setStationName(binf.getStationName());
|
res.setDevName(binf.getDevName());
|
res.setBattgroupName(binf.getBattgroupName());
|
res.setProduct(binf.getProduct());
|
res.setInuseTime(binf.getInuseTime());
|
res.setMonvolstd(binf.getMonvolstd());
|
res.setMonNum(i+1);
|
res.setMonrealCap(0f);
|
res.setMonprecentCap("0");
|
res.setMoncapperformance(Capperformance.getValue(Capperformance.BATTSTATE_3.getStateId()));
|
if(performance==null){
|
reslist.add(res);
|
}else{
|
if(res.getMoncapperformance().equals(Capperformance.getValue(performance))){
|
reslist.add(res);
|
}
|
}
|
reslist.add(res);
|
}
|
}
|
}
|
