修改报表，界面添加查询流程卡个数，调整推送数据到前端的间隔

ZengTao

2025-03-28 f68d3c71819feb59e7a227a5d992b059b900916c

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/impl/BigStorageCageDetailsServiceImpl.java

@@ -2,14 +2,16 @@

import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.base.entity.BigStorageCageBaseInfo;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.FlowCardDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
@@ -20,26 +22,25 @@
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.job.PlcStorageCageTask;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -72,9 +73,16 @@
    private TemperingGlassInfoService temperingGlassInfoService;

    @Resource
    private PlcStorageCageTask plcStorageCageTask;

    @Resource
    private DamageService damageService;
    @Resource
    private RedisUtil redisUtil;
    @Resource
    private BigStorageCageOutTaskService bigStorageCageOutTaskService;
    @Resource
    private BigStorageCageDetailsService bigStorageCageDetailsService;

    @Value("${mes.minCount}")
    private int minCount;
@@ -101,6 +109,13 @@
                .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                .isNotNull(BigStorageCageFeedTask::getTargetSlot);
        List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(feedTaskWrapper);

        List<String> glassIds = bigStorageCageDetailsList.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
        List<BigStorageCageFeedTask> feedTasks = bigStorageCageFeedTaskList.stream()
                .filter(task -> !glassIds.contains(task.getGlassId()))
                .collect(Collectors.toList());


        Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
        Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
@@ -109,6 +124,14 @@
            BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
        }
        for (BigStorageCageFeedTask bigStorageCageFeedTask : feedTasks
        ) {
            BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
            bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
            bigStorageCageDetailsList.add(bigStorageCageDetails);
        }
        bigStorageCageDetailsList.sort(Comparator
                .comparing((BigStorageCageDetails detail) -> detail.getBigStorageCageFeedTask().getId()));
        return bigStorageCageDetailsList;
    }

@@ -118,7 +141,8 @@
        outWrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING, Const.GLASS_STATE_SCHEDULE_ING);
        List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(outWrapper);
        LambdaQueryWrapper<BigStorageCageOutTask> outTaskWrapper = new LambdaQueryWrapper<>();
        outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS);
        outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
                .orderByAsc(BigStorageCageOutTask::getId);
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = bigStorageCageOutTaskMapper.selectList(outTaskWrapper);

        Map<String, BigStorageCageOutTask> listMap = bigStorageCageOutTaskList.stream()
@@ -133,6 +157,10 @@
            BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
        }
        bigStorageCageDetailsList.sort(Comparator
                .comparing((BigStorageCageDetails detail) -> detail.getBigStorageCageOutTask().getTrainNumber())
                .thenComparingInt((BigStorageCageDetails detail) -> detail.getBigStorageCageOutTask().getSerialNumber()));

        return bigStorageCageDetailsList;
    }

@@ -188,19 +216,19 @@
        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper = new LambdaQueryWrapper<>();
        bigStorageCageDetailsWrapper
                .eq(BigStorageCageDetails::getGlassId, glassId)
                .eq(BigStorageCageDetails::getState,Const.GLASS_STATE_IN);
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
        BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(bigStorageCageDetailsWrapper);

        if (temperingGlassInfo != null) {
            if (status == 0) {
            if (status == 8) {
                temperingGlassInfo.setState(Const.GLASS_STATE_DAMAGE);
            } else {
                temperingGlassInfo.setState(Const.GLASS_STATE_TAKE);
            }
            temperingGlassInfoMapper.updateById(temperingGlassInfo);
            temperingGlassInfoMapper.deleteById(temperingGlassInfo);
        }
        Damage damage = new Damage();
        if (status == 0) {
        if (status == 8) {
            bigStorageCageDetails.setState(Const.GLASS_STATE_DAMAGE);
            damage.setType(Const.GLASS_STATE_DAMAGE);
        } else {
@@ -210,10 +238,10 @@
        baseMapper.updateById(bigStorageCageDetails);
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
        damage.setGlassId(bigStorageCageDetails.getGlassId());
        damage.setWorkingProcedure("冷加工");
        damage.setLine(3001);
        damage.setRemark("大理片笼破损");
        damage.setStatus(2);
        damage.setWorkingProcedure("钢化");
        damage.setLine(4001);
        damage.setRemark("大理片笼");
        damage.setStatus(1);
        damageService.insertDamage(damage);
    }

@@ -221,7 +249,7 @@
    @Override
    public List<BigStorageCageDetails> selectBigStorageCageDetails(String glassId) {
        LambdaQueryWrapper<GlassInfo> glassInfoWrapper = new LambdaQueryWrapper<>();
        List<BigStorageCageDetails> bigStorageCageDetailsList=new ArrayList<>();
        List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
        glassInfoWrapper.eq(GlassInfo::getGlassId, glassId);
        GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoWrapper);
        BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
@@ -265,6 +293,13 @@

    @Override
    public BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) {
        List<GlassInfo> glassInfoList = glassInfoService.list(
                new LambdaQueryWrapper<GlassInfo>()
                        .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
                        .eq(GlassInfo::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                        .eq(GlassInfo::getTargetSlot, glassInfo.getTargetSlot())
        );
        List<String> glassIds = glassInfoList.stream().map(GlassInfo::getGlassId).collect(Collectors.toList());
        BigStorageDTO bigStorageDTO = null;
        MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>(BigStorageCage.class)
                .selectAll(BigStorageCage.class)
@@ -274,13 +309,15 @@
                .eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
                .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
                .gt(BigStorageCage::getSlotHeight, Math.min(glassInfo.getWidth(), glassInfo.getHeight()))
                .in(BigStorageCageDetails::getGlassId, glassIds)
                .last("limit 1");
        if (glassInfo.getTemperingLayoutId() == 0) {
            wrapper.eq(BigStorageCageDetails::getFlowCardId,glassInfo.getFlowCardId())
                    .eq(BigStorageCageDetails::getLayer,glassInfo.getLayer());
            wrapper.eq(BigStorageCageDetails::getFlowCardId, glassInfo.getFlowCardId())
                    .eq(BigStorageCageDetails::getLayer, glassInfo.getLayer());
//            wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
        } else {
            wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() + 1);
            wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() - 1);
        }
        BigStorageCage bigStorageCage = bigStorageCageService.selectJoinOne(BigStorageCage.class, wrapper);
        if (null != bigStorageCage) {
@@ -294,9 +331,10 @@
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .lt(BigStorageCage::getSlotHeight, Math.min(glassInfo.getWidth(), glassInfo.getHeight()))
//                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .inSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where engineer_id = '" + glassInfo.getEngineerId() + "' and tempering_layout_id = " + glassInfo.getTemperingLayoutId())
                        "select distinct device_id from big_storage_cage_details where state!=101 and engineer_id = '" + glassInfo.getEngineerId() + "' and tempering_layout_id = " + glassInfo.getTemperingLayoutId())
                .last("limit 1"));
        if (null != bigStorageCage) {
            log.info("根据版图id找到笼子内的目标格子：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
@@ -308,7 +346,50 @@
        }

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness());
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness(), Math.min(glassInfo.getWidth(), glassInfo.getHeight()));
        List<Integer> deviceUseds = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness(), Math.min(glassInfo.getWidth(), glassInfo.getHeight()));
        List<BigStorageCageDetails> engineerCount1 = baseMapper.selectList(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 1, 5)
        );
        List<BigStorageCageDetails> engineerCount2 = baseMapper.selectList(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 6, 8)
        );
        BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
                        .orderByAsc(BigStorageCageDetails::getSlot)
                        .last("limit 1")
        );
        if (bigStorageCageDetails == null) {
            if (glassInfo.getThickness() == 8) {
                deviceUsedList.removeIf(device -> device < 6);
            } else {
                if (engineerCount1.size() > engineerCount2.size()) {
                    deviceUsedList.removeIf(device -> device < 6);
                } else {
                    deviceUsedList.removeIf(device -> device > 5);
                }
            }
        } else {
            if (bigStorageCageDetails.getDeviceId() >= 1 && bigStorageCageDetails.getDeviceId() <= 5) {
                deviceUsedList.removeIf(device -> device > 5);
            } else {
                deviceUsedList.removeIf(device -> device < 6);
            }
        }

        if (CollectionUtils.isEmpty(deviceUsedList)) {
            deviceUsedList = deviceUseds;
        }

        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth)
@@ -363,12 +444,11 @@
    }

    @Override
    public boolean temperingGlass(String temperingLayoutId, String engineerId) {
    public boolean temperingGlass(String temperingLayoutId, String engineerId, String temperingFeedSequence) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        if (temperingGlassInfoList.size() == 0) {
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                    .selectAll(GlassInfo.class)
@@ -380,7 +460,13 @@
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                temperingGlassInfoService.saveBatch(temperingGlassInfos);
                if ("0".equals(temperingFeedSequence)) {
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, 1);
                    }
                } else {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                }
                return true;
            }
        }
@@ -404,4 +490,93 @@
        redisUtil.setCacheObject("temperingSwitch", flag);
        return "success";
    }

    @Override
    public void appointEngineerId(String engineerId) {
        redisUtil.setCacheObject("temperingengineerId", engineerId);
    }

    @Override
    public long scheduleTime() {
        //执行内部调度任务
        List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
        List<BigStorageCageOutTask> bigStorageCageOutTasks = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
            for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                List<GlassInfo> glassInfos = glassInfoService.list(
                        new LambdaQueryWrapper<GlassInfo>()
                                .eq(GlassInfo::getEngineerId, temperingOccupySlot.getEngineerId())
                                .eq(GlassInfo::getTemperingLayoutId, temperingOccupySlot.getTemperingLayoutId())
                                .notInSql(GlassInfo::getGlassId, "select glass_id from damage where type=8 and engineer_id='"
                                        + temperingOccupySlot.getEngineerId() + "' and tempering_layout_id = '" + temperingOccupySlot.getTemperingLayoutId() + "'")
                                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                );
                Map<Integer, List<GlassInfo>> listMap = glassInfos.stream().collect(Collectors.groupingBy(item -> item.getTargetSlot()));
                for (Map.Entry<Integer, List<GlassInfo>> entry : listMap.entrySet()) {
                    List<GlassInfo> valueList = entry.getValue();
                    List<String> glassIds = valueList.stream().map(GlassInfo::getGlassId).collect(Collectors.toList());
                    List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsService.list(
                            new LambdaQueryWrapper<BigStorageCageDetails>()
                                    .in(BigStorageCageDetails::getGlassId, glassIds)
                                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                    .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence)
                    );
                    //当一格玻璃都到齐时
                    if (bigStorageCageDetailsList.size() == valueList.size()) {
                        long distinctSlotCount = bigStorageCageDetailsList.stream()
                                .map(BigStorageCageDetails::getSlot)
                                .distinct()
                                .count();
                        //当玻璃不在同一格时
                        if (distinctSlotCount > 1) {
                            BigStorageCageDetails maxSequenceDetail = bigStorageCageDetailsList.stream()
                                    .max(Comparator.comparingInt(BigStorageCageDetails::getTemperingFeedSequence))
                                    .orElse(null);  // 如果没有元素，返回 null
                            int maxSlot = maxSequenceDetail.getSlot();
                            int serialNumber = 1;
                            for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
                            ) {
                                if (bigStorageCageDetails.getSlot() != maxSlot) {
                                    bigStorageCageOutTasks.add(new BigStorageCageOutTask(bigStorageCageDetails.getGlassId(), bigStorageCageDetails.getSlot(), maxSlot,
                                            bigStorageCageDetails.getWidth() * 10, bigStorageCageDetails.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
                                }
                            }
                        }
                    }
                }
            }
        }
        long startSlotCount = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getStartSlot).distinct().count();
        long endSlotCount = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getEndSlot).distinct().count();
        long time = (startSlotCount * 30 + endSlotCount * 20) / 60;
        return time;
    }

    @Override
    public void cancelOutTask() {
        List<BigStorageCageOutTask> bigStorageCageOutTasks = bigStorageCageOutTaskService.list(
                new LambdaQueryWrapper<BigStorageCageOutTask>()
                        .in(BigStorageCageOutTask::getEndSlot, Const.OUT_TARGET_POSITION_ALL)
                        .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW)
        );
        if(bigStorageCageOutTasks.size()>0){
            List<String> outGlassId = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
            temperingGlassInfoService.remove(
                    new LambdaUpdateWrapper<TemperingGlassInfo>()
                            .in(TemperingGlassInfo::getGlassId, outGlassId)
            );
            bigStorageCageDetailsService.update(
                    new LambdaUpdateWrapper<BigStorageCageDetails>()
                            .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                            .in(BigStorageCageDetails::getGlassId, outGlassId)
            );
            bigStorageCageOutTaskService.deleteTask(bigStorageCageOutTasks);
        }
    }

    @Override
    public List<FlowCardDTO> selectFlowCardCount(){
        return baseMapper.selectFlowCardCount();
    }
}