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.github.yulichang.toolkit.JoinWrappers; import com.kangaroohy.milo.model.ReadWriteEntity; import com.kangaroohy.milo.service.MiloService; import com.mes.base.entity.BigStorageCageBaseInfo; import com.mes.bigstorage.entity.BigStorageCage; import com.mes.bigstorage.entity.BigStorageCageDetails; import com.mes.bigstorage.entity.dto.BigStorageDTO; import com.mes.bigstorage.entity.dto.BigStorageRelationDTO; import com.mes.bigstorage.entity.dto.BigStorageSequenceDTO; import com.mes.bigstorage.entity.dto.TemperingLayoutDTO; import com.mes.bigstorage.service.BigStorageCageDetailsService; import com.mes.bigstorage.service.BigStorageCageService; import com.mes.bigstorage.service.BigStorageGlassInfoService; import com.mes.bigstorage.service.BigStorageGlassRelationInfoService; import com.mes.bigstoragecagetask.entity.BigStorageCageHistoryTask; import com.mes.bigstoragecagetask.entity.BigStorageCageTask; import com.mes.bigstoragecagetask.service.BigStorageCageHistoryTaskService; import com.mes.bigstoragecagetask.service.BigStorageCageTaskService; import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO; import com.mes.common.config.Const; import com.mes.damage.entity.Damage; import com.mes.damage.service.DamageService; import com.mes.edgglasstask.entity.EdgGlassTaskInfo; import com.mes.edgglasstask.service.EdgGlassTaskInfoService; import com.mes.glassinfo.entity.GlassInfo; import com.mes.glassinfo.service.GlassInfoService; 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 OpcPlcStorageCageNewTask { @Resource private BigStorageCageDetailsService bigStorageCageDetailsService; @Resource private TemperingGlassInfoService temperingGlassInfoService; @Resource private DamageService damageService; @Resource private GlassInfoService glassInfoService; @Resource private BigStorageGlassRelationInfoService bigStorageGlassRelationInfoService; @Resource private BigStorageCageService bigStorageCageService; @Resource private BigStorageCageHistoryTaskService bigStorageCageHistoryTaskService; @Resource private BigStorageCageTaskService bigStorageCageTaskService; @Resource private BigStorageGlassInfoService bigStorageGlassInfoService; @Resource private EdgGlassTaskInfoService edgGlassTaskInfoService; @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; @Value("${mes.temperingOutTargetPosition}") private Integer temperingOutTargetPosition; @Value("${mes.artificialOutTargetPosition}") private Integer artificialOutTargetPosition; @Scheduled(fixedDelay = 1000) public void inBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束进片任务"); return; } ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1A.DLP1A.RequestMes"); if (!"1".equals(requestEntity.getValue() + "")) { log.info("当前未收到进片请求，结束进片任务"); return; } ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP1A.DLP1A.MesReply"); if ("1".equals(mesReplyEntity.getValue() + "")) { log.info("有正在执行的任务，结束进片任务"); return; } //获取进片任务信息 List inTaskList = new ArrayList(); ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM1"); List glassIdList = new ArrayList<>(); for (int i = 1; i <= 6; i++) { ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.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 glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting())); for (Map.Entry entry : glassCountMap.entrySet()) { if (entry.getValue() > 1) { log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey()); //todo:向plc发送报警 return; } } List detailsList = bigStorageCageDetailsService.list(new LambdaQueryWrapper().in(BigStorageCageDetails::getGlassId, glassIdList) .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL)); if (CollectionUtil.isNotEmpty(detailsList)) { log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList); //todo:向plc发送报警 return; } List glassInfoList = glassInfoService.list(new LambdaQueryWrapper().in(GlassInfo::getGlassId, glassIdList)); if (glassInfoList.size() != inTaskList.size()) { log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size()); //todo:向plc发送报警 return; } //修改磨边对列表的玻璃状态 edgGlassTaskInfoService.update(new LambdaUpdateWrapper() .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).in(EdgGlassTaskInfo::getGlassId, glassIdList)); Map> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId)); //计算目标格子 List historyTasks = new ArrayList<>(); for (BigStorageCageTask task : inTaskList) { GlassInfo info = glassListMap.get(task.getGlassId()).get(0); BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getEngineerId(), info.getTemperingLayoutId(), info.getTemperingFeedSequence()); //获取目标格子信息 // BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info); // 临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸） bigStorageCageService.update(new LambdaUpdateWrapper() .set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap) .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot())); task.setTargetSlot(bigStorageDTO.getSlot()); task.setGlassId(info.getGlassId()); bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task); //存放历史任务 BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask(); BeanUtils.copyProperties(task, historyTask); historyTask.setTaskType(Const.BIG_STORAGE_BEFORE_IN); historyTask.setGlassCount(glassInfoList.size()); historyTask.setTaskState(Const.ENGINEERING_NEW); historyTasks.add(historyTask); BigStorageCageDetails cageDetails = new BigStorageCageDetails(); BeanUtils.copyProperties(info, cageDetails); cageDetails.setSlot(bigStorageDTO.getSlot()); cageDetails.setState(Const.GLASS_STATE_NEW); cageDetails.setDeviceId(bigStorageDTO.getDeviceId()); cageDetails.setSequence(bigStorageDTO.getSlotSequence()); cageDetails.setGap(glassGap); cageDetails.setId(null); bigStorageCageDetailsService.save(cageDetails); } //历史数据入库 bigStorageCageHistoryTaskService.saveBatch(historyTasks); //向opc发送启动信号 List list = new ArrayList<>(); for (int i = 1; i <= inTaskList.size(); i++) { list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, inTaskList.get(i - 1).getTargetSlot())); } list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1)); miloService.writeToOpcWord(list); } @Scheduled(fixedDelay = 1000) public void outBigStorageTask() throws Exception { Date startDate = new Date(); ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束进片任务"); return; } ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1B.DLP1B.RequestMes"); if (!"1".equals(requestEntity.getValue() + "")) { log.info("当前未收到出片请求，结束出片任务"); return; } //获取出片任务表 List outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task"); if (CollectionUtil.isNotEmpty(outTaskList)) { log.info("有正在执行的出片任务，结束本次出片任务"); return; } //是否允许钢化 //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息 // 获取当前钢化任务未完成出片的玻璃信息 List unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper() .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence)); if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) { // List glassIdList = unFinishTemperingGlassInfoList.stream().map(TemperingGlassInfo::getGlassId).collect(Collectors.toList()); // List historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper() // .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_OUT) // .in(BigStorageCageHistoryTask::getGlassId, glassIdList)); // List temperingGlassList = unFinishTemperingGlassInfoList; // if (CollectionUtil.isNotEmpty(historyTaskList)) { // List taskGlassList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList()); // temperingGlassList = unFinishTemperingGlassInfoList.stream().filter(e -> !taskGlassList.contains(e.getGlassId())).collect(Collectors.toList()); // } // 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; } if (redisUtil.getCacheObject("temperingSwitch")) { //钢化优先：获取理片笼 玻璃小片 破损表 数量 判断笼内版图是否到齐 List temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll(); if (CollectionUtil.isNotEmpty(temperingLayoutDTOList)) { //玻璃到齐包括已出片的 //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务 结束 for (TemperingLayoutDTO item : temperingLayoutDTOList) { // if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) { List temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class) .selectAll(GlassInfo.class) .select("-1 as state") .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot) .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId) .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId()) .eq(GlassInfo::getEngineerId, item.getEngineerId()) .orderByAsc(GlassInfo::getTemperingFeedSequence)); if (CollectionUtil.isNotEmpty(temperingGlassInfos)) { temperingGlassInfoService.saveBatch(temperingGlassInfos); computeOutGlassInfoByVirtualSlot(temperingGlassInfos, "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; } // } } } } //是否有人工下片任务 有直接出 List artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL) .orderByAsc(BigStorageCageDetails::getSlot) .orderByAsc(BigStorageCageDetails::getId).last("limit " + outCarMaxSize)); if (CollectionUtil.isNotEmpty(artificialList)) { computeOutGlassInfoByVirtualSlot(artificialList, "big_storage_cage_out_one_task", artificialOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } //是否存在需要内部调度的格子:执行内部调度任务 if (redisUtil.getCacheObject("dispatchSwitch")) { //todo:获取笼内单格已经到齐的玻璃格子信息 List virtualList = bigStorageCageDetailsService.queryIsAllNeedDispatchVirtualSlot(); if (CollectionUtil.isEmpty(virtualList)) { log.info("没有需要调度的格子"); return; } List list = new ArrayList<>(); loop: for (BigStorageRelationDTO dto : virtualList) { List sequenceDTOList = bigStorageCageDetailsService.dispatchBigStorageGlassInfo(dto); if (CollectionUtil.isEmpty(sequenceDTOList) || sequenceDTOList.size() == 1) { continue; } int sequence = -1; int startSlot = -1; for (BigStorageSequenceDTO item : sequenceDTOList) { if (item.getMaxSequence() == sequence - 1) { //生成调度任务 int targetSlot = item.getSlot(); list = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN).eq(BigStorageCageDetails::getSlot, startSlot)); computeOutGlassInfoByVirtualSlot(list, "big_storage_cage_out_one_task", targetSlot, Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH); List slotList = new ArrayList<>(); slotList.add(targetSlot); updateSlotRemainBySlots(slotList); break loop; } sequence = item.getMinSequence(); 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("DLP1A.DLP1A.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束完成进片任务"); return; } //获取进片任务表 // List inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task"); List inTaskList = new ArrayList(); List glassIdList = new ArrayList<>(); ReadWriteEntity toWord = miloService.readFromOpcUa("DLP1A.DLP1A.TO1"); if ("0".equals(toWord.getValue() + "")) { log.info("完成任务已执行，结束本次完成进片任务"); return; } for (int i = 1; i <= 6; i++) { ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i); ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP1A.DLP1A.STATE" + i); ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.TO" + i); ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.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 unFinishTaskList = inTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList()); if (CollectionUtil.isNotEmpty(unFinishTaskList)) { log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList); return; } Map> taskMap = inTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState)); //按照任务状态修改大理片笼内的玻璃数据 // 重新计算大理片笼内的剩余尺寸 taskMap.forEach((e1, v) -> { if (e1 == 2) { //进片完成 log.info("3、获取进片已完成的玻璃信息id:{}", v); List inSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList()); List storageCageDTOList = v.stream().map(e -> { UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO(); BeanUtils.copyProperties(e, storageCageDTO); return storageCageDTO; }).collect(Collectors.toList()); bigStorageCageDetailsService.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) { //更新历史任务表中的任务状态 bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper() .set(BigStorageCageHistoryTask::getTaskState, item.getTaskState()) .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_IN) .eq(BigStorageCageHistoryTask::getTargetSlot, item.getTargetSlot()) .eq(BigStorageCageHistoryTask::getGlassId, item.getGlassId())); item.setTargetSlot(0); //清空任务表数据 bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", item); } //清空启动状态 //向opc发送启动信号 //向opc发送启动信号 List list = new ArrayList<>(); for (int i = 1; i <= 6; i++) { list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, 0)); } list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0)); miloService.writeToOpcWord(list); } @Scheduled(fixedDelay = 1000) public void finishOutBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束完成出片任务"); return; } //获取进片任务表 List outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task"); if (CollectionUtil.isEmpty(outTaskList)) { log.info("当前大车无进片玻璃，结束完成进片任务"); return; } List unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList()); if (CollectionUtil.isNotEmpty(unFinishTaskList)) { log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList); return; } Map> 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_BEFORE_OUT; } else { taskType = Const.BIG_STORAGE_BEFORE_DISPATCH; } //按照任务状态修改大理片笼内的玻璃数据 // 重新计算大理片笼内的剩余尺寸 Integer finalTaskType = taskType; taskMap.forEach((e1, v) -> { if (e1 == 2) { //进片完成 log.info("3、获取进片已完成的玻璃信息id:{}", v); List outSuccessGlassSlot = new ArrayList<>(); if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) { outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList()); } else { List targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList()); List startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList()); outSuccessGlassSlot.addAll(targetSuccessGlassSlot); outSuccessGlassSlot.addAll(startoutSuccessGlassSlot); } List storageCageDTOList = v.stream().map(e -> { UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO(); storageCageDTO.setGlassId(e.getGlassId()); if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) { storageCageDTO.setTargetSlot(e.getStartSlot()); } else { storageCageDTO.setTargetSlot(e.getTargetSlot()); } return storageCageDTO; }).collect(Collectors.toList()); if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) { bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT); } else { bigStorageCageDetailsService.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) { //更新历史任务表中的任务状态 bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper() .set(BigStorageCageHistoryTask::getTaskState, item.getTaskState()) .eq(BigStorageCageHistoryTask::getTaskType, taskType) .eq(BigStorageCageHistoryTask::getGlassId, item.getGlassId())); //更新钢化小片表 Integer taskState = item.getTaskState(); if (taskState == 2) { temperingGlassInfoService.update(new LambdaUpdateWrapper() .set(TemperingGlassInfo::getState, Const.TEMPERING_OUT).eq(TemperingGlassInfo::getGlassId, item.getGlassId())); } else if (taskState == 3) { // temperingGlassInfoService.remove(new LambdaQueryWrapper().eq(TemperingGlassInfo::getGlassId, item.getGlassId())); temperingGlassInfoService.update(new LambdaUpdateWrapper() .set(TemperingGlassInfo::getState, Const.TEMPERING_DAMAGE ).eq(TemperingGlassInfo::getGlassId, item.getGlassId())); } else { // 空执行 } } // 重置任务表数据 bigStorageCageTaskService.updateOutTaskMessage("big_storage_cage_out_one_task"); //清空启动状态 //向opc发送启动信号 miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0)); } private void dealDamageInTask(List damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 bigStorageCageDetailsService.remove(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(BigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List 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 damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 bigStorageCageDetailsService.remove(new LambdaQueryWrapper() .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO) .in(BigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List 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 noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); //移除理片笼详情表未执行任务的空记录信息 bigStorageCageDetailsService.remove(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(BigStorageCageDetails::getGlassId, noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //记录格子号，按格子号更新剩余尺寸 List slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("进片任务-无动作执行完成"); } private void noDealOutTask(List noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); if (Const.OUT_TARGET_POSITION_ALL.contains(noDealTaskList.get(0).getTargetSlot())) { //出片任务:将出片中状态恢复为在笼内 List glassList = noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .in(BigStorageCageDetails::getGlassId, glassList)); } else { //调度任务：将调度中状态改为在笼内，格子号恢复为调度前的格子 for (BigStorageCageTask item : noDealTaskList) { bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getSlot, item.getStartSlot()) .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .eq(BigStorageCageDetails::getGlassId, item.getGlassId())); } } //将破损信息新增入破损表 List slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("出片任务-无动作执行完成"); } /** * 出片一次仅生成一车玻璃 * * @param list * @param * @return */ private Boolean computeOutGlassInfoByVirtualSlot(List list, String tableName, int targetSlot, int state, int taskType) { //任务数据:获取车子存放玻璃最大数量,玻璃间隔 List glassIdList = bigStorageGlassRelationInfoService.queryNeedOutGlassId( list.get(0).getEngineerId(), list.get(0).getTemperingLayoutId(), list.get(0).getTemperingFeedSequence()); List outGlassList = list.stream().filter(e -> glassIdList.contains(e.getGlassId())).collect(Collectors.toList()); Assert.isFalse(CollectionUtil.isEmpty(outGlassList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", outGlassList.size()); List bigStorageCageTaskList = outGlassList.stream() .map(e -> new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot, 0)).collect(Collectors.toList()); List 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("big_storage_cage_out_one_task"); bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList); List historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> { BigStorageCageHistoryTask history = new BigStorageCageHistoryTask(); BeanUtils.copyProperties(e, history); history.setGlassCount(glassCount); history.setTaskType(taskType); return history; }).collect(Collectors.toList()); bigStorageCageHistoryTaskService.saveBatch(historyList); log.info("将出片玻璃{}玻璃状态改为出片中", glassIds); bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, state) .set(Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType), BigStorageCageBaseInfo::getSlot, targetSlot) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .in(BigStorageCageDetails::getGlassId, glassIds)); try { miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1)); } catch (Exception e) { e.printStackTrace(); } return Boolean.TRUE; } // /** // * 出片一次仅生成一车玻璃 // * // * @param list // * @param // * @return // */ private Boolean computeOutGlassInfo(List list, String tableName, int targetSlot, int state, int taskType) { //任务数据:获取车子存放玻璃最大数量,玻璃间隔 List bigStorageCageTaskList = new ArrayList<>(); //打车剩余尺寸 Integer remainWidth = carWidth; for (T e : list) { if (bigStorageCageTaskList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) { break; } //计算当前出片车剩尺寸 remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap; bigStorageCageTaskList.add(new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot, 0)); } Assert.isFalse(CollectionUtil.isEmpty(bigStorageCageTaskList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", bigStorageCageTaskList.size()); List 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("big_storage_cage_out_one_task"); bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList); List historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> { BigStorageCageHistoryTask history = new BigStorageCageHistoryTask(); BeanUtils.copyProperties(e, history); history.setGlassCount(glassCount); history.setTaskType(taskType); return history; }).collect(Collectors.toList()); bigStorageCageHistoryTaskService.saveBatch(historyList); log.info("将出片玻璃{}玻璃状态改为出片中", glassIds); bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, state) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .set(Const.GLASS_STATE_SCHEDULE_ING.equals(state), BigStorageCageBaseInfo::getSlot, targetSlot) .in(BigStorageCageDetails::getGlassId, glassIds)); try { miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1)); } catch (Exception e) { e.printStackTrace(); } return Boolean.TRUE; } public void updateSlotRemainBySlots(List slotList) { //获取格子内所有的玻璃信息 List inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL)); Map slotRemainMap = new HashMap<>(); //是否存在有格子非空的玻璃 if (CollectionUtil.isNotEmpty(inSlotGlassList)) { //存在 将格子内的玻璃分别进行更新 slotRemainMap = inSlotGlassList.stream() .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap))); slotRemainMap.forEach((e, v) -> { double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0; bigStorageCageService.update(new LambdaUpdateWrapper().set(BigStorageCage::getRemainWidth, remainWidth) .eq(BigStorageCage::getSlot, e)); }); } //过滤不存在玻璃的格子 将宽度重置为原始宽度5000 Set remainSlotList = slotRemainMap.keySet(); slotList.removeAll(remainSlotList); if (CollectionUtil.isNotEmpty(slotList)) { bigStorageCageService.update(new LambdaUpdateWrapper().set(BigStorageCage::getRemainWidth, slotWidth) .in(BigStorageCage::getSlot, slotList)); } } private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) { return ReadWriteEntity.builder() .identifier(identifier) //Kep中是Long类型，即：Int32，Java中的int类型 .value(value) .build(); } }