From 0aacd330fca570ab3350aef5bda901f23aee23b3 Mon Sep 17 00:00:00 2001
From: wangfei <3597712270@qq.com>
Date: 星期三, 20 十一月 2024 13:51:00 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'
---
hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java | 645 +++++++++++++++++++++++++++++++++++++++++-----------------
1 files changed, 458 insertions(+), 187 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 b51000b..000af98 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,27 +1,37 @@
package com.mes.job;
+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.runner.subscription.SubscriptionCallback;
+import com.github.yulichang.toolkit.JoinWrappers;
+import com.github.yulichang.wrapper.MPJLambdaWrapper;
+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.SlotSequenceDTO;
+import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
-import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
-import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
+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.bigstoragetask.service.BigStorageCageFeedTaskService;
-import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
-import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
+import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
+import com.mes.temperingglass.entity.TemperingGlass;
import com.mes.temperingglass.entity.TemperingGlassInfo;
-import com.mes.temperingglass.service.TemperingGlassInfoService;
+import com.mes.temperingglass.service.TemperingGlassService;
+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;
@@ -38,32 +48,26 @@
@Component
@Slf4j
public class OpcPlcStorageCageTask {
-
- @Resource
- private BigStorageCageService bigStorageCageService;
@Resource
private BigStorageCageDetailsService bigStorageCageDetailsService;
@Resource
- private GlassInfoService glassInfoService;
- @Resource
- private BigStorageCageFeedTaskService bigStorageCageFeedTaskService;
- @Resource
- private BigStorageCageOutTaskService bigStorageCageOutTaskService;
- @Resource
- private EdgGlassTaskInfoService edgGlassTaskInfoService;
- @Resource
- private TemperingGlassInfoService temperingGlassInfoService;
+ private TemperingGlassService temperingGlassService;
@Resource
private DamageService damageService;
+ @Resource
+ private GlassInfoService glassInfoService;
+ @Resource
+ private BigStorageCageService bigStorageCageService;
+ @Resource
+ private BigStorageCageHistoryTaskService bigStorageCageHistoryTaskService;
+ @Resource
+ private BigStorageCageTaskService bigStorageCageTaskService;
@Autowired(required = false)
MiloService miloService;
- @Resource(name = "bigStorageStartCallback")
- SubscriptionCallback bigStorageStartCallback;
-
- @Value("${mes.carWidth}")
- private Integer carWidth;
+ @Resource
+ private RedisUtil redisUtil;
@Value("${mes.slotWidth}")
private Integer slotWidth;
@@ -71,200 +75,461 @@
@Value("${mes.glassGap}")
private Integer glassGap;
- @Scheduled(fixedDelay = Long.MAX_VALUE)
- public void startOpcTask() throws Exception {
- //璁惧涓�浜岀殑杩涚墖璇锋眰
- miloService.subscriptionFromOpcUa(Arrays.asList("my.device01.x1", "my.device02.x1"), bigStorageStartCallback);
+ @Value("${mes.carWidth}")
+ private Integer carWidth;
+
+ @Value("${mes.outCarMaxSize}")
+ private Integer outCarMaxSize;
+
+ @Value("${mes.sequence.order}")
+ private boolean sequenceOrder;
+
+
+ @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<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task");
+ if (CollectionUtils.isEmpty(inTaskList)) {
+ log.info("褰撳墠澶ц溅鏃犺繘鐗囩幓鐠冿紝缁撴潫杩涚墖浠诲姟");
+ }
+ List<String> glassIdList = inTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
+ log.info("鑾峰彇浠诲姟鐨勭幓鐠僫d锛歿}", glassIdList);
+ 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 (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()));
+ 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.setGap(glassGap);
+ cageDetails.setId(null);
+ bigStorageCageDetailsService.save(cageDetails);
+ }
+ //鍘嗗彶鏁版嵁鍏ュ簱
+ bigStorageCageHistoryTaskService.saveBatch(historyTasks);
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1));
}
- @Scheduled(fixedDelay = Long.MAX_VALUE)
- public void outOpcTask() throws Exception {
- //璁惧1鐨勫嚭鐗囪姹�
- miloService.subscriptionFromOpcUa(Arrays.asList("my.device03.x1"), bigStorageStartCallback);
- }
-
-
- @Scheduled(fixedDelay = 300)
- public void updateInGlassStateTask() {
+ @Scheduled(fixedDelay = 1000)
+ public void outBigStorageTask() throws Exception {
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_NEW));
- if (CollectionUtils.isNotEmpty(list)) {
- log.info("2銆佽幏鍙栨墍鏈夋鍦ㄨ繘鐗囩殑鐜荤拑淇℃伅id:{}", list);
- List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
- List<BigStorageCageFeedTask> inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
- .in(BigStorageCageFeedTask::getGlassId, glassIds)
- .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT));
- if (CollectionUtils.isNotEmpty(inSuccessGlass)) {
- log.info("3銆佽幏鍙栬繘鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", inSuccessGlass);
- List<Integer> inSuccessGlassSlot = inSuccessGlass.stream().map(BigStorageCageFeedTask::getTargetSlot).collect(Collectors.toList());
- List<UpdateBigStorageCageDTO> storageCageDTOList = inSuccessGlass.stream().map(e -> {
+ 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 (CollectionUtils.isNotEmpty(outTaskList)) {
+ log.info("鏈夋鍦ㄦ墽琛岀殑鍑虹墖浠诲姟锛岀粨鏉熸湰娆″嚭鐗囦换鍔�");
+ return;
+ }
+ //todo:鏄惁鍏佽閽㈠寲
+ if (redisUtil.getCacheObject("temperingSwitch")) {
+ //鏄惁鏈夋鍦ㄩ挗鍖栫殑鐜荤拑:閽㈠寲灏忕墖琛ㄥ叧鑱斿巻鍙蹭换鍔¤〃锛岀瓫閫夋湭鍑虹鐨勭幓鐠冧俊鎭�
+ List<TemperingGlass> temperingGlassList = temperingGlassService.selectJoinList(TemperingGlass.class, new MPJLambdaWrapper<TemperingGlass>()
+ .selectAll(TemperingGlass.class)
+ .leftJoin(BigStorageCageHistoryTask.class, BigStorageCageHistoryTask::getGlassId, TemperingGlass::getGlassId)
+ .eq(TemperingGlass::getState, Const.TEMPERING_NEW)
+ .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_OUT)
+ .isNull(BigStorageCageHistoryTask::getGlassId)
+ .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlass::getTemperingFeedSequence));
+ //todo:鍘嗗彶浠诲姟琛�
+ if (CollectionUtils.isNotEmpty(temperingGlassList)) {
+ log.info("鏈夋鍦ㄥ嚭鐗囩殑閽㈠寲浠诲姟");
+ computeOutGlassInfo(temperingGlassList, "big_storage_cage_out_one_task", Const.TEMPERING_OUT_TARGET_POSITION, 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 (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
+ //鐜荤拑鍒伴綈鍖呮嫭宸插嚭鐗囩殑
+ //鍒伴綈锛屽皢鐜荤拑灏忕墖鏁版嵁瀛樺叆閽㈠寲灏忕墖琛紝閫昏緫鐢熸垚鍑虹墖浠诲姟 缁撴潫
+ for (TemperingLayoutDTO item : temperingLayoutDTOList) {
+// if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) {
+ List<TemperingGlass> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlass.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 (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
+ temperingGlassService.saveBatch(temperingGlassInfos);
+ computeOutGlassInfo(temperingGlassInfos, "big_storage_cage_out_one_task", Const.TEMPERING_OUT_TARGET_POSITION, 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)
+ .orderByDesc(BigStorageCageDetails::getId));
+ if (CollectionUtils.isNotEmpty(artificialList)) {
+ computeOutGlassInfo(artificialList, "big_storage_cage_out_one_task", Const.ARTIFICIAL_OUT_TARGET_POSITION, 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 (CollectionUtils.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 (CollectionUtils.isNotEmpty(list)) {
+ computeOutGlassInfo(list, "big_storage_cage_out_one_task", second.getSlot(), Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH);
+ }
+ updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
+ 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)) {
+ log.info("褰撳墠澶ц溅鏃犺繘鐗囩幓鐠冿紝缁撴潫瀹屾垚杩涚墖浠诲姟");
+ return;
+ }
+ List<BigStorageCageTask> unFinishTaskList = inTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
+ if (CollectionUtils.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<UpdateBigStorageCageDTO> 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:{}", inSuccessGlass);
- //鏇存柊鐞嗙墖绗肩幓鐠冨昂瀵�
+ log.info("4銆佸ぇ鐞嗙墖绗艰繘鐗囩姸鎬佸凡瀹屾垚宸插畬鎴愮殑鐜荤拑淇℃伅id:{}", v);
updateSlotRemainBySlots(inSuccessGlassSlot);
- log.info("5銆佸ぇ鐞嗙墖绗艰繘鐗囩洰鏍囨牸瀛愬昂瀵告洿鏂板畬鎴�");
+ } else if (e1 == 3) {
+ //鐮存崯澶勭悊
+ dealDamageInTask(v);
+ } else {
+ //娓呯┖鐞嗙墖绗肩┖鏁版嵁
+ noDealInTask(v);
}
-
+ });
+ 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);
}
- Date endDate = new Date();
- log.info("end:澶х悊鐗囩杩涚墖瀹屾垚鍚庢洿鏂板ぇ鐞嗙墖绗兼暟鎹换鍔＄粨鏉熸椂闂达細{}锛屽叡鑰楁椂锛歿}ms,缁撴潫浠诲姟", endDate, endDate.getTime() - startDate.getTime());
- return;
-
+ //娓呯┖鍚姩鐘舵��
+ //鍚憃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())
- );
- }
+ @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 (CollectionUtils.isEmpty(outTaskList)) {
+ log.info("褰撳墠澶ц溅鏃犺繘鐗囩幓鐠冿紝缁撴潫瀹屾垚杩涚墖浠诲姟");
+ return;
+ }
+ List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
+ if (CollectionUtils.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());
}
- log.info("3銆佽幏鍙栧嚭鐗囧凡瀹屾垚鐨勭幓鐠冧俊鎭痠d:{}", outSuccessGlass);
- List<UpdateBigStorageCageDTO> storageCageDTOList = outSuccessGlass.stream().map(e -> {
+ List<UpdateBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
storageCageDTO.setGlassId(e.getGlassId());
- storageCageDTO.setTargetSlot(e.getStartSlot());
+ 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);
- List<Integer> outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList());
- log.info("4銆佸ぇ鐞嗙墖绗煎嚭鐗囩姸鎬佸凡瀹屾垚宸插畬鎴愮殑鐜荤拑淇℃伅id:{}", outSuccessGlass);
- //鏇存柊鐞嗙墖绗肩幓鐠冨昂瀵�
- updateSlotRemainBySlots(outSuccessSlotList);
- log.info("5銆佸ぇ鐞嗙墖绗艰繘鐗囩洰鏍囨牸瀛愬昂瀵告洿鏂板畬鎴�");
+ bigStorageCageDetailsService.updateBySlot(storageCageDTOList, finalTaskType);
+ 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()));
}
- Date endDate = new Date();
- log.info("end:澶х悊鐗囩鍑虹墖瀹屾垚鍚庢洿鏂板ぇ鐞嗙墖绗兼暟鎹换鍔＄粨鏉熸椂闂达細{}锛屽叡鑰楁椂锛歿}ms,缁撴潫浠诲姟", endDate, endDate.getTime() - startDate.getTime());
- return;
-
+ //娓呯┖浠诲姟琛ㄦ暟鎹�
+ bigStorageCageTaskService.removeAll("big_storage_cage_out_one_task");
+ //娓呯┖鍚姩鐘舵��
+ //鍚憃pc鍙戦�佸惎鍔ㄤ俊鍙�
+ miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0));
}
- @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()));
- updateSlotRemainBySlots(slotList);
- log.info("5銆佸ぇ鐞嗙墖绗艰繘鐗囩洰鏍囨牸瀛愬昂瀵告洿鏂板畬鎴�");
+ 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()));
}
}
- Date endDate = new Date();
- log.info("end:澶х悊鐗囩鍑虹墖瀹屾垚鍚庢洿鏂板ぇ鐞嗙墖绗兼暟鎹换鍔＄粨鏉熸椂闂达細{}锛屽叡鑰楁椂锛歿}ms,缁撴潫浠诲姟", endDate, endDate.getTime() - startDate.getTime());
- return;
-
+ //灏嗙牬鎹熶俊鎭柊澧炲叆鐮存崯琛�
+ 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
*/
- @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());
+ 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;
}
- //鏇存柊鏍煎瓙鍓╀綑瀹藉害
- updateSlotRemainBySlots(slotList);
- log.info("杩涚墖浠诲姟鎵ц瀹屾垚");
+ //璁＄畻褰撳墠鍑虹墖杞﹀墿灏哄
+ remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap;
+ bigStorageCageTaskList.add(new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot,
+ 0));
}
- //鑾峰彇鍑虹墖浠诲姟琛ㄤ腑鐘舵�佷负鐮存崯鐨勬暟鎹�
- 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());
- }
- //鏇存柊鏍煎瓙鍓╀綑瀹藉害
- updateSlotRemainBySlots(slotList);
- log.info("鍑虹墖浠诲姟鎵ц瀹屾垚");
+ Assert.isFalse(CollectionUtils.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));
}
- Date endDate = new Date();
- log.info("澶х悊鐗囩鐮存崯鐜荤拑娓呴櫎浠诲姟缁撴潫鏃堕棿锛歿}锛屽叡鑰楁椂锛歿}ms,缁撴潫鎵爜浠诲姟", endDate, endDate.getTime() - startDate.getTime());
- return;
+ 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));
+ return Boolean.TRUE;
}
+
public void updateSlotRemainBySlots(List<Integer> slotList) {
//鑾峰彇鏍煎瓙鍐呮墍鏈夌殑鐜荤拑淇℃伅
@@ -291,5 +556,11 @@
}
}
-
+ private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) {
+ return ReadWriteEntity.builder()
+ .identifier(identifier)
+ //Kep涓槸Long绫诲瀷锛屽嵆锛欼nt32锛孞ava涓殑int绫诲瀷
+ .value(value)
+ .build();
+ }
}
\ No newline at end of file
--
Gitblit v1.8.0