审批页面修改

lxw

2023-08-15 160e150009b51a39fa95d9462c3798ba28d51a09

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

@@ -6,46 +6,47 @@
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.constant.AlarmConstant;
import com.whyc.dto.AlarmDaoFactory;
import com.whyc.dto.BattMaintDealarm;
import com.whyc.dto.Response;
import com.whyc.dto.paramter.AlarmPar;
import com.whyc.dto.result.AlarmNumberRes;
import com.whyc.dto.result.AlarmRes;
import com.whyc.dto.result.AlarmStaticRes;
import com.whyc.dto.result.AlarmNumberRes;
import com.whyc.mapper.BattalarmDataMapper;
import com.whyc.mapper.DevalarmDataMapper;
import com.whyc.pojo.BattalarmData;
import com.whyc.pojo.DevalarmData;
import com.whyc.pojo.UserInf;
import com.whyc.pojo.WorkflowAlarm;
import com.whyc.mapper.PwrdevAlarmMapper;
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.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.*;
import java.util.stream.Collectors;

@Service
@Transactional
public class BattalarmDataService {

    @Resource
    private BattalarmDataMapper  mapper;
    @Resource
    private DevalarmDataMapper devalarmDataMapper;
    @Resource
    private PwrdevAlarmMapper pwrdevAlarmMapper;


