update

Lius

2024-05-09 efc5dece153d8e51f9e18e136a35558c4ae8a894

 lxzn-module-mdc/src/main/java/org/jeecg/modules/mdc/service/impl/MdcEquipmentStatisticalShiftInfoServiceImpl.java

@@ -4,14 +4,13 @@
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.jeecg.modules.mdc.entity.Equipment;
import org.jeecg.modules.mdc.entity.MdcEquipmentRepair;
import org.jeecg.modules.mdc.entity.MdcEquipmentRunningSection;
import org.jeecg.modules.mdc.entity.MdcEquipmentStatisticalShiftInfo;
import org.jeecg.modules.mdc.mapper.MdcEquipmentStatisticalShiftInfoMapper;
import org.jeecg.modules.mdc.service.IEquipmentService;
import org.jeecg.modules.mdc.service.IMdcDeviceCalendarService;
import org.jeecg.modules.mdc.service.IMdcEquipmentRunningSectionService;
import org.jeecg.modules.mdc.service.IMdcEquipmentStatisticalShiftInfoService;
import org.jeecg.modules.mdc.service.*;
import org.jeecg.modules.mdc.util.DateUtils;
import org.jeecg.modules.mdc.vo.MdcDateVo;
import org.jeecg.modules.mdc.vo.MdcDeviceCalendarVo;
import org.jeecg.modules.mdc.vo.MdcShiftDateVo;
import org.springframework.stereotype.Service;
@@ -19,9 +18,11 @@

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description: 设备单日班次运行数据表
@@ -39,6 +40,9 @@

    @Resource
    private IMdcDeviceCalendarService mdcDeviceCalendarService;

    @Resource
    private IMdcEquipmentRepairService mdcEquipmentRepairService;

    /**
     * 计算设备单日班次运行数据
@@ -68,6 +72,24 @@
        }
        if (!result.isEmpty()) {
            this.saveBatch(result);
        }
    }

    /**
     * 查询主轴运行时间
     *
     * @param equipmentId
     * @param validDate
     * @return
     */
    @Override
    public BigDecimal findSpindleRunDuration(String equipmentId, String validDate) {
        validDate = validDate.replaceAll("-", "");
        BigDecimal duration = this.baseMapper.findSpindleRunDuration(equipmentId, validDate);
        if (duration != null && duration.compareTo(BigDecimal.ZERO) != 0) {
            return duration.divide(new BigDecimal("60"), 0, RoundingMode.HALF_UP);
        } else {
            return new BigDecimal("0");
        }
    }

@@ -110,7 +132,7 @@
        }
        //查询班制班次信息
        Map<String, List<MdcDeviceCalendarVo>> listMap = this.mdcDeviceCalendarMap(equipment.getEquipmentid(), stringDates);
        if (listMap.isEmpty()) {
        if (listMap == null || listMap.isEmpty()) {
            listMap = new HashMap<>();
        }
        List<MdcEquipmentStatisticalShiftInfo> resultList = new ArrayList<>();
@@ -140,7 +162,9 @@
                        equipmentStatisticalShiftInfo.setCloseLong(equipmentStatisticalShiftInfo.getCloseLong().add(shiftInfo.getCloseLong()));
                        equipmentStatisticalShiftInfo.setOpenLong(equipmentStatisticalShiftInfo.getOpenLong().add(shiftInfo.getOpenLong()));
                        equipmentStatisticalShiftInfo.setErrorLong(equipmentStatisticalShiftInfo.getErrorLong().add(shiftInfo.getErrorLong()));
                        equipmentStatisticalShiftInfo.setTotalLong(equipmentStatisticalShiftInfo.getTotalLong().add(shiftInfo.getTotalLong()));
                    }
                    resultList.add(equipmentStatisticalShiftInfo);
                }
            }
        }
