package com.whyc.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.github.pagehelper.PageInfo;
|
import com.whyc.dto.ReportBattDTO;
|
import com.whyc.dto.Response;
|
import com.whyc.mapper.*;
|
import com.whyc.pojo.AlarmParam;
|
import com.whyc.pojo.BattParamLow;
|
import com.whyc.pojo.Battinf;
|
import com.whyc.pojo.BatttestdataInf;
|
import com.whyc.util.PageInfoUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
@Service
|
public class BattMaintDealarmService {
|
@Resource
|
private BattMaintDealarmMapper mapper;
|
@Resource
|
private BattInfMapper battInfMapper;
|
@Resource
|
private BattParamLowMapper battParamLowMapper;
|
@Resource
|
private BattResDataMapper BattResDataMapper;
|
@Resource
|
AlarmParamMapper alarmParamMapper;
|
@Resource
|
BattalarmDataMapper alarmDataMapper;
|
|
|
@Resource
|
private BatttestdataInfService batttestdataInfService;
|
|
@Autowired
|
private SubTablePageInfoService subService;
|
|
public Response searchLow(ReportBattDTO tinf, int userId) {
|
Response res = new Response();
|
List<Battinf> battinfList = battInfMapper.searchByTestType(tinf, userId);
|
List<Map> result = new ArrayList<>();
|
if (battinfList != null && battinfList.size() > 0) {
|
BatttestdataInf btdinf = new BatttestdataInf();
|
btdinf.setRecordTime(tinf.getRecordStartTime());
|
btdinf.setRecordTime1(tinf.getRecordEndTime());
|
btdinf.setTestType(tinf.getTestType());
|
btdinf.setTestStarttype(tinf.getTestStartType());
|
for (Battinf binf : battinfList) {
|
btdinf.setBattGroupId(binf.getBattGroupId());
|
btdinf.setGroupVol(binf.getMonVolStd());
|
btdinf.setTestCap(binf.getMonCapStd());
|
btdinf.setTestRecordCount(binf.getTestRecordCount());
|
Map map = new HashMap();
|
map.put("battinf", binf);
|
//该电池组的放电结果
|
List<BatttestdataInf> batttestdataInfList = batttestdataInfService.searchByTestType(btdinf);
|
map.put("battTestDataInf", batttestdataInfList);
|
result.add(map);
|
}
|
}
|
return res.set(1,result,"查询成功");
|
}
|
|
//1.4电池性能评估
|
public Response searchGroupAssess(int pageNum,int pageSize,ReportBattDTO tinf, int userId){
|
List<Battinf> battinfList = battInfMapper.searchGroupAssess(tinf, userId);
|
List<Map> result = new ArrayList<>();
|
Integer assess = tinf.getAssess();//性能筛选
|
Integer wj = tinf.getWj();//往年还是本年
|
Integer statictype= tinf.getStatictype();//统计方式
|
if (assess == null) {
|
assess = -1;
|
}
|
if (wj == null) {
|
wj = -1;
|
}
|
if (battinfList != null && battinfList.size() > 0) {
|
for (Battinf binf : battinfList) {
|
Integer battGroupId = binf.getBattGroupId();
|
Map<String, Object> map=new HashMap<>();
|
Map<String, Object> batttestdataInfList = batttestdataInfService.searchDischargeTest(battGroupId, binf.getMonCapStd(), binf.getMonVolStd(), tinf.getRecordStartTime(), tinf.getRecordEndTime(),wj);
|
if(statictype==0){
|
//对每个电池组状态进行判断（容量+内阻）
|
map = getAssess2(binf, batttestdataInfList,assess);
|
}else{
|
//对每个电池组状态进行判断（容量）
|
map = getAssess3(binf, batttestdataInfList,assess);
|
}
|
if (assess == -1) {
|
result.add(map);
|
} else {
|
if (map.get("flag") == assess) {
|
result.add(map);
|
}
|
}
|
}
|
}
|
PageInfo pageInfo = PageInfoUtils.list2PageInfo(result, pageNum, pageSize);
|
return new Response().set(1, pageInfo, "查询成功");
|
}
|
|
//查询电池告警（劣化：内阻过高重要，电压过低重要；损坏：内阻过高紧急，电压过低紧急）
|
private List getAlm(Integer battGroupId, Integer assess) {
|
List list = alarmDataMapper.getAlm(battGroupId, assess);
|
return list;
|
}
|
|
//筛选蓄电池组后评性能
|
public Map<String, Object> getAssess(Battinf binf, Map<String, Object> mapList, int assess) {
|
Map<String, Object> map = new HashMap();
|
map.put("battinf", binf);
|
map.put("battTestDataInf", mapList);
|
//直接去集合第2个数（放电次数），第6个数（实际预估容量：最近一次核容的实际容量）
|
int battGroupId = (int) mapList.get("battGroupid");
|
int disNum = (int) mapList.get("sum");
|
float realCap = (Float) mapList.get("lastCap");
|
float monCapStd = binf.getMonCapStd();
|
//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;
|
}
|
//查询电池告警（劣化：内阻过高重要，电压过低重要；损坏：内阻过高紧急，电压过低紧急）
|
List listALmSH = getAlm(battGroupId, 3);
|
List listALmLH = getAlm(battGroupId, 2);
|
//先判断是否损坏
|
if ((disNum != 0 && realCap < capChange * monCapStd)
|
|| (listALmSH != null && listALmSH.size() > 0)) {
|
map.put("flag", 3);
|
if (assess == 0) {
|
if (disNum == 0) {
|
map.put("flag", 0);
|
}
|
} else {
|
map.put("alarm", listALmSH);
|
}
|
}//在判断是否劣化
|
else if (
|
(disNum != 0 && realCap <= capAlarm * monCapStd && realCap >= capChange * monCapStd
|
)
|
|| (listALmLH != null && listALmLH.size() > 0)) {
|
map.put("flag", 2);
|
if (assess == 0) {
|
if (disNum == 0) {
|
map.put("flag", 0);
|
}
|
} else {
|
map.put("alarm", listALmLH);
|
}
|
}//再判断是否放电正常
|
else if (disNum != 0 && realCap > capAlarm * monCapStd) {
|
map.put("flag", 1);
|
if (assess == 0) {
|
if (disNum == 0) {
|
map.put("flag", 0);
|
}
|
}
|
}
|
//在判断是否未放电
|
else if (disNum == 0) {
|
map.put("flag", 0);
|
} else {
|
map.put("flag", 0);
|
}
|
if ((int) map.get("flag") == 0) {
|
if ((listALmSH != null && listALmSH.size() > 0)) {
|
map.put("noDisAlmSH", listALmSH);
|
}
|
if ((listALmLH != null && listALmLH.size() > 0)) {
|
map.put("noDisAlmLH", listALmLH);
|
}
|
}
|
return map;
|
}
|
|
//查询电池告警(2024。4.15修改)
|
/*未放电：本年度未放电
|
*优秀：本年度已放电，且容量健康，无内阻告警（预告警（重要），告警（紧急））
|
*劣化：本年度未放电，内阻告警（预告警（重要），告警（紧急））
|
* 容量小于劣化阈值，大于损坏阈值，内阻告警(预告警，告警)
|
* 容量小于劣化阈值，内阻正常
|
* 容量正常，内阻告警(预告警，告警)
|
* 损坏：容量低，内阻告警
|
* */
|
private List getAlm2(Integer battGroupId) {
|
List list = alarmDataMapper.getAlm2(battGroupId);
|
return list;
|
}
|
|
//筛选蓄电池组后评性能(2024。4.15修改)
|
public Map<String, Object> getAssess2(Battinf binf, Map<String, Object> mapList,int assess) {
|
Map<String, Object> map = new HashMap();
|
map.put("battinf", binf);
|
map.put("battTestDataInf", mapList);
|
map.put("wj",mapList.get("wj"));
|
//直接去集合第2个数（放电次数），第6个数（实际预估容量：最近一次核容的实际容量）
|
int battGroupId = (int) mapList.get("battGroupid");
|
int disNum = (int) mapList.get("sum");
|
float realCap = (Float) mapList.get("lastCap");
|
float monCapStd = binf.getMonCapStd();
|
//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;
|
}
|
//查询电池告警（内阻告警）
|
List listALmRes = getAlm2(battGroupId);
|
map.put("noDisAlmSH",listALmRes);
|
//未放电：本年度未放电
|
if( (disNum==0) ){
|
map.put("flag",0);
|
}
|
//优秀：本年度已放电，且容量健康，无内阻告警（预告警（重要），告警（紧急））
|
if( (disNum>0)&&(realCap > capAlarm * monCapStd)&&(listALmRes.size()<=0)){
|
map.put("flag",1);
|
}
|
|
/*劣化：本年度未放电，内阻告警（预告警（重要），告警（紧急））
|
*容量小于劣化阈值，大于损坏阈值，内阻告警(预告警，告警)
|
* 容量小于劣化阈值，内阻正常
|
* 容量正常，内阻告警(预告警，告警)
|
*/
|
if (((disNum==0)&&(listALmRes.size()>0))
|
||((disNum>0)&&(realCap <= capAlarm * monCapStd && realCap >= capChange * monCapStd)&&(listALmRes.size()>0))
|
||((disNum>0)&&(realCap <= capAlarm * monCapStd)&&(listALmRes.size()<=0))
|
||(disNum>0)&&(realCap > capAlarm * monCapStd)&&(listALmRes.size()>0)){
|
if((assess==0)&&(disNum==0)){
|
map.put("flag",0);
|
}else{
|
map.put("flag",2);
|
}
|
}
|
//损坏：容量低，内阻告警
|
if((disNum!=0)&&(realCap< capChange * monCapStd)&&(listALmRes.size()>0)){
|
map.put("flag",3);
|
}
|
return map;
|
}
|
//筛选蓄电池组后评性能(2024。4.15修改)
|
public Map<String, Object> getAssess3(Battinf binf, Map<String, Object> mapList,int assess) {
|
Map<String, Object> map = new HashMap();
|
map.put("battinf", binf);
|
map.put("battTestDataInf", mapList);
|
map.put("wj", mapList.get("wj"));
|
//直接去集合第2个数（放电次数），第6个数（实际预估容量：最近一次核容的实际容量）
|
int battGroupId = (int) mapList.get("battGroupid");
|
int disNum = (int) mapList.get("sum");
|
float realCap = (Float) mapList.get("lastCap");
|
float monCapStd = binf.getMonCapStd();
|
//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;
|
}
|
//未放电：本年度未放电
|
if ((disNum == 0)) {
|
map.put("flag", 0);
|
}
|
//优秀：本年度已放电，且容量健康）
|
if ((disNum > 0) && (realCap > capAlarm * monCapStd)) {
|
map.put("flag", 1);
|
}
|
/*劣化：
|
*容量小于劣化阈值，大于损坏阈值
|
*/
|
if (((disNum > 0) && (realCap <= capAlarm * monCapStd && realCap >= capChange * monCapStd))) {
|
map.put("flag", 2);
|
}
|
//损坏：容量低
|
if ((disNum > 0) && (realCap < capChange * monCapStd)) {
|
map.put("flag", 3);
|
}
|
return map;
|
}
|
|
|
public Response searchMonNum(ReportBattDTO dto) {
|
List list = new ArrayList();
|
if (dto.getTestType() == 3) {
|
//list = mapper.searchByBattGroupId(dto);
|
list = subService.searchByBattGroupId(dto);
|
}
|
if (dto.getTestType() == 5) {
|
//list = mapper.searchByBattGroupId5(dto);
|
list = subService.searchByBattGroupId5(dto);
|
}
|
//添加内阻测试设置为标准值的那一笔，如果没有则拿最新的一笔
|
List listRes = new ArrayList();
|
//listRes = BattResDataMapper.serchisStandard(dto.getBattGroupId().intValue());
|
listRes = subService.serchisStandard(dto.getBattGroupId().intValue());
|
if (listRes == null || listRes.size() <= 0) {
|
//listRes = BattResDataMapper.serchCurrent(dto.getBattGroupId().intValue());
|
listRes = subService.serchCurrent(dto.getBattGroupId().intValue());
|
}
|
BattParamLow lowCA = new BattParamLow();
|
lowCA.setLowType(2);
|
lowCA.setLowNametype(2);//电容告警
|
BattParamLow lowCH = new BattParamLow();
|
lowCH.setLowType(2);
|
lowCH.setLowNametype(3);//电容更换
|
List<BattParamLow> listCA = battParamLowMapper.serchByLow(lowCA);
|
List<BattParamLow> listCH = battParamLowMapper.serchByLow(lowCH);
|
Float percentCA = listCA.get(0).getLowValue();
|
Float percentCH = listCH.get(0).getLowValue();
|
//电导基准/维护建议/电导分析值
|
BattParamLow lowRA=new BattParamLow();
|
lowRA.setLowType(3);
|
lowRA.setLowNametype(2);//电导告警
|
BattParamLow lowRH=new BattParamLow();
|
lowRH.setLowType(3);
|
lowRH.setLowNametype(3);//电导更换
|
|
//电导
|
List<BattParamLow> listRA = battParamLowMapper.serchByLow(lowRA);
|
List<BattParamLow> listRH = battParamLowMapper.serchByLow(lowRH);
|
Float percentRA = listRA.get(0).getLowValue();
|
Float percentRH = listRH.get(0).getLowValue();
|
int methodRM = listRA.get(0).getLowMethod(); //分析方式
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("Data", list);
|
map.put("Data2", listRes);
|
map.put("LowCA", percentCA);
|
map.put("LowCH", percentCH);
|
map.put("LowRA", percentRA);
|
map.put("LowRH", percentRH);
|
map.put("newSum", methodRM);
|
|
return new Response().set(1, map, "查询成功");
|
}
|
|
|
}
|