    //查询所有的告警
    public Response<List<BattalarmData>> getAll() {
    public Response getAll() {
        QueryWrapper<BattalarmData> wrapper = new QueryWrapper<>();
        // 通过id进行排序
        wrapper.orderByAsc("BattGroupId");
        List<BattalarmData> list=mapper.selectList(wrapper);
        return new Response<List<BattalarmData>>().set(1,list);
        return new Response().set(1,list);
    }
    //分页查询所有的实时告警
    public Response<List<BattalarmData>> getAllByPage(com.whyc.dto.Page p) {
@@ -64,23 +65,76 @@
        PageInfo<BattMaintDealarm> pinfo=new PageInfo<BattMaintDealarm>(list);
        return new Response<List<BattMaintDealarm>>().set(1,list,String.valueOf(pinfo.getPages()));
    }

    /**
     * @param userId
     * @param type 1,查询24小时内;0,查询所有
     * @return
     */
    public List<BattalarmData> getList(Long userId,int type){
        return mapper.getList(userId,type);
    }
    //电池告警实时查询
    public Response serchByCondition(AlarmPar par) {
        String lang = ActionUtil.getLang();
        //分页信息
        PageHelper.startPage(par.getPage().getPageCurr(), par.getPage().getPageSize());
        UserInf uinf= ActionUtil.getUser();
        UserInf uinf = ActionUtil.getUser();
        par.setUId(uinf.getUId().intValue());
        List<AlarmRes> list=mapper.serchByCondition(par);
        for (AlarmRes a:list) {
            List<BattalarmData> l=a.getAdatas();
            for (BattalarmData adata:l) {
                adata.setAlmSignalIdName(AlarmDaoFactory.getAlarmName(adata.getAlmSignalId()));
                adata.setAlmLevelName(AlarmDaoFactory.getAlarmType(adata.getAlmLevel()));
        List<AlarmRes> list = mapper.serchByCondition(par);
        for (AlarmRes a : list) {
            List<BattalarmData> l = a.getAdatas();
            for (BattalarmData adata : l) {
                adata.setAlmSignalIdName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(adata.getAlmSignalId()), lang));
                adata.setAlmLevelName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmType(adata.getAlmLevel()), lang));
            }
        }
        PageInfo<AlarmRes> pinfo=new PageInfo<AlarmRes>(list);
        return new Response().set(1,pinfo);
        PageInfo<AlarmRes> pinfo = new PageInfo<AlarmRes>(list);
        return new Response().set(1, pinfo);
    }

    //电池告警实时查询-websocket使用
    @Transactional
    public Response serchByConditionOfWebSocket(AlarmPar par, String lang) {
        //分页信息
        PageHelper.startPage(par.getPage().getPageCurr(), par.getPage().getPageSize());
        List<AlarmRes> list = mapper.serchByCondition(par);
        for (AlarmRes a : list) {
            List<BattalarmData> l = a.getAdatas();
            for (BattalarmData adata : l) {
                adata.setAlmSignalIdName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(adata.getAlmSignalId()), lang));
                adata.setAlmLevelName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmType(adata.getAlmLevel()), lang));
            }
        }
        PageInfo<AlarmRes> pinfo = new PageInfo<AlarmRes>(list);
        return new Response().set(1, pinfo);
    }


    //电池告警实时查询-websocket使用
    @Transactional
    public Response getSendBattAlarmOfWebSocket(Integer uId, String lang) {
        List<BattalarmData> list = mapper.getSendBattAlarm(uId);
        Date now = new Date();
        ListIterator<BattalarmData> it = list.listIterator();
        while (it.hasNext()) {
            BattalarmData adata = it.next();
            if (adata.getAlmLevel() == 1 && adata.getRecordTime() != null && now.getTime() - adata.getRecordTime().getTime() < 24 * 3600000) {
                it.remove();
            }
            if (adata.getAlmLevel() == 2 && adata.getRecordTime() != null && now.getTime() - adata.getRecordTime().getTime() < 7 * 24 * 3600000) {
                it.remove();
            }
            if (adata.getAlmLevel() == 3 && adata.getRecordTime() != null && now.getTime() - adata.getRecordTime().getTime() < 30 * 7 * 24 * 3600000) {
                it.remove();
            }
            adata.setAlmSignalIdName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(adata.getAlmSignalId()), lang));
            adata.setAlmLevelName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmType(adata.getAlmLevel()), lang));
        }
        return new Response().set(1,list);
    }


    //根据电池组id查询所有的告警
    public Response<List<AlarmRes>> serchByInfo(AlarmPar par) {
        //分页信息
@@ -203,6 +257,12 @@
        return  new Response().set(number);
    }

    //实时1级告警记录总数查询
    public Response getRealTimeWithLevel1(int uId) {
        int number=mapper.getRealTimeWithLevel1(uId);
        return  new Response().set(number);
    }

    //电池告警实时查询(确认告警)
    public Response update(int num) {
        UpdateWrapper wrapper = new UpdateWrapper<>();
@@ -269,34 +329,276 @@
        List<BattalarmData> list = mapper.getCountByStationId(stationId,alarmParams);
        return list;
    }

    //项目下方的滚动，查询最新电池告警(电池告警和设备告警筛选出最新的五条)
    public Response getRealAlarm(int uId){
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DAY_OF_MONTH,-1);
        Date yesterday = instance.getTime();
    public List<BattMapInformation> findAllStation(){
        int[] alarmParams = {AlarmDaoFactory.Alarm_CapAlarm,AlarmDaoFactory.Alarm_CapChange,AlarmDaoFactory.Alarm_res_Conn,AlarmDaoFactory.ALM_TYPE_DisChargeMonVol_ID};
        List<BattalarmData> lista=mapper.getRealAlarm(yesterday,uId,alarmParams);
        List<DevalarmData> listd=devalarmDataMapper.getRealAlarm(yesterday,uId);
        if(listd!=null&&listd.size()>0){
        List<BattMapInformation> list = mapper.findAllStation(alarmParams);
        return list;
    }


    //项目下方的滚动，查询30天的电池告警和设备告警和电源告警
    @Transactional
    public Response getRealAlarm(int uId, String lang) {
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.MONTH, -1);
        Date yesterday = instance.getTime();
        int[] alarmParams = {AlarmDaoFactory.Alarm_CapAlarm, AlarmDaoFactory.Alarm_CapChange, AlarmDaoFactory.Alarm_res_Conn, AlarmDaoFactory.ALM_TYPE_DisChargeMonVol_ID};
        List<BattalarmData> lista = mapper.getRealAlarm(yesterday, uId, alarmParams);
        for (BattalarmData battAlarm : lista) {
            battAlarm.setAlarmName(MessageUtils.getMessageSocket(AlarmDaoFactory.getAlarmName(battAlarm.getAlmSignalId()), lang));
        }
        List<DevalarmData> listd = devalarmDataMapper.getRealAlarm(yesterday, uId);
        if (listd != null && listd.size() > 0) {
            for (DevalarmData ddata : listd) {
                BattalarmData data=new BattalarmData();
                data.setAlarmtype("1");//1表示设备告警
                BattalarmData data = new BattalarmData();
                data.setBattGroupId(ddata.getDevId());
                data.setAlarmType("1");//1表示设备告警
                data.setAlmId(ddata.getAlmType());
                data.setStationName(ddata.getStationName());
                data.setStationName3(ddata.getStationName3());
                data.setAlmLevel(ddata.getAlmLevel());
                //data.setNote(ddata.getNote());
                data.setNum(ddata.getNum());
                data.setAlmStartTime(ddata.getAlmStartTime());
                //data.setAlm_signal_id(ddata.getAlm_type());
                data.setAlarmName(AlarmDaoFactory.getdevName(ddata.getAlmType()));
                data.setAlarmName(MessageUtils.getMessageSocket(AlarmDaoFactory.getdevName(ddata.getAlmType()), lang));
                data.setAlmSeverity(ddata.getAlmSeverity());
                lista.add(data);
            }
        }

        //添加电源告警
        List<PwrdevAlarm> pwrAlarmList = pwrdevAlarmMapper.getRealAlarmFoot(yesterday,uId);
        if (pwrAlarmList!=null && pwrAlarmList.size()>0){
            for (PwrdevAlarm pAlarm:pwrAlarmList ) {
                BattalarmData data=new BattalarmData();
                data.setBattGroupId(pAlarm.getPowerDeviceId().intValue());
                data.setAlarmType("2");//2表示电源告警
                data.setAlmId(pAlarm.getAlmType());
                data.setStationName(pAlarm.getStationName());
                data.setStationName3(pAlarm.getStationName3());
                data.setAlmLevel(pAlarm.getAlmLevel());
                data.setNum(pAlarm.getNum());
                data.setAlmStartTime(pAlarm.getAlmStartTime());
                data.setAlarmName(AlarmDaoFactory.getAllAlarmName(pAlarm.getAlmType()));
                data.setAlmSeverity(pAlarm.getAlmSeverity());
                lista.add(data);
            }
        }
        //排序,按照时间或者说是num
        lista.sort(Comparator.comparing(BattalarmData::getAlmStartTime).reversed());
        return new Response().set(1,lista,"查询成功");
        return new Response().set(1, lista, "查询成功");

    }

    //查询分级告警的个数
    public Response serchByLevel(int uId) {
        List list = new ArrayList();
        //分四级查询个数
        for (int i = 1; i <= 4; i++) {
            int countLevel = mapper.serchByLevel(i, uId);
            list.add(countLevel);
        }
        return new Response().setII(1, list.size() > 0, list, "分级告警数");
    }

    /**
     * 单体容量 monCapStd
     * alm_id
     * Alarm_CapAlarm =119010
     * @param userId
     * @return
     */
    public Response getMonCapacityLowAnalysis(int userId) {
        Response response = new Response();
        Map<String, Object> resultMap = new HashMap<>();

        try {
            //单体容量低告警数和对应的告警机房数
            //BatteryAlarmDto batteryAlarmDto = mapper.getLowCapacityAlarms(userId,AlarmConstant.Alarm_IGNAL_ID_CapAlarmLow);
            //int alarmNum = batteryAlarmDto.getNum();
            Integer alarmLow = mapper.getAlarmHighLow(userId, AlarmConstant.Alarm_IGNAL_ID_CapAlarmLow);
            Integer alarmHigh = mapper.getAlarmHighLow(userId, AlarmConstant.Alarm_IGNAL_ID_CapAlarmHigh);
            //int stationNum = batteryAlarmDto.getStationNum();
            //总告警数
            //Integer totalAlarmNum = mapper.getTotalAlarms(userId);
            //总机房数
            //int totalStationNum = infoMapper.getStationCount(userId);

            //容量低告警占比
            //String capLowRateStr = (String) MathUtil.divide(alarmNum,totalAlarmNum,3);
            //容量低告警机房占比
            //String capLowStationRateStr = (String) MathUtil.divide(stationNum,totalStationNum,3);

            resultMap.put("单体容量低告警",alarmLow);
            resultMap.put("单体容量高告警",alarmHigh);
            //resultMap.put("告警总数",totalAlarmNum);
            //resultMap.put("告警占比",capLowRateStr);

            //resultMap.put("告警机房数",alarmNum);
            //resultMap.put("告警机房占比",capLowStationRateStr);

            response.setII(1,true, resultMap,null);
        } catch (Exception e) {
            return response.set(0,false,"发生异常:"+e.getCause());
        }
        return response;
    }

    /**
     * 单体电压、内阻和温度
     * alm_id 电池告警参数
     * 三个告警总数不同，带条件？电压、内阻、温度
     * @param userId
     * @return
     */
    public Response getMonVRTAnalysis(int userId) {

        Response response = new Response();
        try {
            HashMap<String, Object> resultMap = new HashMap<>();
            Map<String, Object> monVolMap = new HashMap<>();//单体电压  Alarm_vol_Monomer =119005;
            Map<String, Object> monResMap = new HashMap<>();//单体内阻  Alarm_res_Monomer =119007
            Map<String, Object> monTemMap = new HashMap<>();//单体温度  Alarm_tmp_Monomer =119006

            /*======单体电压======*/

            //高告警数量
            Integer volHighAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonVolHigh);
            //低告警数量
            Integer volLowAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonVolLow);

            //单体电压总告警数
            //Integer volTotalAlarmNum = volHighAlarmsNum+volLowAlarmsNum;

            //告警总数
            //Integer totalStationAlarmNum =mapper.getTotalAlarms(userId);

            //电压告警机房数
            //int volTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_vol_Monomer);

            //总机房数
            //int totalStationNum = infoMapper.getStationCount(userId);

            //电压告警占比
            //String volRateStr = (String) MathUtil.divide(volTotalAlarmNum,totalStationAlarmNum,3);
            //电压告警机房占比
            //String volStationRateStr = (String) MathUtil.divide(volTotalAlarmStations,totalStationNum,3);


            monVolMap.put("单体电压高告警", volHighAlarmsNum);     //高告警数量    alm_signal_id 9
            monVolMap.put("单体电压低告警", volLowAlarmsNum);     //低告警数量     alm_signal_id   10
            //monVolMap.put("告警总数", volTotalAlarmNum);        //告警总数
            //monVolMap.put("告警总数比例", volRateStr);      //告警总数比例
            //monVolMap.put("告警机房总数", volTotalAlarmStations);      //告警机房总数
            //monVolMap.put("告警机房数比例", volStationRateStr);    //告警机房数比例
            resultMap.put("单体电压", monVolMap);



            /*======单体内阻======*/

            //高告警数量
            Integer resHighAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonResHigh);
            //低告警数量
            Integer resLowAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonResLow);

            //单体内阻总告警数
            //Integer resTotalAlarmNum = resHighAlarmsNum+resLowAlarmsNum;

            //内阻告警机房数
            //int resTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_res_Monomer);

            //内阻告警占比
            //String resRateStr = (String) MathUtil.divide(resTotalAlarmNum,totalStationAlarmNum,3);
            //内阻告警机房占比
            //String resStationRateStr = (String) MathUtil.divide(resTotalAlarmStations,totalStationNum,3);

            monResMap.put("单体内阻高告警", resHighAlarmsNum);     //高告警数量    alm_signal_id 13
            monResMap.put("单体内阻低告警", resLowAlarmsNum);     //低告警数量     alm_signal_id 14
            //monResMap.put("告警总数", resTotalAlarmNum);        //告警总数
            //monResMap.put("告警总数比例", resRateStr);      //告警总数比例
            //monResMap.put("告警机房总数", resTotalAlarmStations);      //告警机房总数
            //monResMap.put("告警机房数比例", resStationRateStr);    //告警机房数比例
            resultMap.put("单体内阻", monResMap);

            /*======单体温度======*/

            //高告警数量
            Integer tempHighAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonTmpHigh);
            //低告警数量
            Integer tempLowAlarmsNum = mapper.getAlarmHighLow(userId, AlarmConstant.ALM_SIGNAL_ID_MonTmpLow);

            //单体温度总告警数
            //Integer tempTotalAlarmNum = tempHighAlarmsNum+tempLowAlarmsNum;

            //温度告警机房数
            //int tempTotalAlarmStations = mapper.getTotalAlarmStations(userId,AlarmConstant.Alarm_tmp_Monomer);

            //温度告警占比
            //String tempRateStr = (String) MathUtil.divide(tempTotalAlarmNum,totalStationAlarmNum,3);
            //温度告警机房占比
            //String tempStationRateStr = (String) MathUtil.divide(tempTotalAlarmStations,totalStationNum,3);

            monTemMap.put("单体温度高告警", tempHighAlarmsNum);     //高告警数量    alm_signal_id 13
            monTemMap.put("单体温度低告警", tempLowAlarmsNum);     //低告警数量     alm_signal_id 14
            //monTemMap.put("告警总数", tempTotalAlarmNum);        //告警总数
            //monTemMap.put("告警总数比例", tempRateStr);      //告警总数比例
            //monTemMap.put("告警机房总数", tempTotalAlarmStations);      //告警机房总数
            //monTemMap.put("告警机房数比例", tempStationRateStr);    //告警机房数比例
            resultMap.put("单体温度", monTemMap);

            return response.setII(1, true, resultMap, null);
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }

    //今日实时告警
    public Response getBalmToday(int userId) {
        try {
            Map<String, Object> map = new HashMap<>();
            int btatolNum = 0;
            Map<String, Integer> bAlmClearMap = new HashMap<>();
            bAlmClearMap.put("clear0", 0);
            bAlmClearMap.put("clear1", 0);
            List<BattalarmData> bAlmList = mapper.getBalmToday(userId);
            Map<Integer, List<BattalarmData>> bclearedMap = bAlmList.stream().collect(Collectors.groupingBy(BattalarmData::getAlmClearedType));
            for (Integer cleared : bclearedMap.keySet()) {
                bAlmClearMap.put("clear" + String.valueOf(cleared), bclearedMap.get(cleared).size());
                btatolNum += bclearedMap.get(cleared).size();
            }
            Map<String, Integer> bAlmLevelMap = new HashMap<>();
            bAlmLevelMap.put("level1", 0);
            bAlmLevelMap.put("level2", 0);
            bAlmLevelMap.put("level3", 0);
            bAlmLevelMap.put("level4", 0);
            Map<Integer, List<BattalarmData>> blevelMap = bAlmList.stream().collect(Collectors.groupingBy(BattalarmData::getAlmLevel));
            for (Integer level : blevelMap.keySet()) {
                bAlmLevelMap.put("level" + String.valueOf(level), blevelMap.get(level).size());
                //btatolNum += blevelMap.get(level).size();
            }
            map.put("bAlmClearMap", bAlmClearMap);
            map.put("bAlmLevelMap", bAlmLevelMap);
            map.put("btatolNum", btatolNum);
            return new Response().setII(1, true, map, "今日实时告警");
        } catch (Exception e) {
            return new Response().set(1, false, "出现异常" + e.getMessage());
        }
    }

    public List<Integer> getStationList(int userId) {
        return mapper.getStationList(userId);
    }

    public int getCapAlarmNum(int userId) {
        return mapper.getCapAlarmNum(userId);
    }

    public int getCountByStationIds(List<String> stationIdList, Integer level) {
        return mapper.getCountByStationIds(stationIdList,level);
    }

    public List<BattalarmData> getListByStationIds(List<String> stationIdList) {
        return mapper.getListByStationIds(stationIdList);
    }
}