Merge remote-tracking branch 'origin/master'

zhoushihao

2025-10-13 83f738105416c9b11e3b7c5246a0980e41b6650e

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java

@@ -712,137 +712,144 @@

    @Scheduled(fixedDelay = 1000)
    public void finishOutBigStorageTask() throws Exception {
        S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
        Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成出片任务");
            return;
        }
        //获取出片任务表
        List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
        if (CollectionUtil.isEmpty(outTaskList)) {
            log.info("当前大车无出片玻璃，结束完成出片任务");
            return;
        }
        List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
        if (CollectionUtil.isNotEmpty(unFinishTaskList)) {
            log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList);
            return;
        }
        Map<Integer, List<BigStorageCageTask>> taskMap = outTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState));
        int taskType = 0;
        if (Const.OUT_TARGET_POSITION_ALL.contains(outTaskList.get(0).getTargetSlot())) {
            taskType = Const.BIG_STORAGE_AFTER_OUT;
        } else {
            taskType = Const.BIG_STORAGE_AFTER_DISPATCH;
        }
        //按照任务状态修改大理片笼内的玻璃数据
//        重新计算大理片笼内的剩余尺寸
        Integer finalTaskType = taskType;
        taskMap.forEach((e1, v) -> {
            if (e1 == 2) {
                //进片完成
                log.info("3、获取出片已完成的玻璃信息id:{}", v);
                List<Integer> outSuccessGlassSlot = new ArrayList<>();
                if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                    outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                } else {
                    List<Integer> targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
                    List<Integer> startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                    outSuccessGlassSlot.addAll(targetSuccessGlassSlot);
                    outSuccessGlassSlot.addAll(startoutSuccessGlassSlot);
                }
                List<UpdateHollowBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
                    UpdateHollowBigStorageCageDTO storageCageDTO = new UpdateHollowBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                        storageCageDTO.setTargetSlot(e.getStartSlot());
                    } else {
                        storageCageDTO.setTargetSlot(e.getTargetSlot());
                    }
                    return storageCageDTO;
                }).collect(Collectors.toList());
                if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                    hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                } else {
                    hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                    //按照格子信息更新对应的设备id
                    List<Integer> slotList = storageCageDTOList.stream().map(UpdateHollowBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
                    hollowBigStorageCageDetailsService.updateDeviceIdBySlot(slotList);
                }
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", v);
                updateSlotRemainBySlots(outSuccessGlassSlot);
            } else if (e1 == 3) {
                //破损处理
                dealDamageOutTask(v);
            } else {
                //清空理片笼空数据
                noDealOutTask(v);
            }
        });

        for (BigStorageCageTask item : outTaskList) {
            //更新历史任务表中的任务状态
            hollowBigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<HollowBigStorageCageHistoryTask>()
                    .set(HollowBigStorageCageHistoryTask::getTaskState, item.getTaskState())
                    .eq(HollowBigStorageCageHistoryTask::getTaskType, taskType)
                    .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
            //更新中空小片表
            Integer taskState = item.getTaskState();
            if (taskState == 2) {
                hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                        .set(HollowGlassQueueInfo::getState, Const.TEMPERING_OUT).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
            } else if (taskState == 3) {
//                temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
                hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                        .set(HollowGlassQueueInfo::getState, Const.TEMPERING_DAMAGE).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));

            } else {
//                空执行
            }
        }
        try {
            //更新数量
            //按照玻璃id获取需要出片对列表中的数据
            if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                HollowGlassQueueInfo hollowGlassQueueInfo = hollowGlassQueueInfoService.getOne(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                        .eq(HollowGlassQueueInfo::getGlassId, outTaskList.get(0).getGlassId())
                        .orderByDesc(HollowGlassQueueInfo::getUpdateTime).last("limit 1"));
                List<HollowGlassQueueInfo> list = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                                .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassQueueInfo.getFlowCardId())
                                .eq(HollowGlassQueueInfo::getCell, hollowGlassQueueInfo.getCell())
//                        .eq(HollowGlassQueueInfo::getIsPair, 1)
                                .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
                );
                if (CollectionUtil.isEmpty(list)) {
//                任务更新为已完成
                    hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                            .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                            .eq("cell", hollowGlassQueueInfo.getCell())
                            .setSql("pair_quantity = total_pair_quantity")
                            .set("state", Const.HOLLOW_FLOW_CARD_SUCCESS)
                    );
            S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
            Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
            if (true != inkageEntity) {
                log.info("当前为非联机状态，结束完成出片任务");
                return;
            }
            //获取出片任务表
            List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
            if (CollectionUtil.isEmpty(outTaskList)) {
                log.info("当前大车无出片玻璃，结束完成出片任务");
                return;
            }
            log.info("中空理片笼出片完成任务:{}", outTaskList);
            log.info("中空理片笼出片汇报情况:{}", s7DataZKDLPTwo);
            List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(unFinishTaskList)) {
                log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList);
                return;
            }
            Map<Integer, List<BigStorageCageTask>> taskMap = outTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState));
            int taskType = 0;
            if (Const.OUT_TARGET_POSITION_ALL.contains(outTaskList.get(0).getTargetSlot())) {
                taskType = Const.BIG_STORAGE_AFTER_OUT;
            } else {
                taskType = Const.BIG_STORAGE_AFTER_DISPATCH;
            }
            //按照任务状态修改大理片笼内的玻璃数据
