1、义乌改造：进出笼规则调整，当存在进片任务/请求时，出片大车不执行调度任务 2、进片一个笼子存放一个工程，笼子存在工程时，按笼子使用情况，剩余格子最...

zhoushihao

2025-08-11 6397754d1a97f7b570435e8ab81d3ef1d152b2d0

1、义乌改造：进出笼规则调整，当存在进片任务/请求时，出片大车不执行调度任务
2、进片一个笼子存放一个工程，笼子存在工程时，按笼子使用情况，剩余格子最多的优先使用
3、指定钢化工程改造

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/mapper/BigStorageCageDetailsMapper.java

@@ -22,6 +22,15 @@
public interface BigStorageCageDetailsMapper extends MPJBaseMapper<BigStorageCageDetails> {

    /**
     * 指定工程的版图是否到齐
     *
     * @param engineerId
     * @param temperingLayoutId
     * @return
     */
    List<TemperingLayoutDTO> temperingIsAllByTemperingLayoutId(String engineerId, Integer temperingLayoutId);

    /**
     * 获取钢化版图已经到齐的工程号及版图id
     *
     * @return

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

@@ -40,12 +40,28 @@
    void outBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails);

    /**
     * 查询进片格子信息：优先工程最少、剩余格子最多的笼子内的格子
     * @param EngineerId
     * @param glassId
     * @param thickness
     * @return
     */
    BigStorageDTO queryTargetSlot(String EngineerId, String glassId, int thickness);

    /**
     * 按照版图信息获取进片笼子信息
     *
     * @param glassInfo
     */
    BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo);

    /**
     * 指定工程的版图是否到齐
     * @param engineerId
     * @param temperingLayoutId
     * @return
     */
    List<TemperingLayoutDTO> temperingIsAllByTemperingLayoutId(String engineerId, Integer temperingLayoutId);
    /**
     * 获取钢化版图已经到齐的工程号及版图id
     *
@@ -87,6 +103,7 @@

    /**
     * 按照工程信息及钢化id(炉号)获取缺少的玻璃信息
     *
     * @param bigStorageQueryVO
     * @return
     */
@@ -96,6 +113,7 @@

    /**
     * 按照格子号更新详情表内的格子对应的设备id
     *
     * @param slotList
     */
    void updateDeviceIdBySlot(List<Integer> slotList);

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

@@ -6,7 +6,6 @@
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.google.common.collect.Lists;
import com.mes.base.entity.vo.BigStorageVO;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
@@ -36,6 +35,7 @@
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

@@ -274,6 +274,48 @@
    }

    @Override
    public BigStorageDTO queryTargetSlot(String EngineerId, String glassId, int thickness) {
        BigStorageDTO bigStorageDTO = null;
        int slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);

        BigStorageCage bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
                .inSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where engineer_id = '" + EngineerId + "'")
                .last("limit 1"));
        if (null != bigStorageCage) {
            log.info("根据版图id找到笼子内的目标格子：{},玻璃id：{}", bigStorageCage.getSlot(), glassId);
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
            bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
            return bigStorageDTO;
        }

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(thickness);

        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                    .eq(BigStorageCage::getDeviceId, item)
                    .last("limit 1"));
            if (null != bigStorageCage) {
                log.info("按照存笼玻璃格子数占用最少方式获取信息格子为：{},玻璃id：{}", bigStorageCage.getSlot(), glassId);
                bigStorageDTO = new BigStorageDTO();
                bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
                bigStorageDTO.setSlot(bigStorageCage.getSlot());
                bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
                return bigStorageDTO;
            }
        }
        Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃");
        return bigStorageDTO;
    }

    @Override
    public BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) {
        BigStorageDTO bigStorageDTO = null;
        int slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
@@ -381,6 +423,11 @@
    }

    @Override
    public List<TemperingLayoutDTO> temperingIsAllByTemperingLayoutId(String engineerId, Integer temperingLayoutId) {
        return baseMapper.temperingIsAllByTemperingLayoutId(engineerId, temperingLayoutId);
    }

    @Override
    public List<TemperingLayoutDTO> temperingIsAll() {
        return baseMapper.temperingIsAll();
    }
