package com.whyc.service;
|
|
import com.whyc.constant.AlarmConstant;
|
import com.whyc.dto.Response;
|
import com.whyc.mapper.PowerAlarmMapper;
|
import com.whyc.mapper.PowerInfoMapper;
|
import com.whyc.pojo.PowerAlarm;
|
import com.whyc.util.MathUtil;
|
import org.springframework.stereotype.Service;
|
import org.springframework.web.bind.annotation.RequestParam;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
|
@Service
|
public class PowerAlarmService {
|
|
@Resource
|
private PowerAlarmMapper mapper;
|
|
@Resource
|
private PowerInfoMapper infoMapper;
|
|
public Response<Map> getACInputAnalysis(@RequestParam int userId){
|
//交流输入-跳闸,
|
//交流输入-熔丝告警,
|
//交流输入-三相不平衡,
|
//交流输入-频率异常
|
Map<String,Integer> resultMap = new HashMap<>();
|
resultMap.put("跳闸",0);
|
resultMap.put("熔丝告警",0);
|
resultMap.put("三相不平衡",0);
|
resultMap.put("频率异常",0);
|
|
ArrayList<Integer> types = new ArrayList<>();
|
types.add(AlarmConstant.acIn1_trip);
|
types.add(AlarmConstant.acIn2_trip);
|
types.add(AlarmConstant.acIn1_fuse);
|
types.add(AlarmConstant.acIn2_fuse);
|
types.add(AlarmConstant.acIn1_unbanlance);
|
types.add(AlarmConstant.acIn2_unbanlance);
|
types.add(AlarmConstant.acIn1_freqerr);
|
types.add(AlarmConstant.acIn2_freqerr);
|
|
List<PowerAlarm> data = mapper.getAnalysis(userId,types);
|
|
for (int i = 0; i < data.size(); i++) {
|
switch (data.get(i).getAlarmType()){
|
case AlarmConstant.acIn1_trip:
|
case AlarmConstant.acIn2_trip:
|
resultMap.put("跳闸",resultMap.get("跳闸")+(data.get(i).getNum()).intValue());
|
break;
|
case AlarmConstant.acIn1_fuse:
|
case AlarmConstant.acIn2_fuse:
|
resultMap.put("熔丝告警",resultMap.get("熔丝告警")+(data.get(i).getNum()).intValue());
|
break;
|
case AlarmConstant.acIn1_unbanlance:
|
case AlarmConstant.acIn2_unbanlance:
|
resultMap.put("三相不平衡",resultMap.get("三相不平衡")+(data.get(i).getNum()).intValue());
|
break;
|
case AlarmConstant.acIn1_freqerr:
|
case AlarmConstant.acIn2_freqerr:
|
resultMap.put("频率异常",resultMap.get("频率异常")+(data.get(i).getNum()).intValue());
|
break;
|
default:
|
throw new IllegalStateException("Unexpected value: " + data.get(i));
|
}
|
|
}
|
|
return new Response<Map>().set(1,resultMap);
|
}
|
|
public Response<Map> getErrorAnalysis(int userId){
|
//故障-交流电故障,
|
//故障-直流电故障,
|
//故障-防雷器故障,
|
//故障-监控器故障,
|
//故障-通讯故障,
|
//故障-开关柜总报警
|
Map<String,Integer> resultMap = new HashMap<>();
|
resultMap.put("交流电故障",0);
|
resultMap.put("直流电故障",0);
|
resultMap.put("防雷器故障",0);
|
resultMap.put("监控器故障",0);
|
resultMap.put("通讯故障",0);
|
resultMap.put("开关柜总报警",0);
|
|
ArrayList<Integer> types = new ArrayList<>();
|
types.add(AlarmConstant.acIn_total_alarm);
|
types.add(AlarmConstant.dcOut_total_alarm);
|
types.add(AlarmConstant.acIn1_thunder_err);
|
types.add(AlarmConstant.acIn_monitorerr);
|
types.add(AlarmConstant.comm_err);
|
types.add(AlarmConstant.total_alarm);
|
|
List<PowerAlarm> data = mapper.getAnalysis(userId,types);
|
|
for (int i = 0; i < data.size(); i++) {
|
switch (data.get(i).getAlarmType()){
|
case AlarmConstant.acIn_total_alarm:
|
resultMap.put("交流总故障",data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.dcOut_total_alarm:
|
resultMap.put("直流总故障",data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acIn1_thunder_err:
|
resultMap.put("防雷器故障",data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acIn_monitorerr:
|
resultMap.put("监控器故障",data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.comm_err:
|
resultMap.put("通讯故障",data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.total_alarm:
|
resultMap.put("开关柜总报警",data.get(i).getNum().intValue());
|
break;
|
default:
|
throw new IllegalStateException("Unexpected value: " + data.get(i));
|
}
|
|
}
|
|
return new Response<Map>().set(1,resultMap);
|
}
|
|
/**
|
* +告警机房数和占比
|
* @return
|
* @param userId
|
*/
|
public Response<List> getAcABCAnalysis(int userId){
|
|
//交流A/B/C-过压,
|
//交流A/B/C-欠压,
|
//交流A/B/C-缺相,
|
//交流A/B/C-过流
|
Map<String,Integer> resultMap = new HashMap<>();
|
resultMap.put("过压",0);
|
resultMap.put("欠压",0);
|
resultMap.put("缺相",0);
|
resultMap.put("过流",0);
|
|
List<Integer> types = Arrays.asList(
|
AlarmConstant.acIn1_over_volA,
|
AlarmConstant.acIn1_over_volB,
|
AlarmConstant.acIn1_over_volC,
|
AlarmConstant.acIn1_under_volA,
|
AlarmConstant.acIn1_under_volB,
|
AlarmConstant.acIn1_under_volC,
|
AlarmConstant.acIn1_less_A,
|
AlarmConstant.acIn1_less_B,
|
AlarmConstant.acIn1_less_C,
|
AlarmConstant.acb1_over_currA,
|
AlarmConstant.acb1_over_currB,
|
AlarmConstant.acb1_over_currC);
|
|
List<PowerAlarm> data = mapper.getAnalysis(userId,types);
|
|
for (int i = 0; i < data.size(); i++) {
|
switch (data.get(i).getAlarmType()){
|
case AlarmConstant.acIn1_over_volA:
|
case AlarmConstant.acIn1_over_volB:
|
case AlarmConstant.acIn1_over_volC:
|
resultMap.put("过压",resultMap.get("过压")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acIn1_under_volA:
|
case AlarmConstant.acIn1_under_volB:
|
case AlarmConstant.acIn1_under_volC:
|
resultMap.put("欠压",resultMap.get("欠压")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acIn1_less_A:
|
case AlarmConstant.acIn1_less_B:
|
case AlarmConstant.acIn1_less_C:
|
resultMap.put("缺相",resultMap.get("缺相")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acb1_over_currA:
|
case AlarmConstant.acb1_over_currB:
|
case AlarmConstant.acb1_over_currC:
|
resultMap.put("过流",resultMap.get("过流")+data.get(i).getNum().intValue());
|
break;
|
default:
|
throw new IllegalStateException("Unexpected value: " + data.get(i));
|
}
|
|
}
|
|
//告警机房总数和比例
|
HashMap<String, Integer> map2 = new HashMap<>();
|
|
//int alarmStationCount = mapper.getAlarmStationCountSpec(userId,types);
|
//int stationCount = infoMapper.getStationCount(userId);
|
|
//map2.put("告警机房总数",alarmStationCount);
|
//map2.put("告警机房数比例",(int)MathUtil.divide(alarmStationCount,stationCount,2));
|
|
List<Map<String, Integer>> mapList = Arrays.asList(resultMap, map2);
|
return new Response<List>().set(1,mapList);
|
}
|
|
public Response<Map> getRectifierAnalysis(int userId){
|
|
//整流器-总故障,
|
//整流器-欠压,
|
//整流器-过流,
|
//整流器-交流异常,
|
//整流器-过压
|
Map<String,Integer> resultMap = new HashMap<>();
|
resultMap.put("整流器总故障",0);
|
resultMap.put("整流器欠压",0);
|
resultMap.put("整流器过流",0);
|
resultMap.put("整流器交流异常",0);
|
resultMap.put("整流器过压",0);
|
|
List<Integer> types = Arrays.asList(
|
AlarmConstant.acdcMod1_err,
|
AlarmConstant.acdcMod2_err,
|
AlarmConstant.acdcMod3_err,
|
AlarmConstant.acdcMod4_err,
|
AlarmConstant.acdcMod5_err,
|
AlarmConstant.acdcMod6_err,
|
AlarmConstant.acdcMod7_err,
|
AlarmConstant.acdcMod8_err,
|
AlarmConstant.acdcMod9_err,
|
AlarmConstant.acdcMod10_err,
|
AlarmConstant.acdcMod11_err,
|
AlarmConstant.acdcMod12_err,
|
AlarmConstant.acdcMod13_err,
|
AlarmConstant.acdcMod14_err,
|
AlarmConstant.acdcMod15_err,
|
AlarmConstant.acdcMod16_err,
|
AlarmConstant.acdcMod1_underVol,
|
AlarmConstant.acdcMod2_underVol,
|
AlarmConstant.acdcMod3_underVol,
|
AlarmConstant.acdcMod4_underVol,
|
AlarmConstant.acdcMod5_underVol,
|
AlarmConstant.acdcMod6_underVol,
|
AlarmConstant.acdcMod7_underVol,
|
AlarmConstant.acdcMod8_underVol,
|
AlarmConstant.acdcMod9_underVol,
|
AlarmConstant.acdcMod10_underVol,
|
AlarmConstant.acdcMod11_underVol,
|
AlarmConstant.acdcMod12_underVol,
|
AlarmConstant.acdcMod13_underVol,
|
AlarmConstant.acdcMod14_underVol,
|
AlarmConstant.acdcMod15_underVol,
|
AlarmConstant.acdcMod16_underVol,
|
AlarmConstant.acdcMod1_overCurr,
|
AlarmConstant.acdcMod2_overCurr,
|
AlarmConstant.acdcMod3_overCurr,
|
AlarmConstant.acdcMod4_overCurr,
|
AlarmConstant.acdcMod5_overCurr,
|
AlarmConstant.acdcMod6_overCurr,
|
AlarmConstant.acdcMod7_overCurr,
|
AlarmConstant.acdcMod8_overCurr,
|
AlarmConstant.acdcMod9_overCurr,
|
AlarmConstant.acdcMod10_overCurr,
|
AlarmConstant.acdcMod11_overCurr,
|
AlarmConstant.acdcMod12_overCurr,
|
AlarmConstant.acdcMod13_overCurr,
|
AlarmConstant.acdcMod14_overCurr,
|
AlarmConstant.acdcMod15_overCurr,
|
AlarmConstant.acdcMod16_overCurr,
|
AlarmConstant.acdcMod1_acErr,
|
AlarmConstant.acdcMod2_acErr,
|
AlarmConstant.acdcMod3_acErr,
|
AlarmConstant.acdcMod4_acErr,
|
AlarmConstant.acdcMod5_acErr,
|
AlarmConstant.acdcMod6_acErr,
|
AlarmConstant.acdcMod7_acErr,
|
AlarmConstant.acdcMod8_acErr,
|
AlarmConstant.acdcMod9_acErr,
|
AlarmConstant.acdcMod10_acErr,
|
AlarmConstant.acdcMod11_acErr,
|
AlarmConstant.acdcMod12_acErr,
|
AlarmConstant.acdcMod13_acErr,
|
AlarmConstant.acdcMod14_acErr,
|
AlarmConstant.acdcMod15_acErr,
|
AlarmConstant.acdcMod16_acErr,
|
AlarmConstant.acdcMod1_overVol,
|
AlarmConstant.acdcMod2_overVol,
|
AlarmConstant.acdcMod3_overVol,
|
AlarmConstant.acdcMod4_overVol,
|
AlarmConstant.acdcMod5_overVol,
|
AlarmConstant.acdcMod6_overVol,
|
AlarmConstant.acdcMod7_overVol,
|
AlarmConstant.acdcMod8_overVol,
|
AlarmConstant.acdcMod9_overVol,
|
AlarmConstant.acdcMod10_overVol,
|
AlarmConstant.acdcMod11_overVol,
|
AlarmConstant.acdcMod12_overVol,
|
AlarmConstant.acdcMod13_overVol,
|
AlarmConstant.acdcMod14_overVol,
|
AlarmConstant.acdcMod15_overVol,
|
AlarmConstant.acdcMod16_overVol
|
);
|
|
List<PowerAlarm> data = mapper.getAnalysis(userId,types);
|
|
for (int i = 0; i < data.size(); i++) {
|
switch (data.get(i).getAlarmType()){
|
case AlarmConstant.acdcMod1_err:
|
case AlarmConstant.acdcMod2_err:
|
case AlarmConstant.acdcMod3_err:
|
case AlarmConstant.acdcMod4_err:
|
case AlarmConstant.acdcMod5_err:
|
case AlarmConstant.acdcMod6_err:
|
case AlarmConstant.acdcMod7_err:
|
case AlarmConstant.acdcMod8_err:
|
case AlarmConstant.acdcMod9_err:
|
case AlarmConstant.acdcMod10_err:
|
case AlarmConstant.acdcMod11_err:
|
case AlarmConstant.acdcMod12_err:
|
case AlarmConstant.acdcMod13_err:
|
case AlarmConstant.acdcMod14_err:
|
case AlarmConstant.acdcMod15_err:
|
case AlarmConstant.acdcMod16_err:
|
resultMap.put("整流器总故障",resultMap.get("整流器总故障")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acdcMod1_underVol:
|
case AlarmConstant.acdcMod2_underVol:
|
case AlarmConstant.acdcMod3_underVol:
|
case AlarmConstant.acdcMod4_underVol:
|
case AlarmConstant.acdcMod5_underVol:
|
case AlarmConstant.acdcMod6_underVol:
|
case AlarmConstant.acdcMod7_underVol:
|
case AlarmConstant.acdcMod8_underVol:
|
case AlarmConstant.acdcMod9_underVol:
|
case AlarmConstant.acdcMod10_underVol:
|
case AlarmConstant.acdcMod11_underVol:
|
case AlarmConstant.acdcMod12_underVol:
|
case AlarmConstant.acdcMod13_underVol:
|
case AlarmConstant.acdcMod14_underVol:
|
case AlarmConstant.acdcMod15_underVol:
|
case AlarmConstant.acdcMod16_underVol:
|
resultMap.put("整流器欠压",resultMap.get("整流器欠压")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acdcMod1_overCurr:
|
case AlarmConstant.acdcMod2_overCurr:
|
case AlarmConstant.acdcMod3_overCurr:
|
case AlarmConstant.acdcMod4_overCurr:
|
case AlarmConstant.acdcMod5_overCurr:
|
case AlarmConstant.acdcMod6_overCurr:
|
case AlarmConstant.acdcMod7_overCurr:
|
case AlarmConstant.acdcMod8_overCurr:
|
case AlarmConstant.acdcMod9_overCurr:
|
case AlarmConstant.acdcMod10_overCurr:
|
case AlarmConstant.acdcMod11_overCurr:
|
case AlarmConstant.acdcMod12_overCurr:
|
case AlarmConstant.acdcMod13_overCurr:
|
case AlarmConstant.acdcMod14_overCurr:
|
case AlarmConstant.acdcMod15_overCurr:
|
case AlarmConstant.acdcMod16_overCurr:
|
resultMap.put("整流器过流",resultMap.get("整流器过流")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acdcMod1_acErr:
|
case AlarmConstant.acdcMod2_acErr:
|
case AlarmConstant.acdcMod3_acErr:
|
case AlarmConstant.acdcMod4_acErr:
|
case AlarmConstant.acdcMod5_acErr:
|
case AlarmConstant.acdcMod6_acErr:
|
case AlarmConstant.acdcMod7_acErr:
|
case AlarmConstant.acdcMod8_acErr:
|
case AlarmConstant.acdcMod9_acErr:
|
case AlarmConstant.acdcMod10_acErr:
|
case AlarmConstant.acdcMod11_acErr:
|
case AlarmConstant.acdcMod12_acErr:
|
case AlarmConstant.acdcMod13_acErr:
|
case AlarmConstant.acdcMod14_acErr:
|
case AlarmConstant.acdcMod15_acErr:
|
case AlarmConstant.acdcMod16_acErr:
|
resultMap.put("整流器交流异常",resultMap.get("整流器交流异常")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.acdcMod1_overVol:
|
case AlarmConstant.acdcMod2_overVol:
|
case AlarmConstant.acdcMod3_overVol:
|
case AlarmConstant.acdcMod4_overVol:
|
case AlarmConstant.acdcMod5_overVol:
|
case AlarmConstant.acdcMod6_overVol:
|
case AlarmConstant.acdcMod7_overVol:
|
case AlarmConstant.acdcMod8_overVol:
|
case AlarmConstant.acdcMod9_overVol:
|
case AlarmConstant.acdcMod10_overVol:
|
case AlarmConstant.acdcMod11_overVol:
|
case AlarmConstant.acdcMod12_overVol:
|
case AlarmConstant.acdcMod13_overVol:
|
case AlarmConstant.acdcMod14_overVol:
|
case AlarmConstant.acdcMod15_overVol:
|
case AlarmConstant.acdcMod16_overVol:
|
resultMap.put("整流器过压",resultMap.get("整流器过压")+data.get(i).getNum().intValue());
|
break;
|
default:
|
throw new IllegalStateException("Unexpected value: " + data.get(i));
|
}
|
|
}
|
|
return new Response<Map>().set(1,resultMap);
|
}
|
|
public Response<Map> getStatus(int userId){
|
|
//状态-交流停电,
|
//状态-直流电压异常,
|
//状态-负载熔断,
|
//状态-直流过流
|
Map<String,Object> resultMap = new HashMap<>();
|
resultMap.put("交流停电",0);
|
resultMap.put("直流电压异常",0);
|
resultMap.put("负载熔断",0);
|
resultMap.put("直流过流",0);
|
|
List<Integer> types = Arrays.asList(
|
AlarmConstant.acIn1_powerdown,
|
AlarmConstant.dcOut_over_vol,
|
AlarmConstant.dcOut_under_vol,
|
AlarmConstant.loader_fuse,
|
AlarmConstant.dcOut_over_curr
|
);
|
|
List<PowerAlarm> data = mapper.getAnalysis(userId,types);
|
|
for (int i = 0; i < data.size(); i++) {
|
switch (data.get(i).getAlarmType()){
|
case AlarmConstant.acIn1_powerdown:
|
resultMap.put("交流停电",data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.dcOut_over_vol:
|
case AlarmConstant.dcOut_under_vol:
|
resultMap.put("直流电压异常",(Integer)resultMap.get("直流电压异常")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.loader_fuse:
|
resultMap.put("负载熔断",data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.dcOut_over_curr:
|
resultMap.put("直流过流",data.get(i).getNum().intValue());
|
break;
|
default:
|
throw new IllegalStateException("Unexpected value: " + data.get(i));
|
}
|
|
}
|
|
/*======获取电源告警机房数和比例======*/
|
/*//告警机房数
|
int alarmStationCount = mapper.getAlarmStationCount(userId);
|
//总机房数
|
int stationCount = infoMapper.getStationCount(userId);
|
//比例
|
String alarmStationRate = (String) MathUtil.divide(alarmStationCount, stationCount,3);
|
resultMap.put("告警机房数",alarmStationCount);
|
resultMap.put("告警机房比例",alarmStationRate);*/
|
|
return new Response<Map>().set(1,resultMap);
|
}
|
|
public Response<Map> getBatteryGroupAnalysis(int userId){
|
|
//电池组-熔断,
|
//电池组-电压低,
|
//电池组-下电,
|
//电池组-充电过流
|
Map<String,Integer> resultMap = new HashMap<>();
|
resultMap.put("熔断",0);
|
resultMap.put("电压低",0);
|
resultMap.put("下电",0);
|
resultMap.put("充电过流",0);
|
|
List<Integer> types = Arrays.asList(
|
AlarmConstant.battgroup1_fuse,
|
AlarmConstant.battgroup2_fuse,
|
AlarmConstant.battgroup1_volLow,
|
AlarmConstant.battgroup2_volLow,
|
AlarmConstant.battgroup1_down,
|
AlarmConstant.battgroup2_down,
|
AlarmConstant.battgroup1_overChgCurr,
|
AlarmConstant.battgroup2_overChgCurr
|
);
|
|
List<PowerAlarm> data = mapper.getAnalysis(userId,types);
|
|
for (int i = 0; i < data.size(); i++) {
|
switch (data.get(i).getAlarmType()){
|
case AlarmConstant.battgroup1_fuse:
|
case AlarmConstant.battgroup2_fuse:
|
resultMap.put("熔断",resultMap.get("熔断")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.battgroup1_volLow:
|
case AlarmConstant.battgroup2_volLow:
|
resultMap.put("电压低",resultMap.get("电压低")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.battgroup1_down:
|
case AlarmConstant.battgroup2_down:
|
resultMap.put("下电",resultMap.get("下电")+data.get(i).getNum().intValue());
|
break;
|
case AlarmConstant.battgroup1_overChgCurr:
|
case AlarmConstant.battgroup2_overChgCurr:
|
resultMap.put("充电过流",resultMap.get("充电过流")+data.get(i).getNum().intValue());
|
break;
|
default:
|
throw new IllegalStateException("Unexpected value: " + data.get(i));
|
}
|
|
}
|
|
return new Response<Map>().set(1,resultMap);
|
}
|
|
|
public Response<List> getAlarmStationCount(int userId) {
|
//告警机房数
|
int alarmStationCount = mapper.getAlarmStationCount(userId);
|
//总机房数
|
int stationCount = infoMapper.getStationCount(userId);
|
|
List<Integer> counts = Arrays.asList(alarmStationCount, stationCount);
|
|
return new Response<List>().set(1,counts);
|
}
|
}
|
