From cf33278c73767f72e35a4898c23765f52a3bfd1d Mon Sep 17 00:00:00 2001
From: zhoushihao <zsh19950802@163.com>
Date: 星期二, 03 十二月 2024 09:06:02 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/ywMes'
---
hangzhoumesParent/moduleService/howllowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java | 768 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 768 insertions(+), 0 deletions(-)
diff --git a/hangzhoumesParent/moduleService/howllowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java b/hangzhoumesParent/moduleService/howllowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java
new file mode 100644
index 0000000..bbfea54
--- /dev/null
+++ b/hangzhoumesParent/moduleService/howllowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java
@@ -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("鑾峰彇浠诲姟鐨勭幓鐠僫d锛歿}", 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:鍚憄lc鍙戦�佹姤璀�
+ 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:鍚憄lc鍙戦�佹姤璀�
+ 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:鍚憄lc鍙戦�佹姤璀�
+ 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);
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ 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銆佽幏鍙栬繘鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", 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);
+ }
+ //娓呯┖鍚姩鐘舵��
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ 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銆佽幏鍙栬繘鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", 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);
+ //娓呯┖鍚姩鐘舵��
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ 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绫诲瀷锛屽嵆锛欼nt32锛孞ava涓殑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;
+// }
+}
\ No newline at end of file
--
Gitblit v1.8.0