@@ -477,24 +524,7 @@

    @Override
    public boolean cancelTemperingTask() {
        //当前正在执行的出片任务
        List<BigStorageCageHistoryTask> historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTargetSlot, Const.TEMPERING_OUT_TARGET_POSITION));
        //不存在出片任务，直接删除钢化小片表未出片的任务
        if (CollectionUtils.isEmpty(historyTaskList)) {
            temperingGlassInfoMapper.delete(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW));
            return Boolean.TRUE;
        }
        //存在出片任务，删除钢化小片表
        List<String> glassIdList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList());
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList)
                .orderByDesc(GlassInfo::getTemperingFeedSequence).last("limit 1"));
        temperingGlassInfoMapper.delete(new LambdaQueryWrapper<TemperingGlassInfo>()
                .eq(TemperingGlassInfo::getEngineerId, glassInfo.getEngineerId())
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .notIn(TemperingGlassInfo::getGlassId, glassIdList)
        );
        redisUtil.deleteObject("temperingEngineerId");
        return Boolean.TRUE;
    }

@@ -506,42 +536,13 @@

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

        int dispatchCount = bigStorageCageHistoryTaskService.count(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_DISPATCH));

        if (temperingGlassInfoList.size() == 0) {
            MPJLambdaWrapper<GlassInfo> wrapper = JoinWrappers.lambda(GlassInfo.class)
                    .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                            ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                            "t.angle,t1.slot,t.engineer_id")
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .ne(GlassInfo::getTemperingLayoutId, 0)
                    .orderByAsc(BigStorageCageDetails::getTemperingLayoutId)
                    .orderByAsc(BigStorageCageDetails::getTemperingFeedSequence);
            if (dispatchCount > 0) {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL);
            } else {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            }
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, wrapper);

            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                //避免大量数据插入导致sqlserver数据库异常，分批次每调存储依次
                List<List<TemperingGlassInfo>> temperingGlassInfoLists = Lists.partition(temperingGlassInfos, 50);
                for (List<TemperingGlassInfo> item : temperingGlassInfoLists) {
                    temperingGlassInfoService.saveBatch(item);
                }
                return true;
            }
        String oldEngineerId = redisUtil.getCacheObject("temperingEngineerId");
        if (StringUtils.isBlank(oldEngineerId)) {
            redisUtil.setCacheObject("temperingEngineerId", engineerId);
            return Boolean.TRUE;
        } else {
            return Boolean.FALSE;
        }
        return false;
    }

    @Override

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

@@ -102,15 +102,10 @@
                .eq(BigStorageGlassRelationInfo::getTemperingLayoutId, relationInfoOne.getTemperingLayoutId())
                .eq(BigStorageGlassRelationInfo::getVirtualSlot, relationInfoOne.getVirtualSlot())
                .eq(BigStorageGlassRelationInfo::getSlotSequence, relationInfoOne.getSlotSequence() - 1));
        BigStorageCage storageCage = null;
        BigStorageDTO storageCageDTO = null;
        if (null == relationInfoBefore) {
            //表示序号没有或者  序号为1又不是第一块来的 新开一格
            storageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getRemainWidth, slotWidth)
                    .le(BigStorageCage::getMinThickness, bigStorageCageDetails.getThickness())
                    .ge(BigStorageCage::getMaxThickness, bigStorageCageDetails.getThickness())
                    .orderByAsc(BigStorageCage::getMaxThickness)
                    .orderByAsc(BigStorageCage::getSlot).last("limit 1"));
            storageCageDTO = bigStorageCageDetailsService.queryTargetSlot(engineerId, bigStorageCageDetails.getGlassId(), (int) bigStorageCageDetails.getThickness());
        } else {
            BigStorageCageDetails beforeGlass = bigStorageCageDetailsService.getOne(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)
@@ -119,23 +114,18 @@
                    .eq(BigStorageCageDetails::getTemperingFeedSequence, relationInfoBefore.getTemperingFeedSequence())
            );
            if (null == beforeGlass) {
                storageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getRemainWidth, slotWidth)
                        .le(BigStorageCage::getMinThickness, bigStorageCageDetails.getThickness())
                        .ge(BigStorageCage::getMaxThickness, bigStorageCageDetails.getThickness())
                        .orderByAsc(BigStorageCage::getMaxThickness).orderByAsc(BigStorageCage::getSlot).last("limit 1"));
                storageCageDTO = bigStorageCageDetailsService.queryTargetSlot(engineerId, bigStorageCageDetails.getGlassId(), (int) bigStorageCageDetails.getThickness());
            } else {
                storageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                BigStorageCage bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getSlot, beforeGlass.getSlot()));
                Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃");
                storageCageDTO = new BigStorageDTO();
                storageCageDTO.setWidth(bigStorageCage.getRemainWidth());
                storageCageDTO.setSlot(bigStorageCage.getSlot());
                storageCageDTO.setDeviceId(bigStorageCage.getDeviceId());
            }
        }
        Assert.isTrue(null != storageCage, "没有空余的笼子存放玻璃");
        BigStorageDTO storageDTO = new BigStorageDTO();
        storageDTO.setDeviceId(storageCage.getDeviceId());
        storageDTO.setSlotSequence(relationInfoOne.getSlotSequence());
        storageDTO.setSlot(storageCage.getSlot());
        storageDTO.setWidth(storageCage.getRemainWidth());
        return storageDTO;
        return storageCageDTO;
    }

    @Override
