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

ZengTao

2025-03-28 f68d3c71819feb59e7a227a5d992b059b900916c

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

@@ -121,7 +121,7 @@
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();


//        d01Id="P24111102|1|13";
//        d01Id="P25010108|37|8";
//        d04ToMES="1";
//        d01ToMES="1";

@@ -134,6 +134,34 @@
            log.info("两条线卧转立均在执行任务，结束本次扫描进卧转立任务");
            return;
        }
//        if (REQUEST_WORD.equals(d01ToMES)) {
//            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
//                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
//                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
//                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
//                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
//                            .eq(BigStorageCageFeedTask::getGlassId, d01Id)
//            );
//            if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks)) {
//                S7object.getinstance().plccontrol.writeWord(mesD01Address, 1);
//            }
//            log.info("{}线再次发送进片启动", Const.A09_OUT_TARGET_POSITION);
//            return;
//        }
//        if (REQUEST_WORD.equals(d04ToMES)) {
//            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
//                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
//                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
//                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
//                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
//                            .eq(BigStorageCageFeedTask::getGlassId, d01Id)
//            );
//            if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks)) {
//                S7object.getinstance().plccontrol.writeWord(mesD04Address, 1);
//            }
//            log.info("{}线再次发送进片启动", Const.A10_OUT_TARGET_POSITION);
//            return;
//        }
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃:  状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， （02玻璃id为空或者卧转立未启动）
        if (!REQUEST_WORD.equals(mesD01Value) && REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
@@ -270,7 +298,8 @@
        //两条先均可执行进片任务，判断两条线是否进片请求是否都为空
        if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) {
            //比较最早一片任务的版图id及版序 求出卧转立的线路
            Integer line = getStartLine();
//            Integer line = getStartLine();
            Integer line = lineList.get(0);
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(line);
            Date endDate = new Date();
@@ -304,7 +333,7 @@
        log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
    }

    @Scheduled(fixedDelay = 10000)
    @Scheduled(fixedDelay = 5000)
    public void plcToHomeEdgOutTask() {
        Date startDate = new Date();
        log.info("大理片笼出片任务开始执行时间：{}", startDate);
@@ -393,7 +422,7 @@
                                            + 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.getSlot()));
                    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());
@@ -403,126 +432,41 @@
                                        .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) {
                                        bigStorageCageOutTaskService.save(new BigStorageCageOutTask(bigStorageCageDetails.getGlassId(), bigStorageCageDetails.getSlot(), maxSlot,
                                                bigStorageCageDetails.getWidth() * 10, bigStorageCageDetails.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
                        List<BigStorageCageDetails> overSizeGlass = bigStorageCageDetailsList.stream().filter(
                                t -> Math.min(t.getWidth(), t.getHeight()) > 2500
                        ).collect(Collectors.toList());
                        if (CollectionUtils.isEmpty(overSizeGlass)) {
                            //当一格玻璃都到齐时
                            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) {
                                            bigStorageCageOutTaskService.save(new BigStorageCageOutTask(bigStorageCageDetails.getGlassId(), bigStorageCageDetails.getSlot(), maxSlot,
                                                    bigStorageCageDetails.getWidth() * 10, bigStorageCageDetails.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));

                                        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                                .set(BigStorageCageBaseInfo::getSlot, maxSlot).eq(BigStorageCageDetails::getGlassId, bigStorageCageDetails.getGlassId())
                                                .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT));
                                        //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                                        // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
                                        List<Integer> updateSlots = new ArrayList<>();
                                        updateSlots.add(bigStorageCageDetails.getSlot());
                                        updateSlotRemainBySlots(updateSlots);
                                            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                                    .set(BigStorageCageBaseInfo::getSlot, maxSlot).eq(BigStorageCageDetails::getGlassId, bigStorageCageDetails.getGlassId())
                                                    .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT));
                                            //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                                            // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
                                        }
                                    }
                                    break loop;
                                }
                                break loop;
                            }
                        }
                    }
