From 5ec61cdaa2c1ab4dd1d58bd94afb49343332e78f Mon Sep 17 00:00:00 2001
From: ZengTao <2773468879@qq.com>
Date: 星期五, 07 三月 2025 16:56:35 +0800
Subject: [PATCH] 添加中空大理片汇总数据显示，推送服务器时间供前端使用
---
hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java | 622 ++++++++++++++++++++++++++++++++++++++++----------------
1 files changed, 444 insertions(+), 178 deletions(-)
diff --git a/hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java b/hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java
index 6ac731b..865eb34 100644
--- a/hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java
+++ b/hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java
@@ -1,13 +1,18 @@
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.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.BigStorageDTO;
+import com.mes.bigstorage.entity.dto.BigStorageDTO;
+import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
+import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragecagetask.entity.BigStorageCageHistoryTask;
@@ -16,15 +21,18 @@
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.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;
@@ -43,7 +51,6 @@
private TemperingGlassInfoService temperingGlassInfoService;
@Resource
private DamageService damageService;
-
@Resource
private GlassInfoService glassInfoService;
@Resource
@@ -56,43 +63,84 @@
@Autowired(required = false)
MiloService miloService;
+ @Resource
+ private RedisUtil redisUtil;
+
@Value("${mes.slotWidth}")
private Integer slotWidth;
@Value("${mes.glassGap}")
private Integer glassGap;
- @Scheduled(fixedDelay = 1000)
+ @Value("${mes.carWidth}")
+ private Integer carWidth;
+
+ @Value("${mes.outCarMaxSize}")
+ private Integer outCarMaxSize;
+
+ @Value("${mes.sequence.order}")
+ private boolean sequenceOrder;
+
+ @Value("${mes.temperingOutTargetPosition}")
+ private Integer temperingOutTargetPosition;
+ @Value("${mes.artificialOutTargetPosition}")
+ private Integer artificialOutTargetPosition;
+
+
+ // @Scheduled(fixedDelay = 1000)
public void inBigStorageTask() throws Exception {
- ReadWriteEntity inkageEntity = miloService.readFromOpcUa("PLC.DPL1.inkageState");
- if (!"1".equals(inkageEntity.getValue())) {
+ ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl");
+ if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
log.info("褰撳墠涓洪潪鑱旀満鐘舵�侊紝缁撴潫杩涚墖浠诲姟");
return;
}
- ReadWriteEntity requestEntity = miloService.readFromOpcUa("PLC.DPL1.plcInGlassRequest");
- if (!"1".equals(requestEntity.getValue())) {
+ 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<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task");
- if (CollectionUtils.isEmpty(inTaskList)) {
+ if (CollectionUtil.isEmpty(inTaskList)) {
log.info("褰撳墠澶ц溅鏃犺繘鐗囩幓鐠冿紝缁撴潫杩涚墖浠诲姟");
}
+
List<String> glassIdList = inTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
log.info("鑾峰彇浠诲姟鐨勭幓鐠僫d锛歿}", glassIdList);
- Map<String, List<BigStorageCageTask>> taskMap = inTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getGlassId));
+ 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<BigStorageCageDetails> detailsList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList)
+ .eq(BigStorageCageDetails::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));
+
+ Map<String, List<GlassInfo>> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId));
+
//璁＄畻鐩爣鏍煎瓙
List<BigStorageCageHistoryTask> historyTasks = new ArrayList<>();
- for (GlassInfo info : glassInfoList) {
+ for (BigStorageCageTask task : inTaskList) {
+ GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
//鑾峰彇鐩爣鏍煎瓙淇℃伅
BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
// 涓存椂鏇存柊鏍煎瓙鐨勫墿浣欏昂瀵革細闃叉鐩搁偦鐜荤拑杩涘悓涓�鏍煎瓙閫犳垚鍓╀綑灏哄涓嶈冻锛岀幓鐠冭秺鐣岀殑鎯呭喌锛屼换鍔″畬鎴愬悗鍐嶆鏇存柊澶х悊鐗囩琛ㄥ墿浣欏搴︼紙鎸夌収绗煎唴鐜荤拑鏁伴噺鏇存柊澶х悊鐗囩鍓╀綑灏哄锛�
bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>()
.set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
.eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
- BigStorageCageTask task = taskMap.get(info.getGlassId()).get(0);
task.setTargetSlot(bigStorageDTO.getSlot());
task.setGlassId(info.getGlassId());
bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task);
@@ -102,42 +150,157 @@
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.setGap(glassGap);
+ cageDetails.setId(null);
bigStorageCageDetailsService.save(cageDetails);
}
//鍘嗗彶鏁版嵁鍏ュ簱
bigStorageCageHistoryTaskService.saveBatch(historyTasks);
//鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
- miloService.writeToOpcWord(generateReadWriteEntity("PLC.DPL1.taskRunning", 1));
+ miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1));
}
- @Scheduled(fixedDelay = 1000)
- public void finishBigStorageTask() throws Exception {
- ReadWriteEntity inkageEntity = miloService.readFromOpcUa("PLC.DPL1.inkageState");
- if (!"1".equals(inkageEntity.getValue())) {
+ // @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<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task");
+ if (CollectionUtil.isNotEmpty(outTaskList)) {
+ log.info("鏈夋鍦ㄦ墽琛岀殑鍑虹墖浠诲姟锛岀粨鏉熸湰娆″嚭鐗囦换鍔�");
+ return;
+ }
+ //todo:鏄惁鍏佽閽㈠寲
+ if (redisUtil.getCacheObject("temperingSwitch")) {
+ //鏄惁鏈夋鍦ㄩ挗鍖栫殑鐜荤拑:閽㈠寲灏忕墖琛ㄥ叧鑱斿巻鍙蹭换鍔¤〃锛岀瓫閫夋湭鍑虹鐨勭幓鐠冧俊鎭�
+// 鑾峰彇褰撳墠閽㈠寲浠诲姟鏈畬鎴愬嚭鐗囩殑鐜荤拑淇℃伅
+ List<TemperingGlassInfo> unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW));
+ if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
+ List<String> glassIdList = unFinishTemperingGlassInfoList.stream().map(TemperingGlassInfo::getGlassId).collect(Collectors.toList());
+ List<BigStorageCageHistoryTask> historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
+ .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_OUT)
+ .in(BigStorageCageHistoryTask::getGlassId, glassIdList));
+ List<TemperingGlassInfo> temperingGlassList = unFinishTemperingGlassInfoList;
+ if (CollectionUtil.isNotEmpty(historyTaskList)) {
+ List<String> taskGlassList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList());
+ temperingGlassList = unFinishTemperingGlassInfoList.stream().filter(e -> !taskGlassList.contains(e.getGlassId())).collect(Collectors.toList());
+ }
+ if (CollectionUtil.isNotEmpty(temperingGlassList)) {
+ log.info("鏈夋鍦ㄥ嚭鐗囩殑閽㈠寲浠诲姟");
+ computeOutGlassInfo(temperingGlassList, "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<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
+ if (CollectionUtil.isNotEmpty(temperingLayoutDTOList)) {
+ //鐜荤拑鍒伴綈鍖呮嫭宸插嚭鐗囩殑
+ //鍒伴綈锛屽皢鐜荤拑灏忕墖鏁版嵁瀛樺叆閽㈠寲灏忕墖琛紝閫昏緫鐢熸垚鍑虹墖浠诲姟 缁撴潫
+ for (TemperingLayoutDTO item : temperingLayoutDTOList) {
+// if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) {
+ List<TemperingGlassInfo> 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())
+ .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
+ if (CollectionUtil.isNotEmpty(temperingGlassInfos)) {
+ temperingGlassInfoService.saveBatch(temperingGlassInfos);
+ computeOutGlassInfo(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<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
+ .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL)
+ .orderByAsc(BigStorageCageDetails::getSlot)
+ .orderByAsc(BigStorageCageDetails::getId));
+ if (CollectionUtil.isNotEmpty(artificialList)) {
+ computeOutGlassInfo(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;
+ }
+ //鏄惁瀛樺湪闇�瑕佸唴閮ㄨ皟搴︾殑鏍煎瓙:鎵ц鍐呴儴璋冨害浠诲姟
+ List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
+ if (CollectionUtil.isNotEmpty(temperingOccupySlotList)) {
+ loop:
+ for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
+ List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
+ for (int i = 0; i < slotSequenceList.size() - 1; i++) {
+ SlotSequenceDTO first = slotSequenceList.get(i);
+ SlotSequenceDTO second = slotSequenceList.get(i + 1);
+ int slotWidth = carWidth - first.getRemainWidth() - glassGap;
+ int totalCount = first.getGlassCount() + second.getGlassCount();
+ if (totalCount <= 6 && first.getMinSequence() == second.getMaxSequence() + 1
+ && second.getRemainWidth() > slotWidth && slotWidth >= 0) {
+ List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
+ .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
+ if (CollectionUtil.isNotEmpty(list)) {
+ computeOutGlassInfo(list, "big_storage_cage_out_one_task", second.getSlot(), Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH);
+ }
+ //浣跨敤Arrays.asList() 浣跨敤removeAll鎶ラ敊锛屾敼涓烘甯镐娇鐢↙ist
+ List<Integer> slotList = new ArrayList<>();
+ slotList.add(second.getSlot());
+ updateSlotRemainBySlots(slotList);
+ break loop;
+ }
+ }
+ }
+ }
+ 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<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task");
- if (CollectionUtils.isEmpty(inTaskList)) {
+ if (CollectionUtil.isEmpty(inTaskList)) {
log.info("褰撳墠澶ц溅鏃犺繘鐗囩幓鐠冿紝缁撴潫瀹屾垚杩涚墖浠诲姟");
+ return;
}
- List<BigStorageCageTask> unFinishTaskList = inTaskList.stream().filter(e -> e.getTaskState() <= 1).collect(Collectors.toList());
- if (CollectionUtils.isNotEmpty(unFinishTaskList)) {
+ 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) -> {
- List<String> glassList = v.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
if (e1 == 2) {
//杩涚墖瀹屾垚
log.info("3銆佽幏鍙栬繘鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", v);
@@ -152,165 +315,268 @@
updateSlotRemainBySlots(inSuccessGlassSlot);
} else if (e1 == 3) {
//鐮存崯澶勭悊
+ dealDamageInTask(v);
} else {
//娓呯┖鐞嗙墖绗肩┖鏁版嵁
+ noDealInTask(v);
}
});
- //todo:鎸夌収浠诲姟鐘舵�佷慨鏀瑰ぇ鐞嗙墖绗煎唴鐨勭幓鐠冩暟鎹�
- //todo:閲嶆柊璁＄畻澶х悊鐗囩鍐呯殑鍓╀綑灏哄
- //todo:鏇存柊鍘嗗彶浠诲姟琛ㄤ腑鐨勪换鍔＄姸鎬�
- //todo:娓呯┖浠诲姟琛ㄦ暟鎹�
- //todo:娓呯┖鍚姩鐘舵��
-
+ for (BigStorageCageTask item : inTaskList) {
+ //鏇存柊鍘嗗彶浠诲姟琛ㄤ腑鐨勪换鍔＄姸鎬�
+ bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<BigStorageCageHistoryTask>()
+ .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);
+ }
+ //娓呯┖鍚姩鐘舵��
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0));
}
-//
-// @Scheduled(fixedDelay = 300)
-// public void updateOutGlassStateTask() {
-// Date startDate = new Date();
-// log.info("1銆佸ぇ鐞嗙墖绗煎嚭鐗囧畬鎴愬悗鏇存柊澶х悊鐗囩鏁版嵁浠诲姟寮�濮嬫墽琛屾椂闂达細{}", startDate);
-// //鍥犱负澶х悊鐗囩鍜屽嚭鐗囦换鍔℃槸涓や釜搴撶殑鏁版嵁锛屾墍浠ヨ鍒嗗紑鏌ユ壘
-// List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
-// .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING));
-// if (CollectionUtils.isNotEmpty(list)) {
-// log.info("2銆佽幏鍙栨墍鏈夋鍦ㄥ嚭鐗囩殑鐜荤拑淇℃伅id:{}", list);
-// List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
-// List<BigStorageCageOutTask> outSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
-// .in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
-// if (CollectionUtils.isNotEmpty(outSuccessGlass)) {
-// for (BigStorageCageOutTask bigStorageCageOutTask : outSuccessGlass
-// ) {
-// if (bigStorageCageOutTask.getEndSlot().equals(Const.ARTIFICIAL_OUT_TARGET_POSITION)) {
-// temperingGlassInfoService.update(
-// new LambdaUpdateWrapper<TemperingGlassInfo>()
-// .set(TemperingGlassInfo::getState, Const.TEMPERING_END)
-// .eq(TemperingGlassInfo::getGlassId, bigStorageCageOutTask.getGlassId())
-// );
-// }
-// }
-// log.info("3銆佽幏鍙栧嚭鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", outSuccessGlass);
-// List<UpdateBigStorageCageDTO> storageCageDTOList = outSuccessGlass.stream().map(e -> {
-// UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
-// storageCageDTO.setGlassId(e.getGlassId());
-// storageCageDTO.setTargetSlot(e.getStartSlot());
-// return storageCageDTO;
-// }).collect(Collectors.toList());
-// bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
-// List<Integer> outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList());
-// log.info("4銆佸ぇ鐞嗙墖绗煎嚭鐗囩姸鎬佸凡瀹屾垚宸插畬鎴愮殑鐜荤拑淇℃伅id:{}", outSuccessGlass);
-// //鏇存柊鐞嗙墖绗肩幓鐠冨昂瀵�
-// baseService.updateSlotRemainBySlots(outSuccessSlotList);
-// log.info("5銆佸ぇ鐞嗙墖绗艰繘鐗囩洰鏍囨牸瀛愬昂瀵告洿鏂板畬鎴�");
-// }
-// }
-// Date endDate = new Date();
-// log.info("end:澶х悊鐗囩鍑虹墖瀹屾垚鍚庢洿鏂板ぇ鐞嗙墖绗兼暟鎹换鍔＄粨鏉熸椂闂达細{}锛屽叡鑰楁椂锛歿}ms,缁撴潫浠诲姟", endDate, endDate.getTime() - startDate.getTime());
-// return;
-//
-// }
-//
-// @Scheduled(fixedDelay = 300)
-// public void updateScheduleGlassStateTask() {
-// Date startDate = new Date();
-// log.info("1銆佸ぇ鐞嗙墖绗艰皟搴﹀畬鎴愬悗鏇存柊澶х悊鐗囩鏁版嵁浠诲姟寮�濮嬫墽琛屾椂闂达細{}", startDate);
-// //鍥犱负澶х悊鐗囩鍜岃皟搴︿换鍔℃槸涓や釜搴撶殑鏁版嵁锛屾墍浠ヨ鍒嗗紑鏌ユ壘
-// List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
-// .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING));
-// if (CollectionUtils.isNotEmpty(list)) {
-// log.info("2銆佽幏鍙栨墍鏈夋鍦ㄥ嚭鐗囩殑鐜荤拑淇℃伅id:{}", list);
-// List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
-// List<BigStorageCageOutTask> scheduleSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
-// .in(BigStorageCageOutTask::getGlassId, glassIds).eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
-// .notIn(BigStorageCageOutTask::getEndSlot, Const.TEMPERING_OUT_TARGET_POSITION, Const.ARTIFICIAL_OUT_TARGET_POSITION));
-// if (CollectionUtils.isNotEmpty(scheduleSuccessGlass)) {
-// log.info("3銆佽幏鍙栬皟搴﹀凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", scheduleSuccessGlass);
-// List<UpdateBigStorageCageDTO> storageCageDTOList = scheduleSuccessGlass.stream().map(e -> {
-// UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
-// storageCageDTO.setGlassId(e.getGlassId());
-// storageCageDTO.setTargetSlot(e.getEndSlot());
-// return storageCageDTO;
-// }).collect(Collectors.toList());
-// bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
-// List<String> scheduleSuccessGlassIds = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
-// log.info("4銆佸ぇ鐞嗙墖绗煎嚭鐗囩姸鎬佸凡瀹屾垚宸插畬鎴愮殑鐜荤拑淇℃伅id:{}", scheduleSuccessGlassIds);
-// //鏇存柊鐞嗙墖绗肩幓鐠冨昂瀵�
-// List<Integer> slotList = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).distinct().collect(Collectors.toList());
-// slotList.addAll(scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getEndSlot).distinct().collect(Collectors.toList()));
-// baseService.updateSlotRemainBySlots(slotList);
-// log.info("5銆佸ぇ鐞嗙墖绗艰繘鐗囩洰鏍囨牸瀛愬昂瀵告洿鏂板畬鎴�");
-// }
-// }
-// Date endDate = new Date();
-// log.info("end:澶х悊鐗囩鍑虹墖瀹屾垚鍚庢洿鏂板ぇ鐞嗙墖绗兼暟鎹换鍔＄粨鏉熸椂闂达細{}锛屽叡鑰楁椂锛歿}ms,缁撴潫浠诲姟", endDate, endDate.getTime() - startDate.getTime());
-// return;
-//
-// }
-//
-// /**
-// * 澶勭悊鐮存崯琛ㄤ换鍔�
-// */
-// @Scheduled(fixedDelay = 300)
-// public void dealDamageTask() {
-// Date startDate = new Date();
-// log.info("澶х悊鐗囩鐮存崯鐜荤拑娓呴櫎浠诲姟寮�濮嬫墽琛屾椂闂达細{}", startDate);
-// //鑾峰彇杩涚墖浠诲姟琛ㄤ腑鐘舵�佷负鐮存崯鐨勬暟鎹�
-// List<BigStorageCageFeedTask> inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
-// .in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
-// if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) {
-// log.info("鑾峰彇杩涚墖浠诲姟琛ㄤ腑鐮存崯鐨勭幓鐠冧俊鎭瘂}", inDamageTaskInfoList);
-// bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
-// //鐞嗙墖绗艰鎯呰〃鏁版嵁鐘舵�佹洿鏂�
-// bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
-// .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
-// //灏嗙牬鎹熶俊鎭柊澧炲叆鐮存崯琛�
-// List<Integer> slotList = new ArrayList<>();
-// for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) {
-// Damage damage = new Damage();
-// damage.setGlassId(bigStorageCageFeedTask.getGlassId());
-// damage.setLine(bigStorageCageFeedTask.getLine());
-// damage.setWorkingProcedure("纾ㄨ竟");
-// damage.setRemark("杩涚鍓嶅崸杞珛");
-// damage.setStatus(1);
-// damage.setType(bigStorageCageFeedTask.getTaskState());
-// damageService.insertDamage(damage);
-// slotList.add(bigStorageCageFeedTask.getTargetSlot());
-// }
-// //鏇存柊鏍煎瓙鍓╀綑瀹藉害
-// baseService.updateSlotRemainBySlots(slotList);
-// log.info("杩涚墖浠诲姟鎵ц瀹屾垚");
-// }
-// //鑾峰彇鍑虹墖浠诲姟琛ㄤ腑鐘舵�佷负鐮存崯鐨勬暟鎹�
-// List<BigStorageCageOutTask> outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
-// .in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
-// if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) {
-// log.info("鑾峰彇鍑虹墖浠诲姟琛ㄤ腑鐮存崯鐨勭幓鐠冧俊鎭瘂}", outDamageTaskInfoList);
-// bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
-// List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
-// //绉婚櫎閽㈠寲涓嬬墖琛ㄦ暟鎹�
-// temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList));
-// //鐞嗙墖绗艰鎯呰〃鏁版嵁鐘舵�佸垹闄�
-// bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList));
-// //灏嗙牬鎹熶俊鎭柊澧炲叆鐮存崯琛�
-// List<Integer> slotList = new ArrayList<>();
-// for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) {
-// Damage damage = new Damage();
-// damage.setGlassId(bigStorageCageOutTask.getGlassId());
-// damage.setLine(bigStorageCageOutTask.getEndSlot());
-// damage.setWorkingProcedure("閽㈠寲");
-// damage.setRemark("鍑虹墖鍚庡崸杞珛");
-// damage.setStatus(1);
-// damage.setType(bigStorageCageOutTask.getTaskState());
-// damageService.insertDamage(damage);
-// slotList.add(bigStorageCageOutTask.getStartSlot());
-// }
-// //鏇存柊鏍煎瓙鍓╀綑瀹藉害
-// baseService.updateSlotRemainBySlots(slotList);
-// log.info("鍑虹墖浠诲姟鎵ц瀹屾垚");
-// }
-// Date endDate = new Date();
-// log.info("澶х悊鐗囩鐮存崯鐜荤拑娓呴櫎浠诲姟缁撴潫鏃堕棿锛歿}锛屽叡鑰楁椂锛歿}ms,缁撴潫鎵爜浠诲姟", endDate, endDate.getTime() - startDate.getTime());
-// return;
-// }
+ // @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<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_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_BEFORE_OUT;
+ } else {
+ taskType = Const.BIG_STORAGE_BEFORE_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_BEFORE_OUT)) {
+ outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
+ } else {
+ outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
+ }
+ List<UpdateBigStorageCageDTO> 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());
+ bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
+ log.info("4銆佸ぇ鐞嗙墖绗艰繘鐗囩姸鎬佸凡瀹屾垚宸插畬鎴愮殑鐜荤拑淇℃伅id:{}", v);
+ updateSlotRemainBySlots(outSuccessGlassSlot);
+ } else if (e1 == 3) {
+ //鐮存崯澶勭悊
+ dealDamageOutTask(v);
+ } else {
+ //娓呯┖鐞嗙墖绗肩┖鏁版嵁
+ noDealOutTask(v);
+ }
+ });
+ for (BigStorageCageTask item : outTaskList) {
+ //鏇存柊鍘嗗彶浠诲姟琛ㄤ腑鐨勪换鍔＄姸鎬�
+ bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<BigStorageCageHistoryTask>()
+ .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<TemperingGlassInfo>()
+ .set(TemperingGlassInfo::getState, Const.TEMPERING_OUT).eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
+ } else if (taskState == 3) {
+// temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
+ temperingGlassInfoService.update(new LambdaUpdateWrapper<TemperingGlassInfo>()
+ .set(TemperingGlassInfo::getState, Const.TEMPERING_DAMAGE
+ ).eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
+
+ } else {
+// 绌烘墽琛�
+ }
+ }
+// 閲嶇疆浠诲姟琛ㄦ暟鎹�
+ bigStorageCageTaskService.updateOutTaskMessage("big_storage_cage_out_one_task");
+ //娓呯┖鍚姩鐘舵��
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0));
+ }
+
+ private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
+// 鑾峰彇杩涚墖浠诲姟琛ㄤ腑鐘舵�佷负鐮存崯鐨勬暟鎹�
+ log.info("鐮存崯鐨勭幓鐠冧俊鎭湁锛歿}", damageTaskList);
+ //绉婚櫎鐞嗙墖绗艰鎯呰〃浠诲姟鎵ц杩囩▼涓牬鎹熺殑鐜荤拑
+ bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
+ .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW)
+ .in(BigStorageCageDetails::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);
+ //绉婚櫎鐞嗙墖绗艰鎯呰〃浠诲姟鎵ц杩囩▼涓牬鎹熺殑鐜荤拑
+ bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
+ .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)
+ .in(BigStorageCageDetails::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);
+ //绉婚櫎鐞嗙墖绗艰鎯呰〃鏈墽琛屼换鍔＄殑绌鸿褰曚俊鎭�
+ bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
+ .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW)
+ .in(BigStorageCageDetails::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());
+ bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
+ .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .in(BigStorageCageDetails::getGlassId, glassList));
+
+ } else {
+ //璋冨害浠诲姟锛氬皢璋冨害涓姸鎬佹敼涓哄湪绗煎唴锛屾牸瀛愬彿鎭㈠涓鸿皟搴﹀墠鐨勬牸瀛�
+ for (BigStorageCageTask item : noDealTaskList) {
+ bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
+ .set(BigStorageCageDetails::getSlot, item.getStartSlot())
+ .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .eq(BigStorageCageDetails::getGlassId, item.getGlassId()));
+ }
+ }
+ //灏嗙牬鎹熶俊鎭柊澧炲叆鐮存崯琛�
+ List<Integer> slotList = new ArrayList<>();
+ for (BigStorageCageTask item : noDealTaskList) {
+ slotList.add(item.getTargetSlot());
+ slotList.add(item.getStartSlot());
+ }
+ //鏇存柊鏍煎瓙鍓╀綑瀹藉害
+ updateSlotRemainBySlots(slotList);
+ log.info("鍑虹墖浠诲姟-鏃犲姩浣滄墽琛屽畬鎴�");
+ }
+
+ /**
+ * 鍑虹墖涓�娆′粎鐢熸垚涓�杞︾幓鐠�
+ *
+ * @param list
+ * @param <T>
+ * @return
+ */
+ private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName, int targetSlot, int state, int taskType) {
+ //浠诲姟鏁版嵁:鑾峰彇杞﹀瓙瀛樻斁鐜荤拑鏈�澶ф暟閲�,鐜荤拑闂撮殧
+ List<BigStorageCageTask> 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<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("big_storage_cage_out_one_task");
+ bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList);
+ List<BigStorageCageHistoryTask> 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<BigStorageCageDetails>()
+ .set(BigStorageCageDetails::getState, state)
+ .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<Integer> slotList) {
//鑾峰彇鏍煎瓙鍐呮墍鏈夌殑鐜荤拑淇℃伅
@@ -318,7 +584,7 @@
.in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
Map<Integer, Double> slotRemainMap = new HashMap<>();
//鏄惁瀛樺湪鏈夋牸瀛愰潪绌虹殑鐜荤拑
- if (CollectionUtils.isNotEmpty(inSlotGlassList)) {
+ if (CollectionUtil.isNotEmpty(inSlotGlassList)) {
//瀛樺湪 灏嗘牸瀛愬唴鐨勭幓鐠冨垎鍒繘琛屾洿鏂�
slotRemainMap = inSlotGlassList.stream()
.collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap)));
@@ -331,7 +597,7 @@
//杩囨护涓嶅瓨鍦ㄧ幓鐠冪殑鏍煎瓙 灏嗗搴﹂噸缃负鍘熷瀹藉害5000
Set<Integer> remainSlotList = slotRemainMap.keySet();
slotList.removeAll(remainSlotList);
- if (CollectionUtils.isNotEmpty(slotList)) {
+ if (CollectionUtil.isNotEmpty(slotList)) {
bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
.in(BigStorageCage::getSlot, slotList));
}
--
Gitblit v1.8.0