@@ -217,7 +207,7 @@

    private Integer getGlassGapByThickness(Double thickness) {
        int sysKey = 0;
        if (thickness >= 12 ) {
        if (thickness >= 12) {
            sysKey = ConstSysConfig.VERTICAL_GLASS_GAP_12;
        } else if (thickness == 8) {
            sysKey = ConstSysConfig.VERTICAL_GLASS_GAP_8;

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageNewTask.java

@@ -100,7 +100,7 @@
    private RedisUtil redisUtil;

    @Scheduled(fixedDelay = 1000)
    public void inBigStorageTask() throws Exception {
    public void inBigStorageTask() {
        S7DataDLPOne s7DataDLPOne = s7SerializerDLPOne.read(S7DataDLPOne.class);
        log.info("进片任务开始{}", s7DataDLPOne);
        Boolean inkageEntity = s7DataDLPOne.getMesControl();
@@ -339,49 +339,56 @@
            log.info("有正在执行的出片任务，结束本次出片任务");
            return;
        }
        //是否允许钢化
        //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息
//            获取当前钢化任务未完成出片的玻璃信息

        Integer temperingOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_TEMPERING_OUT_TARGET_POSITION);
        List<TemperingGlassInfo> unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingLayoutId).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence));
        if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfoByVirtualSlot(unFinishTemperingGlassInfoList, "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }

        BigStorageCageDetails details = bigStorageCageDetailsService.getOne(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).last("limit 1"));
        if (details != null) {
            TemperingGlassInfo temperingGlassInfo = new TemperingGlassInfo();
            BeanUtils.copyProperties(details, temperingGlassInfo);
            temperingGlassInfo.setState(-1);
            temperingGlassInfoService.save(temperingGlassInfo);
            computeOutGlassInfoByVirtualSlot(Arrays.asList(temperingGlassInfo), "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
            return;
        }

        if (redisUtil.getCacheObject("temperingSwitch")) {
            //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
            List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
            if (CollectionUtil.isNotEmpty(temperingLayoutDTOList)) {
                //玻璃到齐包括已出片的
                //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
                for (TemperingLayoutDTO item : temperingLayoutDTOList) {
//                    if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) {
            //是否允许钢化
            //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息
//            获取当前钢化任务未完成出片的玻璃信息
            List<TemperingGlassInfo> unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                    .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingLayoutId).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence));
            if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
                log.info("有正在出片的钢化任务");
                computeOutGlassInfoByVirtualSlot(unFinishTemperingGlassInfoList, "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }

            BigStorageCageDetails details = bigStorageCageDetailsService.getOne(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).last("limit 1"));
            if (details != null) {
                TemperingGlassInfo temperingGlassInfo = new TemperingGlassInfo();
                BeanUtils.copyProperties(details, temperingGlassInfo);
                temperingGlassInfo.setState(-1);
                temperingGlassInfoService.save(temperingGlassInfo);
                computeOutGlassInfoByVirtualSlot(Arrays.asList(temperingGlassInfo), "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
                return;
            }
            String temperingEngineerId = redisUtil.getCacheObject("temperingEngineerId");
            if (StringUtils.isNotBlank(temperingEngineerId)) {
                TemperingGlassInfo temperingGlassInfo = temperingGlassInfoService.getOne(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getEngineerId, temperingEngineerId)
                        .orderByDesc(TemperingGlassInfo::getTemperingLayoutId).last("limit 1"));
                int temperingLayoutId = 1;
                if (temperingGlassInfo != null) {
                    temperingLayoutId = temperingGlassInfo.getTemperingLayoutId() + 1;
                }
                List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getEngineerId, temperingEngineerId).eq(GlassInfo::getTemperingLayoutId, temperingLayoutId));
                if (CollectionUtil.isEmpty(glassInfos)) {
                    //指定钢化工程执行完成，移除工程号
                    redisUtil.deleteObject("temperingEngineerId");
                    return;
                }
                List<TemperingLayoutDTO> temperingLayoutDTOS = bigStorageCageDetailsService.temperingIsAllByTemperingLayoutId(temperingEngineerId, temperingLayoutId);
                if (CollectionUtil.isNotEmpty(temperingLayoutDTOS)) {
                    List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                            .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                                    ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                                    "t.angle,t1.slot,t.engineer_id")
                            .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                            .eq(GlassInfo::getEngineerId, item.getEngineerId())
                            .eq(GlassInfo::getTemperingLayoutId, temperingLayoutId)
                            .eq(GlassInfo::getEngineerId, temperingEngineerId)
                            .orderByAsc(GlassInfo::getTemperingFeedSequence));
                    if (CollectionUtil.isNotEmpty(temperingGlassInfos)) {
                        temperingGlassInfoService.saveBatch(temperingGlassInfos);
@@ -390,10 +397,11 @@
                        log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                        return;
                    }