//                    List<GlassInfo> glassInfoList = glassInfoService.list(
//                            new LambdaQueryWrapper<GlassInfo>()
//                                    .eq(GlassInfo::getTemperingLayoutId, temperingOccupySlot.getTemperingLayoutId())
//                                    .eq(GlassInfo::getEngineerId, temperingOccupySlot.getEngineerId())
//                                    .notInSql(GlassInfo::getGlassId, "select glass_id from damage where type=8 and engineer_id='"
//                                            + temperingOccupySlot.getEngineerId() + "' and tempering_layout_id = '" + temperingOccupySlot.getTemperingLayoutId() + "'")
//                    );
//                    List<BigStorageCageDetails> glassInfoLists = new ArrayList<>();
//                    glassInfoList.forEach(glassInfo -> {
//                        BigStorageCageDetails details = new BigStorageCageDetails();
//                        BeanUtils.copyProperties(glassInfo, details);
//                        details.setSlot(1);
//                        glassInfoLists.add(details);
//                    });
//                    List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsService.list(
//                            new LambdaQueryWrapper<BigStorageCageDetails>()
//                                    .eq(BigStorageCageDetails::getEngineerId, temperingOccupySlot.getEngineerId())
//                                    .eq(BigStorageCageDetails::getTemperingLayoutId, temperingOccupySlot.getTemperingLayoutId())
//                                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
//                                    .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence)
//                    );
////                    if (glassInfoLists.size() == bigStorageCageDetailsList.size()) {
//                    computeOutMoreGlassInfo(glassInfoLists, Boolean.TRUE, 2);
//                    computeOutMoreGlassInfo(bigStorageCageDetailsList, Boolean.TRUE, 3);
//                    int allTrainNumber = allTask.stream()
//                            .map(BigStorageCageOutTask::getTrainNumber)
//                            .collect(Collectors.toSet())
//                            .size();
//                    int allTrainSlot = allTask.stream()
//                            .map(BigStorageCageOutTask::getStartSlot)
//                            .collect(Collectors.toSet())
//                            .size();
//                    int notallTrainNumber = notAllTask.stream()
//                            .map(BigStorageCageOutTask::getTrainNumber)
//                            .collect(Collectors.toSet())
//                            .size();
//                    int notallTrainSlot = notAllTask.stream()
//                            .map(BigStorageCageOutTask::getStartSlot)
//                            .collect(Collectors.toSet())
//                            .size();
////                        if (allTrainNumber < notallTrainNumber || (allTrainNumber == notallTrainNumber && allTrainSlot < notallTrainSlot)) {
//                    List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
//                    for (int i = 0; i < slotSequenceList.size() - 1; i++) {
//                        SlotSequenceDTO first = slotSequenceList.get(i);
//                        SlotSequenceDTO second = slotSequenceList.get(i + 1);
//                        int slotWidth = first.getRemainWidth() - glassGap;
//                        List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
//                                .eq(BigStorageCageDetails::getSlot, second.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
//                                .orderBy(Boolean.TRUE, !sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
//                        if (CollectionUtils.isNotEmpty(list)) {
//                            List<BigStorageCageOutTask> outTasks = new ArrayList<>();
//                            int serialNumber = 1;
//                            for (BigStorageCageDetails item : list) {
//                                int maxlength = (int) Math.max(item.getWidth(), item.getHeight());
//                                if (slotWidth > maxlength) {
//                                    slotWidth = slotWidth - maxlength - glassGap;
//                                    outTasks.add(new BigStorageCageOutTask(item.getGlassId(), second.getSlot(), first.getSlot(),
//                                            item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
//                                } else {
//                                    outTasks.add(new BigStorageCageOutTask(item.getGlassId(), second.getSlot(), second.getSlot(),
//                                            item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
//                                }
//                            }
//                            List<String> glassList = outTasks.stream()
//                                    .filter(item -> !item.getStartSlot().equals(item.getEndSlot()))
//                                    .map(BigStorageCageOutTask::getGlassId)
//                                    .collect(Collectors.toList());
//                            if (glassList.size() > 0) {
//                                //新增调度任务
//                                bigStorageCageOutTaskService.saveBatch(outTasks);
//                                //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
////                                    List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
//
//                                bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
//                                        .set(BigStorageCageBaseInfo::getSlot, first.getSlot()).in(BigStorageCageDetails::getGlassId, glassList)
//                                        .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT));
//
//                                //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
//                                // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
//                                updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
//                                break loop;
//                            }
//
//                        }
//                    }
//                        }
//                    }
                }
//            //向plc写入确认字
//            int returnData = 0;
@@ -673,7 +617,10 @@
            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
//                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW)
                    .and(e -> e.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).or()
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN))
                    .in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
            //将破损信息新增入破损表
            List<Integer> slotList = new ArrayList<>();
            for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) {
@@ -834,7 +781,7 @@
        }
        if (CollectionUtils.isEmpty(glassIds1)) {
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
            log.info("{}线修改玻璃状态为3", Const.A09_OUT_TARGET_POSITION);
            log.info("{}线修改玻璃{}状态为3", Const.A09_OUT_TARGET_POSITION, glassIds1);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
@@ -846,7 +793,7 @@
        }
        if (CollectionUtils.isEmpty(glassIds2)) {
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
            log.info("{}线修改玻璃状态为3", Const.A10_OUT_TARGET_POSITION);
            log.info("{}线修改玻璃{}状态为3", Const.A10_OUT_TARGET_POSITION, glassIds2);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
@@ -867,9 +814,20 @@
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                            .eq(BigStorageCageFeedTask::getTargetSlot, 0)
            );
            if(CollectionUtils.isNotEmpty(bigStorageCageFeedTasks)){
                log.info("获取到的进片任务信息{}", bigStorageCageFeedTasks);
            if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks)) {
                log.info("计算目标格子发送任务{}", bigStorageCageFeedTasks);
                computeTargetByLineCar(bigStorageCageFeedTasks.get(0).getLine(), glassIdsCar);
            } else {
                log.info("再次发送进片任务{}", bigStorageCageFeedTasks);
                List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskService.list(
                        new LambdaQueryWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, glassIdsCar)
                                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR)
                                .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                );
                if (CollectionUtils.isNotEmpty(bigStorageCageFeedTaskList)) {
                    sendTaskListToPLCCar(bigStorageCageFeedTaskList);
                }
            }
        }