//        重新计算大理片笼内的剩余尺寸
            Integer finalTaskType = taskType;
            taskMap.forEach((e1, v) -> {
                if (e1 == 2) {
                    //进片完成
                    log.info("3、获取出片已完成的玻璃信息id:{}", v);
                    List<Integer> outSuccessGlassSlot = new ArrayList<>();
                    if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                        outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                    } else {
                        List<Integer> targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
                        List<Integer> startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                        outSuccessGlassSlot.addAll(targetSuccessGlassSlot);
                        outSuccessGlassSlot.addAll(startoutSuccessGlassSlot);
                    }
                    List<UpdateHollowBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
                        UpdateHollowBigStorageCageDTO storageCageDTO = new UpdateHollowBigStorageCageDTO();
                        storageCageDTO.setGlassId(e.getGlassId());
                        if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                            storageCageDTO.setTargetSlot(e.getStartSlot());
                        } else {
                            storageCageDTO.setTargetSlot(e.getTargetSlot());
                        }
                        return storageCageDTO;
                    }).collect(Collectors.toList());
                    if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                        hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                    } else {
                        hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                        //按照格子信息更新对应的设备id
                        List<Integer> slotList = storageCageDTOList.stream().map(UpdateHollowBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
                        hollowBigStorageCageDetailsService.updateDeviceIdBySlot(slotList);
                    }
                    log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", v);
                    updateSlotRemainBySlots(outSuccessGlassSlot);
                } else if (e1 == 3) {
                    //破损处理
                    dealDamageOutTask(v);
                } else {
//               计算剩余玻璃对数，用任务总队数减剩余对数
                    int remainCount = list.size() / hollowGlassQueueInfo.getTotalLayer();
                    hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                            .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                            .eq("cell", hollowGlassQueueInfo.getCell())
                            .setSql("pair_quantity = total_pair_quantity -" + remainCount)
                    );
                    //清空理片笼空数据
                    noDealOutTask(v);
                }
            });

            for (BigStorageCageTask item : outTaskList) {
                //更新历史任务表中的任务状态
                hollowBigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<HollowBigStorageCageHistoryTask>()
                        .set(HollowBigStorageCageHistoryTask::getTaskState, item.getTaskState())
                        .eq(HollowBigStorageCageHistoryTask::getTaskType, taskType)
                        .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
                //更新中空小片表
                Integer taskState = item.getTaskState();
                if (taskState == 2) {
                    hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                            .set(HollowGlassQueueInfo::getState, Const.TEMPERING_OUT).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
                } else if (taskState == 3) {
//                temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
                    hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                            .set(HollowGlassQueueInfo::getState, Const.TEMPERING_DAMAGE).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));

                } else {
//                空执行
                }
            }
        } catch (Exception e) {
            log.info("计算玻璃数量过程中出现错误，错误信息{}", e.getMessage());
        }
            try {
                //更新数量
                //按照玻璃id获取需要出片对列表中的数据
                if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                    HollowGlassQueueInfo hollowGlassQueueInfo = hollowGlassQueueInfoService.getOne(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                            .eq(HollowGlassQueueInfo::getGlassId, outTaskList.get(0).getGlassId())
                            .orderByDesc(HollowGlassQueueInfo::getUpdateTime).last("limit 1"));
                    List<HollowGlassQueueInfo> list = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                                    .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassQueueInfo.getFlowCardId())
                                    .eq(HollowGlassQueueInfo::getCell, hollowGlassQueueInfo.getCell())
//                        .eq(HollowGlassQueueInfo::getIsPair, 1)
                                    .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
                    );
                    if (CollectionUtil.isEmpty(list)) {
//                任务更新为已完成
                        hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                                .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                                .eq("cell", hollowGlassQueueInfo.getCell())
                                .setSql("pair_quantity = total_pair_quantity")
                                .set("state", Const.HOLLOW_FLOW_CARD_SUCCESS)
                        );
                    } else {
//               计算剩余玻璃对数，用任务总队数减剩余对数
                        int remainCount = list.size() / hollowGlassQueueInfo.getTotalLayer();
                        hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                                .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                                .eq("cell", hollowGlassQueueInfo.getCell())
                                .setSql("pair_quantity = total_pair_quantity -" + remainCount)
                        );
                    }
                }
            } catch (Exception e) {
                log.info("计算玻璃数量过程中出现错误，错误信息{}", e.getMessage());
            }

//       重置任务表数据
        resetOutTask();
        //清空启动状态
        //向opc发送启动信号
        s7DataZKDLPTwo = new S7DataZKDLPTwo();
        s7DataZKDLPTwo.setMesReply(0);
        s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
            resetOutTask();
            //清空启动状态
            //向opc发送启动信号
            s7DataZKDLPTwo = new S7DataZKDLPTwo();
            s7DataZKDLPTwo.setMesReply(0);
            s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
        } catch (Exception e) {
            log.info("中空理片笼出片汇报任务异常：{}", e);
        }

    }

    private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {