派生自 YiWuProject
hangzhoumesParent/moduleService/howllowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java
New file @@ -0,0 +1,768 @@ package com.mes.job; import cn.hutool.core.collection.CollectionUtil; import cn.hutool.core.lang.Assert; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; import com.kangaroohy.milo.model.ReadWriteEntity; import com.kangaroohy.milo.service.MiloService; import com.mes.base.entity.HollowBigStorageCageBaseInfo; import com.mes.bigstoragecagetask.entity.BigStorageCageTask; import com.mes.bigstoragecagetask.service.BigStorageCageTaskService; import com.mes.common.config.Const; import com.mes.damage.entity.Damage; import com.mes.damage.service.DamageService; import com.mes.glassinfo.entity.GlassInfo; import com.mes.glassinfo.service.GlassInfoService; import com.mes.hollow.entity.HollowBigStorageCage; import com.mes.hollow.entity.HollowBigStorageCageDetails; import com.mes.hollow.entity.HollowGlassOutRelationInfo; import com.mes.hollow.entity.HollowGlassRelationInfo; import com.mes.hollow.entity.dto.*; import com.mes.hollow.service.HollowBigStorageCageDetailsService; import com.mes.hollow.service.HollowBigStorageCageService; import com.mes.hollow.service.HollowGlassOutRelationInfoService; import com.mes.hollow.service.HollowGlassRelationInfoService; import com.mes.hollowqueue.entity.HollowGlassQueueInfo; import com.mes.hollowqueue.service.HollowGlassQueueInfoService; import com.mes.hollowtask.entity.HollowBigStorageCageHistoryTask; import com.mes.hollowtask.service.HollowBigStorageCageHistoryTaskService; import com.mes.temperingglass.entity.TemperingGlassInfo; 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.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.util.*; import java.util.stream.Collectors; /** * @author SNG-015 */ @Component @Slf4j public class OpcPlcStorageCageHollowTask { @Resource private HollowBigStorageCageService hollowBigStorageCageService; @Resource private HollowBigStorageCageHistoryTaskService hollowBigStorageCageHistoryTaskService; @Resource private HollowGlassRelationInfoService hollowGlassRelationInfoService; @Resource private HollowBigStorageCageDetailsService hollowBigStorageCageDetailsService; @Resource private DamageService damageService; @Resource private GlassInfoService glassInfoService; @Resource private BigStorageCageTaskService bigStorageCageTaskService; @Resource private TemperingGlassInfoService temperingGlassInfoService; @Resource private HollowGlassQueueInfoService hollowGlassQueueInfoService; @Resource private HollowGlassOutRelationInfoService hollowGlassOutRelationInfoService; private static final String BIG_STORAGE_CAGE_IN_TWO_TASK = "big_storage_cage_in_two_task"; private static final String BIG_STORAGE_CAGE_OUT_TWO_TASK = "big_storage_cage_out_two_task"; @Autowired(required = false) MiloService miloService; @Resource private RedisUtil redisUtil; @Value("${mes.slotWidth}") private Integer slotWidth; @Value("${mes.glassGap}") private Integer glassGap; @Value("${mes.carWidth}") private Integer carWidth; @Value("${mes.outCarMaxSize}") private Integer outCarMaxSize; @Scheduled(fixedDelay = 1000) public void inBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束进片任务"); return; } ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2A.DLP2A.RequestMes"); if (!"1".equals(requestEntity.getValue() + "")) { log.info("当前未收到进片请求，结束进片任务"); return; } ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP2A.DLP2A.MesReply"); if ("1".equals(mesReplyEntity.getValue() + "")) { log.info("有正在执行的任务，结束进片任务"); return; } List<BigStorageCageTask> inTaskList = new ArrayList(); ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM1"); List<String> glassIdList = new ArrayList<>(); for (int i = 1; i <= 6; i++) { ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i); if (null != requestWord.getValue()) { BigStorageCageTask task = new BigStorageCageTask(); task.setGlassId(requestWord.getValue() + ""); task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + "")); inTaskList.add(task); glassIdList.add(requestWord.getValue() + ""); continue; } } if (CollectionUtil.isEmpty(inTaskList)) { log.info("当前大车无进片玻璃，结束进片任务"); return; } log.info("获取任务的玻璃id：{}", glassIdList); Map<String, Long> glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting())); for (Map.Entry<String, Long> entry : glassCountMap.entrySet()) { if (entry.getValue() > 1) { log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey()); //todo:向plc发送报警 return; } } List<HollowBigStorageCageDetails> detailsList = hollowBigStorageCageDetailsService.list(new LambdaQueryWrapper<HollowBigStorageCageDetails>().in(HollowBigStorageCageDetails::getGlassId, glassIdList) .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL)); if (CollectionUtil.isNotEmpty(detailsList)) { log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList); //todo:向plc发送报警 return; } List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList)); if (glassInfoList.size() != inTaskList.size()) { log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size()); //todo:向plc发送报警 return; } //修改钢化任务表中的状态 temperingGlassInfoService.update(new LambdaUpdateWrapper<TemperingGlassInfo>() .set(TemperingGlassInfo::getState, Const.TEMPERING_END).in(TemperingGlassInfo::getGlassId, glassIdList)); Map<String, List<GlassInfo>> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId)); //计算目标格子 List<HollowBigStorageCageHistoryTask> historyTasks = new ArrayList<>(); for (BigStorageCageTask task : inTaskList) { GlassInfo info = glassListMap.get(task.getGlassId()).get(0); HollowBigStorageDTO bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(), info.getWidth(), info.getHeight(), info.getTotalLayer(), info.getLayer()); // 临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸） hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>() .set(HollowBigStorageCage::getRemainWidth, bigStorageDTO.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap) .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot())); task.setTargetSlot(bigStorageDTO.getSlot()); task.setGlassId(info.getGlassId()); bigStorageCageTaskService.updateTaskMessage(BIG_STORAGE_CAGE_IN_TWO_TASK, task); //存放历史任务 HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask(); BeanUtils.copyProperties(task, historyTask); historyTask.setTaskType(Const.BIG_STORAGE_AFTER_IN); historyTask.setGlassCount(glassInfoList.size()); historyTask.setTaskState(Const.ENGINEERING_NEW); historyTasks.add(historyTask); //存放详情数据 HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails(); BeanUtils.copyProperties(bigStorageDTO, cageDetails); BeanUtils.copyProperties(info, cageDetails); cageDetails.setState(Const.GLASS_STATE_NEW); cageDetails.setSequence(bigStorageDTO.getSlotSequence()); cageDetails.setGap(glassGap); cageDetails.setId(null); hollowBigStorageCageDetailsService.save(cageDetails); hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>() .set(HollowGlassRelationInfo::getGlassId, cageDetails.getGlassId()) .set(HollowGlassRelationInfo::getTemperingLayoutId, cageDetails.getTemperingLayoutId()) .set(HollowGlassRelationInfo::getTemperingFeedSequence, cageDetails.getTemperingFeedSequence()) .set(HollowGlassRelationInfo::getEngineerId, cageDetails.getEngineerId()) .eq(HollowGlassRelationInfo::getFlowCardId, bigStorageDTO.getFlowCardId()) .eq(HollowGlassRelationInfo::getLayer, bigStorageDTO.getLayer()) .eq(HollowGlassRelationInfo::getVirtualSlot, bigStorageDTO.getVirtualSlot()) .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence()) .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence()) ); } //历史数据入库 hollowBigStorageCageHistoryTaskService.saveBatch(historyTasks); //向opc发送启动信号 List<ReadWriteEntity> list = new ArrayList<>(); for (int i = 1; i <= inTaskList.size(); i++) { list.add(generateReadWriteEntity("DLP2A.DLP2A.TO" + i, inTaskList.get(i - 1).getTargetSlot())); } list.add(generateReadWriteEntity("DLP2A.DLP2A.MesReply", 1)); miloService.writeToOpcWord(list); } @Scheduled(fixedDelay = 1000) public void outBigStorageTask() throws Exception { Date startDate = new Date(); ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束进片任务"); return; } ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2B.DLP2B.RequestMes"); if (!"1".equals(requestEntity.getValue() + "")) { log.info("当前未收到出片请求，结束出片任务"); return; } //获取出片任务表 List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK); if (CollectionUtil.isNotEmpty(outTaskList)) { log.info("有正在执行的出片任务，结束本次出片任务"); return; } //获取空闲且领取任务的数据信息，没有任务直接走玻璃调度 ReadWriteEntity oneEntity = miloService.readFromOpcUa("DLP2B.DLP2B.outOneRequest"); ReadWriteEntity twoEntity = miloService.readFromOpcUa("DLP2B.DLP2B.outTwoRequest"); ReadWriteEntity threeEntity = miloService.readFromOpcUa("DLP2B.DLP2B.outThreeRequest"); int cell = -1; HollowGlassOutRelationInfo hollowGlassOutRelationInfo = null; if ("1".equals(oneEntity.getValue() + "")) { cell = 930; hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>() .eq(HollowGlassOutRelationInfo::getCell, cell) .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START) ); } if (1 == 1 || null == hollowGlassOutRelationInfo && "1".equals(twoEntity.getValue() + "")) { cell = 931; hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>() .eq(HollowGlassOutRelationInfo::getCell, cell) .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START) ); } if (null == hollowGlassOutRelationInfo && "1".equals(threeEntity.getValue() + "")) { cell = 932; hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>() .eq(HollowGlassOutRelationInfo::getCell, cell) .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START) ); } if (null != hollowGlassOutRelationInfo) { //是否允许中空 //是否有正在中空的玻璃:中空小片表筛选未出笼的玻璃信息 // 获取当前中空任务未完成出片的玻璃信息 List<HollowGlassQueueInfo> unFinishHollowQueueList = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>() .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassOutRelationInfo.getFlowCardId()) .eq(HollowGlassQueueInfo::getCell, cell) .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW) .orderByAsc(HollowGlassQueueInfo::getHollowSequence)); if (CollectionUtil.isNotEmpty(unFinishHollowQueueList)) { log.info("有正在出片的中空任务"); Integer isPair = unFinishHollowQueueList.get(0).getIsPair(); hollowOutGlassByIsPair(unFinishHollowQueueList, hollowGlassOutRelationInfo.getCell(), isPair, hollowGlassOutRelationInfo.getTotalLayer()); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } else { //将中空任务状态改为已完成 hollowGlassOutRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassOutRelationInfo>() .eq(HollowGlassOutRelationInfo::getFlowCardId, hollowGlassOutRelationInfo.getFlowCardId()) .eq(HollowGlassOutRelationInfo::getCell, hollowGlassOutRelationInfo.getCell()) .set(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_SUCCESS)); } if (redisUtil.getCacheObject("hollowSwitch")) { List<HollowGlassOutRelationInfo> HollowGlassOutRelationInfoList = hollowGlassOutRelationInfoService .list(new LambdaQueryWrapper<HollowGlassOutRelationInfo>() .eq(HollowGlassOutRelationInfo::getCell, cell) .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_NEW)); for (HollowGlassOutRelationInfo e : HollowGlassOutRelationInfoList) { //中空优先：获取理片笼 玻璃小片 破损表 数量 判断笼内版图是否到齐 List<FlowCardGlassInfoDTO> flowCardGlassInfoDTO = hollowBigStorageCageDetailsService.hollowIsAll(e.getFlowCardId(), e.getTotalLayer(), Boolean.TRUE); if (CollectionUtil.isNotEmpty(flowCardGlassInfoDTO)) { //玻璃到齐包括已出片的 //到齐，将玻璃小片数据存入中空小片表，逻辑生成出片任务 结束 for (FlowCardGlassInfoDTO item : flowCardGlassInfoDTO) { List<HollowBigStorageCageDetails> hollowBigStorageCageDetailsList = hollowBigStorageCageDetailsService.queryOutGlassList(item.getFlowCardId(), cell); int finalCell = cell; List<HollowGlassQueueInfo> hollowQueues = hollowBigStorageCageDetailsList.stream().map(queue -> { HollowGlassQueueInfo queueInfo = new HollowGlassQueueInfo(); BeanUtils.copyProperties(queue, queueInfo); queueInfo.setState(Const.TEMPERING_NEW); queueInfo.setCell(finalCell); return queueInfo; }).collect(Collectors.toList()); if (CollectionUtil.isNotEmpty(hollowQueues)) { hollowGlassQueueInfoService.saveBatch(hollowQueues); Integer isPair = hollowQueues.get(0).getIsPair(); hollowOutGlassByIsPair(hollowQueues, cell, isPair, e.getTotalLayer()); //将中空任务状态改为开始 hollowGlassOutRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassOutRelationInfo>() .eq(HollowGlassOutRelationInfo::getFlowCardId, e.getFlowCardId()) .eq(HollowGlassOutRelationInfo::getCell, cell) .set(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } } } } } } // redisUtil.setCacheObject("dispatchHollowSwitch",true); //是否存在需要内部调度的格子:执行内部调度任务 if (redisUtil.getCacheObject("dispatchHollowSwitch")) { //todo:获取笼内单格已经到齐的玻璃格子信息 List<FlowCardVirtualSlotDTO> virtualList = hollowBigStorageCageDetailsService.queryIsAllNeedDispatchVirtualSlot(); if (CollectionUtil.isEmpty(virtualList)) { log.info("没有需要调度的格子"); return; } List<HollowBigStorageCageDetails> list = new ArrayList<>(); loop: for (FlowCardVirtualSlotDTO dto : virtualList) { List<BigStorageSequenceDTO> sequenceDTOList = hollowBigStorageCageDetailsService.queryNeedDispatchSlot(dto); if (CollectionUtil.isEmpty(sequenceDTOList) || sequenceDTOList.size() == 1) { continue; } int sequence = -1; int startSlot = -1; for (BigStorageSequenceDTO item : sequenceDTOList) { if (item.getMinSequence() == sequence + 1) { //生成调度任务 int targetSlot = item.getSlot(); list = hollowBigStorageCageDetailsService.list(new LambdaQueryWrapper<HollowBigStorageCageDetails>() .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN).eq(HollowBigStorageCageDetails::getSlot, startSlot)); hollowOutGlassByIsPair(list, targetSlot, 0, 0); List<Integer> slotList = new ArrayList<>(); slotList.add(targetSlot); updateSlotRemainBySlots(slotList); break loop; } sequence = item.getMaxSequence(); startSlot = item.getSlot(); } } } Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } @Scheduled(fixedDelay = 1000) public void finishInBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束完成进片任务"); return; } //获取进片任务表 List<BigStorageCageTask> inTaskList = new ArrayList(); List<String> glassIdList = new ArrayList<>(); ReadWriteEntity toWord = miloService.readFromOpcUa("DLP2A.DLP2A.TO1"); if ("0".equals(toWord.getValue() + "")) { log.info("完成任务已执行，结束本次完成进片任务"); return; } for (int i = 1; i <= 6; i++) { ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i); ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP2A.DLP2A.STATE" + i); ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.TO" + i); ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM" + i); if (null != requestWord.getValue()) { BigStorageCageTask task = new BigStorageCageTask(); task.setGlassId(requestWord.getValue() + ""); task.setTargetSlot(Integer.parseInt(toOpcUa.getValue() + "")); task.setTaskState(Integer.parseInt(statetWord.getValue() + "")); task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + "")); inTaskList.add(task); glassIdList.add(requestWord.getValue() + ""); continue; } } if (CollectionUtil.isEmpty(inTaskList)) { log.info("当前大车无进片玻璃，结束完成进片任务"); return; } List<BigStorageCageTask> unFinishTaskList = inTaskList.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 = inTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState)); //按照任务状态修改大理片笼内的玻璃数据 // 重新计算大理片笼内的剩余尺寸 taskMap.forEach((e1, v) -> { if (e1 == 2) { //进片完成 log.info("3、获取进片已完成的玻璃信息id:{}", v); List<Integer> inSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList()); List<UpdateHollowBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> { UpdateHollowBigStorageCageDTO storageCageDTO = new UpdateHollowBigStorageCageDTO(); BeanUtils.copyProperties(e, storageCageDTO); return storageCageDTO; }).collect(Collectors.toList()); hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN); log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", v); updateSlotRemainBySlots(inSuccessGlassSlot); } else if (e1 == 3) { //破损处理 dealDamageInTask(v); } else { //清空理片笼空数据 noDealInTask(v); } }); for (BigStorageCageTask item : inTaskList) { //更新历史任务表中的任务状态 hollowBigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<HollowBigStorageCageHistoryTask>() .set(HollowBigStorageCageHistoryTask::getTaskState, item.getTaskState()) .eq(HollowBigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_AFTER_IN) .eq(HollowBigStorageCageHistoryTask::getTargetSlot, item.getTargetSlot()) .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId())); item.setTargetSlot(0); //清空任务表数据 bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", item); } //清空启动状态 //向opc发送启动信号 //向opc发送启动信号 List<ReadWriteEntity> list = new ArrayList<>(); for (int i = 1; i <= 6; i++) { list.add(generateReadWriteEntity("DLP2A.DLP2A.TO" + i, 0)); } list.add(generateReadWriteEntity("DLP2A.DLP2A.MesReply", 0)); miloService.writeToOpcWord(list); } @Scheduled(fixedDelay = 1000) public void finishOutBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束完成出片任务"); return; } //获取进片任务表 List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK); 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); } 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 { // 空执行 } } // 重置任务表数据 bigStorageCageTaskService.updateOutTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK); //清空启动状态 //向opc发送启动信号 miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 0)); } private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 hollowBigStorageCageDetailsService.remove(new LambdaQueryWrapper<HollowBigStorageCageDetails>() .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(HollowBigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List<Integer> slotList = new ArrayList<>(); for (BigStorageCageTask item : damageTaskList) { Damage damage = new Damage(); damage.setGlassId(item.getGlassId()); damage.setLine(item.getStartSlot()); damage.setWorkingProcedure("磨边"); damage.setRemark("进笼前卧转立"); damage.setStatus(1); damage.setType(item.getTaskState()); damageService.insertDamage(damage); slotList.add(item.getTargetSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("进片任务-破损任务执行完成"); } private void dealDamageOutTask(List<BigStorageCageTask> damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 hollowBigStorageCageDetailsService.remove(new LambdaQueryWrapper<HollowBigStorageCageDetails>() .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO) .in(HollowBigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List<Integer> slotList = new ArrayList<>(); for (BigStorageCageTask item : damageTaskList) { Damage damage = new Damage(); damage.setGlassId(item.getGlassId()); damage.setLine(item.getStartSlot()); damage.setWorkingProcedure("中空前"); damage.setRemark("进笼后卧转立"); damage.setStatus(1); damage.setType(item.getTaskState()); damageService.insertDamage(damage); slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("出片任务-破损任务执行完成"); } private void noDealInTask(List<BigStorageCageTask> noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); //移除理片笼详情表未执行任务的空记录信息 hollowBigStorageCageDetailsService.remove(new LambdaQueryWrapper<HollowBigStorageCageDetails>() .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(HollowBigStorageCageDetails::getGlassId, noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //记录格子号，按格子号更新剩余尺寸 List<Integer> slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("进片任务-无动作执行完成"); } private void noDealOutTask(List<BigStorageCageTask> noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); if (Const.OUT_TARGET_POSITION_ALL.contains(noDealTaskList.get(0).getTargetSlot())) { //出片任务:将出片中状态恢复为在笼内 List<String> glassList = noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>() .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN) .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .in(HollowBigStorageCageDetails::getGlassId, glassList)); } else { //调度任务：将调度中状态改为在笼内，格子号恢复为调度前的格子 for (BigStorageCageTask item : noDealTaskList) { hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>() .set(HollowBigStorageCageDetails::getSlot, item.getStartSlot()) .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN) .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .eq(HollowBigStorageCageDetails::getGlassId, item.getGlassId())); } } //将破损信息新增入破损表 List<Integer> slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("出片任务-无动作执行完成"); } private <T extends HollowBigStorageCageBaseInfo> Boolean hollowOutGlassByIsPair(List<T> list, int targetSlot, int isPair, int totalLayer) { List<T> resultList = new ArrayList<>(); int taskType = Const.BIG_STORAGE_AFTER_OUT; int taskState = Const.GLASS_STATE_OUT_ING; for (T t : list) { if (isPair == (t.getIsPair() == null ? 0 : t.getIsPair())) { resultList.add(t); } } if (isPair == 0) { taskType = Const.BIG_STORAGE_AFTER_DISPATCH; taskState = Const.GLASS_STATE_SCHEDULE_ING; totalLayer = 0; } return computeOutGlassInfo(resultList, BIG_STORAGE_CAGE_OUT_TWO_TASK, targetSlot, taskState, taskType, totalLayer); } /** * 出片一次仅生成一车玻璃 * * @param <T> * @param list * @param totalLayer * @return */ private <T extends HollowBigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName, int targetSlot, int state, int taskType, int totalLayer) { //任务数据:获取车子存放玻璃最大数量,玻璃间隔 List<BigStorageCageTask> tempList = new ArrayList<>(); List<T> tempTList = new ArrayList<>(); //打车剩余尺寸 Integer remainWidth = carWidth; for (T e : list) { if (tempList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) { break; } //计算当前出片车剩尺寸 remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap; tempTList.add(e); tempList.add(new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot, 0)); } Assert.isFalse(CollectionUtil.isEmpty(tempList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", tempList.size()); List<BigStorageCageTask> bigStorageCageTaskList = tempList; if (taskType == Const.BIG_STORAGE_AFTER_OUT) { if (tempList.size() <= totalLayer) { bigStorageCageTaskList = tempList; } else { int remainCount = tempList.size() % totalLayer; // tempList.subList(0,) } } List<String> glassIds = bigStorageCageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); int glassCount = bigStorageCageTaskList.size(); //生成出片任务条数不足6补全 while (bigStorageCageTaskList.size() < 6) { bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0)); } //清空任务表数据 bigStorageCageTaskService.removeAll(tableName); bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList); List<HollowBigStorageCageHistoryTask> historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> { HollowBigStorageCageHistoryTask history = new HollowBigStorageCageHistoryTask(); BeanUtils.copyProperties(e, history); history.setGlassCount(glassCount); history.setTaskType(taskType); return history; }).collect(Collectors.toList()); hollowBigStorageCageHistoryTaskService.saveBatch(historyList); log.info("将出片玻璃{}玻璃状态改为出片中", glassIds); hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>() .set(HollowBigStorageCageDetails::getState, state) .set(Const.BIG_STORAGE_AFTER_DISPATCH.equals(taskType), HollowBigStorageCageDetails::getSlot, targetSlot) .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .in(HollowBigStorageCageDetails::getGlassId, glassIds)); try { miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 1)); } catch (Exception e) { e.printStackTrace(); } return Boolean.TRUE; } public void updateSlotRemainBySlots(List<Integer> slotList) { //获取格子内所有的玻璃信息 List<HollowBigStorageCageDetails> inSlotGlassList = hollowBigStorageCageDetailsService.list(new LambdaQueryWrapper<HollowBigStorageCageDetails>() .in(HollowBigStorageCageDetails::getSlot, slotList).in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL)); Map<Integer, Double> slotRemainMap = new HashMap<>(); //是否存在有格子非空的玻璃 if (CollectionUtils.isNotEmpty(inSlotGlassList)) { //存在 将格子内的玻璃分别进行更新 slotRemainMap = inSlotGlassList.stream() .collect(Collectors.groupingBy(HollowBigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap))); slotRemainMap.forEach((e, v) -> { double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0; hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>().set(HollowBigStorageCage::getRemainWidth, remainWidth) .eq(HollowBigStorageCage::getSlot, e)); }); } //过滤不存在玻璃的格子 将宽度重置为原始宽度6200 Set<Integer> remainSlotList = slotRemainMap.keySet(); slotList.removeAll(remainSlotList); if (CollectionUtils.isNotEmpty(slotList)) { hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>().set(HollowBigStorageCage::getRemainWidth, slotWidth) .in(HollowBigStorageCage::getSlot, slotList)); } } private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) { return ReadWriteEntity.builder() .identifier(identifier) //Kep中是Long类型，即：Int32，Java中的int类型 .value(value) .build(); } // // private List<BigStorageCageTask> computeOutTaskList(List<BigStorageCageTask> taskList, int totalLayer, int target) { //// if (target == 931){} // if (taskList.get(0).get) // return null; // } }