@@ -880,8 +838,8 @@
     * 按照玻璃id判断玻璃状态及卧转立是否可直接启动
     */
    public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {
        //预排格子
        computeSlot(glassId);
//        预排格子
//        computeSlot(glassId);
        //判断此玻璃是在笼内或已生成进片任务
        BigStorageCageFeedTask bigStorageCageFeedTask = bigStorageCageFeedTaskService.getOne(
                new LambdaQueryWrapper<BigStorageCageFeedTask>()
@@ -1005,7 +963,7 @@
                new LambdaQueryWrapper<GlassInfo>()
                        .eq(GlassInfo::getGlassId, glassId)
        );
        if (glassInfo.getSlot() == null) {
        if (glassInfo.getTargetSlot() == null) {
            List<GlassInfo> glassInfos = glassInfoService.list(
                    new LambdaQueryWrapper<GlassInfo>()
                            .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
@@ -1025,7 +983,7 @@
                glassInfoService.update(
                        new LambdaUpdateWrapper<GlassInfo>()
                                .eq(GlassInfo::getGlassId, bigStorageCageOutTask.getGlassId())
                                .set(GlassInfo::getSlot, bigStorageCageOutTask.getTrainNumber())
                                .set(GlassInfo::getTargetSlot, bigStorageCageOutTask.getTrainNumber())
                );
            }
        }
@@ -1043,11 +1001,12 @@
        bigStorageCageFeedTask.setWidth(width);
        bigStorageCageFeedTask.setHeight(height);
        bigStorageCageFeedTask.setCreateTime(new Date());
        bigStorageCageFeedTask.setTargetSlot(0);
        //删除理片笼表拿走/破损数据数据
        damageService.deleteByGlassId(glassId);
        Damage damage = new Damage();
        damage.setGlassId(glassId);
        damage.setWorkingProcedure("钢化");
        damage.setWorkingProcedure("磨边");
        damage.setLine(line);
        damage.setType(1);
        damage.setRemark("进大理片");
@@ -1123,11 +1082,11 @@
            if (info == null) {
                continue;
            }
            if(info.getSlot()==null){
            if (info.getTargetSlot() == null) {
                computeSlot(info.getGlassId());
                info=glassInfoService.getOne(
                info = glassInfoService.getOne(
                        new LambdaQueryWrapper<GlassInfo>()
                        .eq(GlassInfo::getGlassId,info.getGlassId())
                                .eq(GlassInfo::getGlassId, info.getGlassId())
                );
            }
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
@@ -1337,11 +1296,21 @@
                    maxX = e.getXCoordinate();
                    slot = e.getSlot();
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                }
            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
                if(serialNumber <= outCarMaxSize && remainWidth > maxLength){
                    remainWidth = remainWidth - maxLength - glassGap;
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                }else{
                    remainWidth = carWidth - maxLength - glassGap;
                    trainNumber = trainNumber + 1;
                    serialNumber = 1;
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                }

            }
        }
        if (isTask == 2) {
@@ -1353,11 +1322,7 @@
        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
        for (BigStorageCageOutTask bigStorageCageOutTask : bigStorageCageOutTaskList
        ) {
            bigStorageCageOutTaskService.save(bigStorageCageOutTask);
        }
//        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
        log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
@@ -1405,9 +1370,21 @@
        if (sitToUpRemainWidth.getGlassCount() == 0) {
            return Boolean.FALSE;
        }
        List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isNotEmpty(lineList)) {
            Integer lineFirst = lineList.get(0);
            if (line == lineFirst) {
                return Boolean.TRUE;
            } else {
                return Boolean.FALSE;
            }
        } else {
            return Boolean.FALSE;
        }

        //获取玻璃信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
        return sitToUpRemainWidth.getWidth() < Math.max(glassInfo.getWidth(), glassInfo.getHeight());
//        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
//        return sitToUpRemainWidth.getWidth() < Math.max(glassInfo.getWidth(), glassInfo.getHeight());
    }

    public String queryAndChangeGlass(String glassId) {
@@ -1422,8 +1399,9 @@
                .eq(GlassInfo::getTotalLayer, glassInfo.getTotalLayer())
                .eq(GlassInfo::getLayer, glassInfo.getLayer())
                .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
                .eq(GlassInfo::getMarkIcon, glassInfo.getMarkIcon())
                .notInSql(GlassInfo::getGlassId, "select distinct glass_id from big_storage_cage_details " +
                        "where state!=101 and engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight())
                        "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight())
                .orderByAsc(GlassInfo::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                .last("Limit 1");