//                    }
                }
            }

        }

        //是否有人工下片任务   有直接出
        Integer artificialOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_ARTIFICIAL_OUT_TARGET_POSITION);
        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE);
@@ -409,6 +417,18 @@
        }
        //是否存在需要内部调度的格子:执行内部调度任务
        if (redisUtil.getCacheObject("dispatchSwitch")) {
            //获取进片协议内容，在进片有请求/进片任务执行中不执行调度任务
            S7DataDLPOne s7DataDLPOne = s7SerializerDLPOne.read(S7DataDLPOne.class);
            String requestInEntity = s7DataDLPOne.getRequestMes().toString();
            if ("1".equals(requestInEntity)) {
                log.info("当前收到进片请求，结束调度任务");
                return;
            }
            String mesReplyInEntity = s7DataDLPOne.getMesReply().toString();
            if ("1".equals(mesReplyInEntity)) {
                log.info("有正在执行的进片任务，结束调度任务");
                return;
            }
            //todo:获取笼内单格已经到齐的玻璃格子信息
            List<BigStorageRelationDTO> virtualList = bigStorageCageDetailsService.queryIsAllNeedDispatchVirtualSlot();
            if (CollectionUtil.isEmpty(virtualList)) {

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageDetailsMapper.xml

@@ -59,6 +59,31 @@
        <result column="is_damage" property="isDamage"/>
    </resultMap>

    <select id="temperingIsAllByTemperingLayoutId" resultMap="temperingLayoutDTO">
        SELECT T2.*
        FROM (
                 SELECT T.ENGINEER_ID,
                        T.TEMPERING_LAYOUT_ID,
                        COUNT(T.TEMPERING_FEED_SEQUENCE) AS COUNT
                 FROM GLASS_INFO T
                          LEFT JOIN DAMAGE T1
                                    ON T.ENGINEER_ID = T1.ENGINEER_ID
                                        AND T.GLASS_ID = T1.GLASS_ID
                                        AND T1.TYPE in (8, 9)
                 WHERE T1.GLASS_ID IS NULL
                 GROUP BY T.ENGINEER_ID,
                          T.TEMPERING_LAYOUT_ID
             ) T2
                 INNER JOIN (SELECT ENGINEER_ID, TEMPERING_LAYOUT_ID, COUNT(TEMPERING_FEED_SEQUENCE) AS COUNT
                             FROM BIG_STORAGE_CAGE_DETAILS
                             WHERE STATE = 100
                             GROUP BY ENGINEER_ID, TEMPERING_LAYOUT_ID) T3 ON T2.ENGINEER_ID = T3.ENGINEER_ID
            AND T2.TEMPERING_LAYOUT_ID = T3.TEMPERING_LAYOUT_ID
            AND T2.COUNT = T3.COUNT
        where T2.ENGINEER_ID = #{engineerId}
          AND T2.TEMPERING_LAYOUT_ID = #{temperingLayoutId}
    </select>

    <select id="temperingIsAll" resultMap="temperingLayoutDTO">
        SELECT T2.*
        FROM (

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageMapper.xml

@@ -17,69 +17,70 @@
        FROM BIG_STORAGE_CAGE T
                 LEFT JOIN (SELECT * FROM BIG_STORAGE_CAGE_DETAILS WHERE STATE NOT IN (101, 8, 9)) T1
                           ON T.SLOT = T1.SLOT
        WHERE T.MAX_THICKNESS >= #{thickness}
        WHERE T.MAX_THICKNESS &gt;= #{thickness}
          and t.MIN_THICKNESS &lt;= #{thickness}
          AND T.ENABLE_STATE = 1
        GROUP BY T.DEVICE_ID
        ORDER BY min(T.MAX_THICKNESS),
                 COUNT(DISTINCT T1.ENGINEER_ID), COUNT(DISTINCT T1.TEMPERING_LAYOUT_ID),
                 COUNT(DISTINCT T1.SLOT)
        HAVING count(t.slot) - COUNT(DISTINCT T1.slot) > 0
        ORDER BY COUNT(DISTINCT T1.ENGINEER_ID), count(t.slot) - COUNT(DISTINCT T1.slot) desc
    </select>

    <select id="selectBigStorageSummary" resultType="com.mes.bigstorage.entity.dto.BigStorageSummaryDTO">
        SELECT
            engineer_id as engineerId,
            count( tempering_layout_id ) AS countTemp,
            sum( countGlass ) AS countGlass,
            round( sum( area ), 2 ) as area,
            sum( fullTemp ) AS fullTemp,
            sum( countSlot ) AS countSlot,
            sum( countGlass )/ sum( countGlass1 )* 100 AS percent,
            thickness
        FROM
            (
                SELECT
                    bscd.engineer_id,
                    bscd.tempering_layout_id,
                    count(*) AS countGlass,
                    sum( bscd.width * bscd.height / 1000000 ) AS area,
                    IF
                        ( gi.countGlass1 = count(*), 1, 0 ) AS fullTemp,
                    count( DISTINCT bscd.slot ) AS countSlot,
                    countGlass1,
                    gi.thickness
                FROM
                    big_storage_cage_details bscd
                        INNER JOIN ( SELECT engineer_id, tempering_layout_id, count(*) AS countGlass1, thickness FROM glass_info GROUP BY engineer_id, tempering_layout_id ) gi ON bscd.engineer_id = gi.engineer_id
                        AND bscd.tempering_layout_id = gi.tempering_layout_id
                WHERE
                    bscd.state = 100
                GROUP BY
                    bscd.engineer_id,
                    bscd.tempering_layout_id
            ) AS cageSummary
        GROUP BY
            engineer_id
        ORDER BY
            percent DESC,
            countSlot DESC,
            thickness DESC
        SELECT engineer_id                              as engineerId,
               count(tempering_layout_id)               AS countTemp,
               sum(countGlass)                          AS countGlass,
               round(sum(area), 2)                      as area,
               sum(fullTemp)                            AS fullTemp,
               sum(countSlot)                           AS countSlot,
               sum(countGlass) / sum(countGlass1) * 100 AS percent,
               thickness
        FROM (
                 SELECT bscd.engineer_id,
                        bscd.tempering_layout_id,
                        count(*)                                AS countGlass,
                        sum(bscd.width * bscd.height / 1000000) AS area,
                        IF
                            (gi.countGlass1 = count(*), 1, 0)   AS fullTemp,
                        count(DISTINCT bscd.slot)               AS countSlot,
                        countGlass1,
                        gi.thickness
                 FROM big_storage_cage_details bscd
                          INNER JOIN (SELECT engineer_id, tempering_layout_id, count(*) AS countGlass1, thickness
                                      FROM glass_info
                                      GROUP BY engineer_id, tempering_layout_id) gi ON bscd.engineer_id = gi.engineer_id
                     AND bscd.tempering_layout_id = gi.tempering_layout_id
                 WHERE bscd.state = 100
                 GROUP BY bscd.engineer_id,
                          bscd.tempering_layout_id
             ) AS cageSummary
        GROUP BY engineer_id
        ORDER BY percent DESC,
                 countSlot DESC,
                 thickness DESC
    </select>
    <select id="queryPieChart" resultType="com.mes.largenscreen.entity.PieChartVO">
        SELECT
            round(sum( CASE WHEN e.station_cell = 5 THEN 1 ELSE 0 END ),2) as oneCompletedQuantity,
            round(sum( CASE WHEN e.station_cell = 5 THEN bscd.width*bscd.height/1000000 ELSE 0 END ),2) as oneCompletedArea,
            round(sum( CASE WHEN e.station_cell = 6 THEN 1 ELSE 0 END ),2) as twoCompletedQuantity,
            round(sum( CASE WHEN e.station_cell = 6 THEN bscd.width*bscd.height/1000000 ELSE 0 END ),2) as twoCompletedArea,
            round(sum( CASE WHEN e.station_cell = 5 and bscd.device_id is null THEN 1 ELSE 0 END ),2) as oneUncompletedQuantity,
            round(sum( CASE WHEN e.station_cell = 5 and bscd.device_id is null THEN gi.width*gi.height/1000000 ELSE 0 END ),2) as oneUncompletedArea,
            round(sum( CASE WHEN e.station_cell = 6 and bscd.device_id is null THEN 1 ELSE 0 END ),2) as twoUncompletedQuantity,
            round(sum( CASE WHEN e.station_cell = 6 and bscd.device_id is null THEN gi.width*gi.height/1000000 ELSE 0 END ),2) as twoUncompletedArea
        FROM
            glass_info gi
                left join big_storage_cage_details bscd ON gi.glass_id = bscd.glass_id
                left join engineering e on gi.engineer_id=e.engineer_id
        WHERE
            date(e.create_time) = date(now())
        SELECT round(sum(CASE WHEN e.station_cell = 5 THEN 1 ELSE 0 END), 2) as oneCompletedQuantity,
               round(sum(CASE WHEN e.station_cell = 5 THEN bscd.width * bscd.height / 1000000 ELSE 0 END),
                     2)                                                      as oneCompletedArea,
               round(sum(CASE WHEN e.station_cell = 6 THEN 1 ELSE 0 END), 2) as twoCompletedQuantity,
               round(sum(CASE WHEN e.station_cell = 6 THEN bscd.width * bscd.height / 1000000 ELSE 0 END),
                     2)                                                      as twoCompletedArea,
               round(sum(CASE WHEN e.station_cell = 5 and bscd.device_id is null THEN 1 ELSE 0 END),
                     2)                                                      as oneUncompletedQuantity,
               round(sum(CASE
                             WHEN e.station_cell = 5 and bscd.device_id is null THEN gi.width * gi.height / 1000000
                             ELSE 0 END),
                     2)                                                      as oneUncompletedArea,
               round(sum(CASE WHEN e.station_cell = 6 and bscd.device_id is null THEN 1 ELSE 0 END),
                     2)                                                      as twoUncompletedQuantity,
               round(sum(CASE
                             WHEN e.station_cell = 6 and bscd.device_id is null THEN gi.width * gi.height / 1000000
                             ELSE 0 END),
                     2)                                                      as twoUncompletedArea
        FROM glass_info gi
                 left join big_storage_cage_details bscd ON gi.glass_id = bscd.glass_id
                 left join engineering e on gi.engineer_id = e.engineer_id
        WHERE date(e.create_time) = date(now())
    </select>