@@ -158,76 +182,420 @@
        if (dates == null || StringUtils.isBlank(equipmentid)) {
            return null;
        }
        //不过滤休班和维修
        //获取班次时间段内数据
        List<MdcEquipmentRunningSection> sectionList = mdcEquipmentRunningSectionService.listEquipmentRunningSection(equipmentid, dates.getStart(), dates.getEnd());
        //查询无数据需要EquipmentLog解析
        if (sectionList.isEmpty()) {
            sectionList = mdcEquipmentRunningSectionService.listRunningSectionFromLog(equipmentid, dates.getStart(), dates.getEnd());
        }
        if (sectionList == null || sectionList.isEmpty()) {
            sectionList = new ArrayList<>();
        }
        //处理数据
        long datesStart = dates.getStart();
        long datesEnd = dates.getEnd();
        for (int i = 0; i < sectionList.size(); i++) {
            MdcEquipmentRunningSection equipmentRunningSection = sectionList.get(i);
            long start = equipmentRunningSection.getStartTime().getTime();
            long end = equipmentRunningSection.getEndTime().getTime();
            if (datesStart <= start) {
                equipmentRunningSection.setStartTime(equipmentRunningSection.getStartTime());
        //查询是否需要维修的设备
        List<MdcEquipmentRepair> repairs = mdcEquipmentRepairService.mdcRepairListDate(equipmentid, dates.getStartDate(), dates.getEndDate());
        //制度时间段内的休班和维修时间段筛选
        List<MdcEquipmentRepair> repairList = this.findSubRepairs(repairs, dates);
        List<MdcDateVo> dateList = new ArrayList<>();
        if (repairList == null || repairList.isEmpty()) {
            //制度时间段内没有维修和休班时间段
            MdcEquipmentStatisticalShiftInfo shiftInfo = mdcRateEquipment(equipmentid, dates.getStartDate(), dates.getEndDate());
            return shiftInfo;
        } else {
            if (repairList.size() == 1) {
                long start = repairList.get(0).getStartTime().getTime();
                long end = repairList.get(0).getEndTime().getTime();
                if (start > dates.getStart() && end < dates.getEnd()) {
                    MdcDateVo d1 = new MdcDateVo();
                    d1.setStartTime(dates.getStartDate());
                    d1.setEndTime(repairList.get(0).getStartTime());
                    dateList.add(d1);
                    MdcDateVo d2 = new MdcDateVo();
                    d2.setStartTime(repairList.get(0).getEndTime());
                    d2.setEndTime(dates.getEndDate());
                    dateList.add(d2);
                } else if (start == dates.getStart() && end < dates.getEnd()) {
                    MdcDateVo d2 = new MdcDateVo();
                    d2.setStartTime(repairList.get(0).getEndTime());
                    d2.setEndTime(dates.getEndDate());
                    dateList.add(d2);
                } else if (start > dates.getStart() && end == dates.getEnd()) {
                    MdcDateVo d1 = new MdcDateVo();
                    d1.setStartTime(dates.getStartDate());
                    d1.setEndTime(repairList.get(0).getStartTime());
                    dateList.add(d1);
                } else {
                    //休班
                    MdcEquipmentStatisticalShiftInfo vo = new MdcEquipmentStatisticalShiftInfo();
                    vo.setTotalLong(BigDecimal.ZERO);
                    vo.setErrorLong(BigDecimal.ZERO);
                    vo.setProcessLong(BigDecimal.ZERO);
                    vo.setWaitLong(BigDecimal.ZERO);
                    vo.setCloseLong(BigDecimal.ZERO);
                    vo.setOpenLong(BigDecimal.ZERO);
                    return vo;
                }
            } else {
                equipmentRunningSection.setStartTime(dates.getStartDate());
            }
            if (datesEnd >= end) {
                equipmentRunningSection.setEndTime(equipmentRunningSection.getEndTime());
            } else {
                equipmentRunningSection.setEndTime(dates.getEndDate());
            }
            Long sen = DateUtils.differentSecond(equipmentRunningSection.getStartTime(), equipmentRunningSection.getEndTime());
            if (sen <= 0) {
                sectionList.remove(i);
                i--;
            } else {
                equipmentRunningSection.setDuration(sen);
                equipmentRunningSection.setStartLong(equipmentRunningSection.getStartTime().getTime());
                equipmentRunningSection.setEndLong(equipmentRunningSection.getEndTime().getTime());
                long s = dates.getStartDate().getTime();
                for (int i = 0; i < repairList.size(); i++) {
                    long start = repairList.get(i).getStartTime().getTime();
                    long end = repairList.get(i).getEndTime().getTime();

                    if (start > s) {
                        MdcDateVo d = new MdcDateVo();
                        d.setStartTime(dates.getStartDate());
                        d.setEndTime(repairList.get(i).getStartTime());
                        if (d.getEndTime().getTime() != d.getStartTime().getTime()) {
                            dateList.add(d);
                        }
                        dates.setStartDate(repairList.get(i).getEndTime());
                    } else if (start == s) {
                        dates.setStartDate(repairList.get(i).getEndTime());
                    }
                    if (i == repairList.size() - 1) {
                        if (dates.getStartDate().getTime() >= end) {
                            MdcDateVo d = new MdcDateVo();
                            d.setStartTime(repairList.get(i).getEndTime());
                            d.setEndTime(dates.getEndDate());
                            if (d.getEndTime().getTime() != d.getStartTime().getTime()) {
                                dateList.add(d);
                            }
                        }
                    }
                }
            }
        }
        MdcEquipmentStatisticalShiftInfo shiftInfo = new MdcEquipmentStatisticalShiftInfo();
        shiftInfo.setEquipmentId(equipmentid);
        shiftInfo.setShiftId(dates.getShiftId());
        shiftInfo.setShiftSubId(dates.getShiftSubId());
        shiftInfo.setTheDate(dates.getDay());
        long waitLong = 0L;
        long processLong = 0L;
        long closeLong = 0L;
        long errorLong = 0L;
        for (MdcEquipmentRunningSection equipmentRunningSection : sectionList) {
            Long duration = equipmentRunningSection.getDuration();
            int status = equipmentRunningSection.getStatus();
            if (status == 2) {
                waitLong += duration;
        for (MdcDateVo date : dateList) {
            MdcEquipmentStatisticalShiftInfo v = mdcRateEquipment(equipmentid, date.getStartTime(), date.getEndTime());
            shiftInfo.setTotalLong(v.getTotalLong().add(shiftInfo.getTotalLong()));
            shiftInfo.setOpenLong(v.getOpenLong().add(shiftInfo.getOpenLong()));
            shiftInfo.setCloseLong(v.getCloseLong().add(shiftInfo.getCloseLong()));
            shiftInfo.setWaitLong(v.getWaitLong().add(shiftInfo.getWaitLong()));
            shiftInfo.setProcessLong(v.getProcessLong().add(shiftInfo.getProcessLong()));
            shiftInfo.setErrorLong(v.getErrorLong().add(shiftInfo.getErrorLong()));
        }
        return shiftInfo;
    }

    private MdcEquipmentStatisticalShiftInfo mdcRateEquipment(String equipmentid, Date startDate, Date endDate) {
        MdcDateVo date = new MdcDateVo();
        date.setStartTime(startDate);
        date.setEndTime(endDate);
        List<MdcEquipmentRunningSection> runningSections = new ArrayList<>();
        runningSections = mdcEquipmentRunningSectionService.listEquipmentRunningSectionRun(equipmentid, startDate.getTime(), endDate.getTime());
        //查询如果无数据需要 EquipmentLog 解析
        if (runningSections == null || runningSections.isEmpty()) {
            runningSections = mdcEquipmentRunningSectionService.listRunningSectionFromLog(equipmentid, startDate.getTime(), endDate.getTime());
        }
        if (runningSections == null || runningSections.isEmpty()) {
            runningSections = new ArrayList<>();
        }
        List<MdcEquipmentRunningSection> sectionErrors = mdcEquipmentRunningSectionService.listEquipmentRunningSectionError(equipmentid, startDate.getTime(), endDate.getTime());

        // 排除基础配置报警号（基础配置报警号的不算报警）
        //sectionErrors = filterSectionErrors(equipmentId, sectionErrors);
        MdcEquipmentStatisticalShiftInfo shiftInfo = new MdcEquipmentStatisticalShiftInfo();
        BigDecimal totalLongRairs = new BigDecimal("0");
        List<MdcEquipmentRunningSection> sectionList = findStatsEquipment(null, runningSections, date, sectionErrors);
        if (sectionList == null || sectionList.isEmpty()) {
            shiftInfo.setEquipmentId(equipmentid);
            return shiftInfo;
        }
        List<MdcEquipmentRunningSection> runs = new ArrayList<>();
        List<MdcEquipmentRunningSection> errs = new ArrayList<>();
        for (MdcEquipmentRunningSection section : sectionList) {
            if (section.getStatus() == 22 || section.getStatus() == 0) {
                errs.add(section);
            }
            if (status == 3) {
                processLong += duration;
            }
            if (status == 0) {
                closeLong += duration;
            }
            if (status == 22) {
                errorLong += duration;
            if (section.getStatus() == 3) {
                runs.add(section);
            }
        }
        shiftInfo.setWaitLong(new BigDecimal(waitLong));
        shiftInfo.setProcessLong(new BigDecimal(processLong));
        shiftInfo.setCloseLong(new BigDecimal(closeLong));
        //开机时间计算为 有效时长 - 关机时长
        shiftInfo.setOpenLong(new BigDecimal((datesEnd - datesStart) / 1000).subtract(shiftInfo.getCloseLong()));
        shiftInfo.setErrorLong(new BigDecimal(errorLong));
        // 及总工时 => 有效时长减
        BigDecimal totalLong = new BigDecimal(DateUtils.getSeconds(startDate, endDate)).subtract(totalLongRairs);
        // 计算加工
        BigDecimal processLong = new BigDecimal("0");
        if (runs != null && !runs.isEmpty()) {
            processLong = processLongInfo(runs);
        }
        // 关机数据
        List<MdcEquipmentRunningSection> closes = errs.stream().filter(section -> section.getStatus() != 22).collect(Collectors.toList());

        // 关机时长
        BigDecimal closeLong = new BigDecimal("0");
        closeLong = closeLong(closes);

        /*故障时间  errs => 关机数据 + 报警数据 */
        BigDecimal faultLong = new BigDecimal("0");
        faultLong = faultLongInfo(errs);

        //报警数据
        List<MdcEquipmentRunningSection> alarms = errs.stream().filter(section -> section.getStatus() == 22).collect(Collectors.toList());

        //报警时长
        BigDecimal alarmLong = new BigDecimal("0");
        alarmLong = alarmLong(alarms);

        //待机时长 => 有效时长 - 运行时长 - 报警时长
        BigDecimal waitLong = totalLong.subtract(processLong).subtract(alarmLong);
        if (waitLong.compareTo(BigDecimal.ZERO) < 0) {
            waitLong = new BigDecimal("0");
        }

        // 开机时长 => 有效时长 - 关机时长
        BigDecimal openLong = totalLong.subtract(closeLong);
        if (openLong.compareTo(BigDecimal.ZERO) < 0) {
            openLong = new BigDecimal("0");
        }

        shiftInfo.setProcessLong(processLong);
        shiftInfo.setTotalLong(totalLong);
        shiftInfo.setWaitLong(waitLong);
        shiftInfo.setErrorLong(alarmLong);
        shiftInfo.setCloseLong(closeLong);
        shiftInfo.setOpenLong(openLong);
        return shiftInfo;
    }

    /**
     * 统计关机时长
     */
    private BigDecimal closeLong(List<MdcEquipmentRunningSection> closes) {
        BigDecimal closeLong = new BigDecimal("0");
        for (MdcEquipmentRunningSection alarm : closes) {
            closeLong = closeLong.add(new BigDecimal(alarm.getDuration()));
        }
        return closeLong;
    }

    /**
     * 统计报警时长
     */
    private BigDecimal alarmLong(List<MdcEquipmentRunningSection> alarms) {
        BigDecimal alarmLong = new BigDecimal("0");
        for (MdcEquipmentRunningSection alarm : alarms) {
            alarmLong = alarmLong.add(new BigDecimal(alarm.getDuration()));
        }
        return alarmLong;
    }

    /**
     * 统计故障时长
     */
    private BigDecimal faultLongInfo(List<MdcEquipmentRunningSection> errs) {
        BigDecimal faultLong = new BigDecimal("0");
        for (MdcEquipmentRunningSection e : errs) {
            faultLong = faultLong.add(new BigDecimal(e.getDuration()));
        }
        return faultLong;
    }

    /**
     * 统计加工时长
     */
    private BigDecimal processLongInfo(List<MdcEquipmentRunningSection> runs) {
        BigDecimal processLong = new BigDecimal("0");
        for (MdcEquipmentRunningSection se : runs) {
            if (se.getStatus() == 3) {
                processLong = processLong.add(new BigDecimal(se.getDuration()));
            }
        }
        return processLong;
    }

    private List<MdcEquipmentRunningSection> findStatsEquipment(List<MdcEquipmentRepair> repairs, List<MdcEquipmentRunningSection> sRun, MdcDateVo mdcDate, List<MdcEquipmentRunningSection> errors) {
        if (sRun == null || sRun.isEmpty()) {
            //无数据处理
            //TODO
            return null;
        }
        Long startMdc = mdcDate.getStartTime().getTime();
        Long endMdc = mdcDate.getEndTime().getTime();
        if (sRun != null && !sRun.isEmpty()) {
            for (int i = 0; i < sRun.size(); i++) {
                Long start = sRun.get(i).getStartTime().getTime();
                Long end = sRun.get(i).getEndTime().getTime();
                if (startMdc <= start) {
                    sRun.get(i).setStartTime(sRun.get(i).getStartTime());
                } else {
                    sRun.get(i).setStartTime(mdcDate.getStartTime());
                }
                if (endMdc >= end) {
                    sRun.get(i).setEndTime(sRun.get(i).getEndTime());
                } else {
                    sRun.get(i).setEndTime(mdcDate.getEndTime());
                }
                Long sen = DateUtils.differentSecond(sRun.get(i).getStartTime(),
                        sRun.get(i).getEndTime());
                if (sen <= 0) {
                    sRun.remove(i);
                    i--;
                } else {
                    sRun.get(i).setDuration(sen);
                    sRun.get(i).setStartLong(sRun.get(i).getStartTime().getTime());
                    sRun.get(i).setEndLong(sRun.get(i).getEndTime().getTime());
                }
            }
        }
        //部分数据是维修  1、运行状态下报警情况
        List<MdcEquipmentRunningSection> faultRun = new ArrayList<>();
        //制度时间段内报警数据
        if (errors != null && !errors.isEmpty()) {
            for (int i = 0; i < errors.size(); i++) {
                Long start = errors.get(i).getStartTime().getTime();
                Long end = errors.get(i).getEndTime().getTime();
                if (startMdc <= start) {
                    errors.get(i).setStartTime(errors.get(i).getStartTime());
                } else {
                    errors.get(i).setStartTime(mdcDate.getStartTime());
                }
                if (endMdc >= end) {
                    errors.get(i).setEndTime(errors.get(i).getEndTime());
                } else {
                    errors.get(i).setEndTime(mdcDate.getEndTime());
                }
                Long sen = DateUtils.differentSecond(errors.get(i).getStartTime(),
                        errors.get(i).getEndTime());
                if (sen <= 0) {
                    errors.remove(i);
                    i--;
                } else {
                    errors.get(i).setDuration(sen);
                    errors.get(i).setStartLong(errors.get(i).getStartTime().getTime());
                    errors.get(i).setEndLong(errors.get(i).getEndTime().getTime());
                }
            }

            //把运行中存在的报警剔除掉
            for (MdcEquipmentRunningSection se : sRun) {
                long runStart = se.getStartTime().getTime();
                long runEnd = se.getEndTime().getTime();
                if (se.getStatus() == 3) {
                    if (errors != null && !errors.isEmpty()) {
                        //处理报警数据
                        for (int i = 0; i < errors.size(); i++) {
                            long errStart = errors.get(i).getStartTime().getTime();
                            long errEnd = errors.get(i).getEndTime().getTime();
                            // 报警开始 小于 运行开始  报警结束 小于运行结束 报警结束 大于 运行开始
                            if (errStart < runStart && errEnd <= runEnd && errEnd > runStart) {
                                errors.get(i).setEndTime(se.getStartTime());
                                Long sen = DateUtils.differentSecond(errors.get(i).getStartTime(),
                                        errors.get(i).getEndTime());
                                errors.get(i).setDuration(sen);
                                errors.get(i).setStartLong(errors.get(i).getStartTime().getTime());
                                errors.get(i).setEndLong(errors.get(i).getEndTime().getTime());
                            }
                            // 报警开始 大于 运行开始 ， 报警开始 小于 运行结束 ，报警结束 大于 运行结束
                            else if (errStart >= runStart && errStart < runEnd && errEnd > runEnd) {
                                errors.get(i).setStartTime(se.getEndTime());
                                Long sen = DateUtils.differentSecond(errors.get(i).getStartTime(),
                                        errors.get(i).getEndTime());
                                errors.get(i).setDuration(sen);
                                errors.get(i).setStartLong(errors.get(i).getStartTime().getTime());
                                errors.get(i).setEndLong(errors.get(i).getEndTime().getTime());
                            }
                            // 报警开始 大于 运行开始 ， 报警开始 小于 运行结束 ，报警结束 大于 运行开始，报警结束 小于  运行结束
                            else if (errStart >= runStart && errStart < runEnd &&
                                    errEnd > runStart && errEnd <= runEnd) {
                                errors.remove(i);
                                i--;
                            }
                            //如果超出范围
                            else if (errStart <= runStart && errStart < runEnd &&
                                    errEnd > runStart && errEnd >= runEnd) {
                                MdcEquipmentRunningSection errOne = new MdcEquipmentRunningSection();
                                errOne.setEndTime(errors.get(i).getEndTime());

                                errors.get(i).setStartTime(errors.get(i).getStartTime());
                                errors.get(i).setEndTime(se.getStartTime());
                                Long sen = DateUtils.differentSecond(errors.get(i).getStartTime(),
                                        errors.get(i).getEndTime());
                                //

                                //TODO
                                errOne.setStatus(22);
                                errOne.setEquipmentId(errors.get(i).getEquipmentId());
                                errOne.setStartTime(se.getEndTime());
                                errors.get(i).setDuration(sen);
                                errors.get(i).setStartLong(errors.get(i).getStartTime().getTime());
                                errors.get(i).setEndLong(errors.get(i).getEndTime().getTime());

                                Long one = DateUtils.differentSecond(errOne.getStartTime(), errOne.getEndTime());
                                errOne.setDuration(one);
                                errOne.setStartLong(errOne.getStartTime().getTime());
                                errOne.setEndLong(errOne.getEndTime().getTime());
                                if (sen <= 0) {
                                    errors.remove(i);
                                    errors.add(i, errOne);
                                } else {
                                    errors.add(i + 1, errOne);
                                    i++;
                                }
                            } else {
                                continue;
                            }
                        }
                    }
                }
            }
        }
        //处理报警数据
        List<MdcEquipmentRunningSection> sectionList = new ArrayList<>();
        if (sRun != null && !sRun.isEmpty()) {
            for (MdcEquipmentRunningSection se : sRun) {
                sectionList.add(se);
            }
        }
        //报警剔除运行报警
        if (errors != null && !errors.isEmpty()) {
            sectionList.addAll(errors);
        }
        //关机处理为故障报警
        if (faultRun != null && !faultRun.isEmpty()) {
            sectionList.addAll(faultRun);
        }
        return sectionList;
    }

    private List<MdcEquipmentRepair> findSubRepairs(List<MdcEquipmentRepair> repairs, MdcShiftDateVo dates) {
        if (repairs == null || repairs.isEmpty() || dates == null) {
            return null;
        }
        for (MdcEquipmentRepair repair : repairs) {
            //调整
            Date start = null;
            Date end = null;
            long dStart = dates.getStartDate().getTime();
            long dEnd = dates.getEndDate().getTime();
            long rStart = repair.getStartTime().getTime();
            long rEnd = repair.getEndTime().getTime();

            if (rStart <= dStart && rEnd >= dStart && rEnd <= dEnd) {
                start = dates.getStartDate();
                end = repair.getEndTime();
            } else if (rStart >= dStart && rEnd <= dEnd) {
                start = repair.getStartTime();
                end = repair.getEndTime();
            } else if (rStart >= dStart && rStart <= dEnd && rEnd >= dEnd) {
                start = repair.getStartTime();
                end = dates.getEndDate();
            } else if (rStart <= dStart && rEnd >= dEnd) {
                start = dates.getStartDate();
                end = dates.getEndDate();
            }
            repair.setStartTime(start);
            repair.setEndTime(end);
            //处理异常数据
            if (start == null || end == null) {
                repair.setSecondLong(0);
            } else {
                try {
                    repair.setSecondLong(DateUtils.getSeconds(start, end));
                } catch (Exception e) {
                    repair.setSecondLong(0);
                }

            }

        }
        for (int i = 0; i < repairs.size(); i++) {
            if (repairs.get(i).getStartTime() == null || repairs.get(i).getEndTime() == null || repairs.get(i).getSecondLong() == 0) {
                repairs.remove(i);
                i--;
            }
        }
        return repairs;
    }

    /**
@@ -336,7 +704,7 @@
     */
    private Map<String, List<MdcDeviceCalendarVo>> mdcDeviceCalendarMap(String equipmentid, List<String> stringDates) {
        List<MdcDeviceCalendarVo> mdcDeviceCalendarVos = mdcDeviceCalendarService.listByEquipmentAndDate(equipmentid, stringDates);
        if (mdcDeviceCalendarVos.isEmpty()) {
        if (mdcDeviceCalendarVos == null || mdcDeviceCalendarVos.isEmpty()) {
            return null;
        }
        Map<String, List<MdcDeviceCalendarVo>> map = new HashMap<>();