From 09402133807b1e774e658a13ad365b2e6efca25b Mon Sep 17 00:00:00 2001
From: wangfei <3597712270@qq.com>
Date: 星期一, 21 四月 2025 16:06:34 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'
---
hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassNewTask.java | 755 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 755 insertions(+), 0 deletions(-)
diff --git a/hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassNewTask.java b/hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassNewTask.java
new file mode 100644
index 0000000..0f83952
--- /dev/null
+++ b/hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassNewTask.java
@@ -0,0 +1,755 @@
+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.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.kangaroohy.milo.model.ReadWriteEntity;
+import com.kangaroohy.milo.service.MiloService;
+import com.mes.common.config.Const;
+import com.mes.common.config.ConstSysConfig;
+import com.mes.damage.service.DamageService;
+import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
+import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
+import com.mes.edgstoragecage.entity.EdgStorageCage;
+import com.mes.edgstoragecage.entity.EdgStorageCageDetails;
+import com.mes.edgstoragecage.service.EdgStorageCageDetailsService;
+import com.mes.edgstoragecage.service.EdgStorageCageService;
+import com.mes.glassinfo.entity.GlassInfo;
+import com.mes.glassinfo.service.GlassInfoService;
+import com.mes.opctask.entity.EdgStorageDeviceTask;
+import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;
+import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService;
+import com.mes.opctask.service.EdgStorageDeviceTaskService;
+import com.mes.sysconfig.service.SysConfigService;
+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.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @Author : zhoush
+ * @Date: 2024/10/10 8:05
+ * @Description:
+ */
+@Component
+@Slf4j
+public class OpcCacheGlassNewTask {
+
+ private static final String EDG_STORAGE_DEVICE_ONE_TASK = "edg_storage_device_one_task";
+
+ private static final String EDG_STORAGE_DEVICE_TWO_TASK = "edg_storage_device_two_task";
+
+ @Autowired(required = false)
+ MiloService miloService;
+
+ @Resource
+ EdgStorageDeviceTaskService edgStorageDeviceTaskService;
+ @Autowired
+ EdgGlassTaskInfoService edgGlassTaskInfoService;
+ @Resource
+ GlassInfoService glassInfoService;
+ @Resource
+ EdgStorageCageDetailsService edgStorageCageDetailsService;
+ @Resource
+ EdgStorageCageService edgStorageCageService;
+ @Resource
+ EdgStorageDeviceTaskHistoryService edgStorageDeviceTaskHistoryService;
+ @Resource
+ DamageService damageService;
+ @Resource
+ SysConfigService sysConfigService;
+
+ // @Value("${mes.threshold}")
+ private int threshold;
+ // @Value("${mes.cellLength}")
+ private int cellLength;
+ // @Value("${mes.ratio}")
+ private int ratio;
+
+ // @Value("${mes.min.one.firstLength}")
+ private int minOneFirstLength;
+ //
+// @Value("${mes.min.one.secondLength}")
+ private int minOneSecondLength;
+ //
+// @Value("${mes.min.two.firstLength}")
+ private int minTwoFirstLength;
+ //
+// @Value("${mes.min.two.secondLength}")
+ private int minTwoSecondLength;
+ //
+// @Value("${mes.max.firstLength}")
+ private int maxTwoFirstLength;
+ //
+// @Value("${mes.max.secondLength}")
+ private int maxTwoSecondLength;
+ //
+// @Value("${mes.maxThickness}")
+ private int maxThickness;
+
+ private String glassInIdOne = "";
+ private String glassInIdTwo = "";
+ private String glassIdOne = "";
+ private String glassIdTwo = "";
+
+ @Scheduled(fixedDelay = 1000)
+ public void startOneOpcTask() throws Exception {
+ //鑾峰彇绗簩鏉＄嚎璺殑鍗у紡鐞嗙墖绗肩姸鎬�
+ ReadWriteEntity twoInkageEntity = miloService.readFromOpcUa("WL2.WL2.deviceState");
+ //榛樿鍙窇涓�鍙板崸寮忕悊鐗�,涓ゆ潯绾胯矾閮藉彲浠ヨ蛋
+ int cellFlag = 1;
+ //濡傛灉涓ゆ潯绾块兘鍚姩鍒欏彧鑳借窇涓�鏉＄嚎
+ if (twoInkageEntity != null && !Boolean.parseBoolean(twoInkageEntity.getValue() + "")) {
+ cellFlag = 2;
+ }
+ startOneOpcTaskChild(EDG_STORAGE_DEVICE_ONE_TASK, 1, cellFlag);
+ }
+
+ @Scheduled(fixedDelay = 1000)
+ public void startTwoOpcTask() throws Exception {
+ ReadWriteEntity oneInkageEntity = miloService.readFromOpcUa("WL1.WL1.deviceState");
+ int cellFlag = 1;
+ if (oneInkageEntity != null && !Boolean.parseBoolean(oneInkageEntity.getValue() + "")) {
+ cellFlag = 2;
+ }
+ startOneOpcTaskChild(EDG_STORAGE_DEVICE_TWO_TASK, 2, cellFlag);
+ }
+
+ private void startOneOpcTaskChild(String tableName, int device, int cellFlag) throws Exception {
+ threshold = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_THRESHOLD);
+ cellLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_CELL_LENGTH);
+ ratio = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_RATIO);
+ minOneFirstLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MIN_ONE_FIRST_LENGTH);
+ minOneSecondLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MIN_ONE_SECOND_LENGTH);
+ minTwoFirstLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MIN_TWO_FIRST_LENGTH);
+ minTwoSecondLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MIN_TWO_SECOND_LENGTH);
+ maxTwoFirstLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MAX_FIRST_LENGTH);
+ maxTwoSecondLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MAX_SECOND_LENGTH);
+ maxThickness = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MAX_THICKNESS);
+
+ EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(tableName);
+ if (task == null) {
+ log.info("浠诲姟琛ㄥ熀纭�鏁版嵁褰曞叆澶辫触锛岃妫�鏌ユ暟鎹槸鍚﹀綍鍏ユ垚鍔�");
+ return;
+ }
+ if (task.getTaskState() == 2) {
+ //闃叉鍑虹墖浠诲姟涓旂鍓嶆湁鐜荤拑鐨勬儏鍐碉紝灏嗚繘鐗噄d缃┖锛屽嵆鍑虹墖浠呰�冭檻绗煎唴鐨勭幓鐠�
+ task.setGlassIdIn("");
+ }
+ int request = task.getTaskState();
+ int taskRunning = task.getTaskRunning();
+ log.info("寮�濮嬫墽琛屼换鍔★紝浠诲姟璇蜂俊鎭负{}", task);
+ if (request == 0) {
+ log.info("璁惧锛歿}鐘舵�侊細{}", device, request);
+ log.info("鏈敹鍒颁换鍔¤姹傦紝缁撴潫鏈浠诲姟");
+ } else if (request == 1 && taskRunning == 0) {
+ //杩涚墖浠诲姟
+ log.info("璁惧锛歿}鐘舵�侊細{}", device, request);
+ log.info("杩涚墖浠诲姟锛氳繘鐗囩幓鐠僫d涓猴細{}", task.getGlassIdIn());
+ intoTask(task, tableName, device);
+ } else if (request == 2 && taskRunning == 0) {
+ //鍑虹墖浠诲姟
+ outTask(task, tableName, device, cellFlag);
+ } else if (request == 3 && taskRunning == 0) {
+ //鐩撮�氫换鍔�
+ log.info("璁惧锛歿}鐘舵�侊細{}", device, request);
+ if (!outTask(task, tableName, device, cellFlag)) {
+ intoTask(task, tableName, device);
+ }
+ } else if (request == 4) {
+ log.info("璁惧锛歿}鐘舵�侊細{}", device, request);
+ log.info("灏嗗惎鍔ㄥ瓙鏀逛负4");
+ task.setTaskRunning(Const.GLASS_CACHE_TYPE_RUNNING);
+ edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
+ } else if (request == 5) {
+ log.info("璁惧锛歿}鐘舵�侊細{}", device, request);
+ finishTask(task, tableName, device);
+ } else {
+ log.info("鐜荤拑寮傚父澶勭悊");
+ damageTask(task, tableName, device);
+ }
+// } catch(Exception e)
+//
+// {
+// log.info("鎵ц浠诲姟杩囩▼涓彂鐢熷紓甯革紝浠诲姟瀛梴}锛寋}", task.getTaskState(), e.getMessage());
+// log.info("灏嗗惎鍔ㄥ瓧鏀逛负0");
+// task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
+// edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
+// }
+
+ }
+
+
+ @Scheduled(fixedDelay = 1000)
+ public void edgOneOpcTask() throws Exception {
+ EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(EDG_STORAGE_DEVICE_ONE_TASK);
+ String glassId = task.getGlassId();
+ if (StringUtils.isBlank(glassId) || glassId.equals(glassIdOne)) {
+ log.info("{}鍙风嚎纾ㄨ竟鍓嶇幓鐠冩湭灏变綅锛岀粨鏉熸湰娆′换鍔�", 1);
+ return;
+ }
+ edgTaskChild(glassId, 1);
+ }
+
+ @Scheduled(fixedDelay = 1000)
+ public void edgTwoOpcTask() throws Exception {
+ EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(EDG_STORAGE_DEVICE_TWO_TASK);
+ String glassId = task.getGlassId();
+ if (StringUtils.isBlank(glassId) || glassId.equals(glassIdTwo)) {
+ log.info("{}鍙风嚎纾ㄨ竟鍓嶇幓鐠冩湭灏变綅锛岀粨鏉熸湰娆′换鍔�", 2);
+ return;
+ }
+ edgTaskChild(glassId, 2);
+ }
+
+ private void edgTaskChild(String glassId, int cell) throws Exception {
+ ratio = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_RATIO);
+ GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId).last("limit 1"));
+ if (glassInfo == null) {
+ log.info("瀵瑰垪琛ㄤ腑鐨勭幓鐠僫d閿欒锛岃妫�鏌ユ暟鎹紝鐜荤拑id锛歿}", glassId);
+ return;
+ }
+ String toEndingId = glassInfo.getTemperingLayoutId() + "" + glassInfo.getTemperingFeedSequence();
+ List<ReadWriteEntity> list = new ArrayList<>();
+// list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".mesControl", true));
+ list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".glassId", Integer.parseInt(toEndingId)));
+ list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".toEdingId", Integer.parseInt(toEndingId)));
+ list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".width", (int) Math.max(glassInfo.getWidth() * ratio, glassInfo.getHeight() * ratio)));
+ list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".height", (int) Math.min(glassInfo.getWidth() * ratio, glassInfo.getHeight() * ratio)));
+
+ miloService.writeToOpcUa(list);
+ miloService.writeToOpcWord(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".thickness", (int) glassInfo.getThickness() * ratio));
+ //淇敼纾ㄨ竟瀵瑰垪涓殑纾ㄨ竟绾胯矾鍙婄姸鎬�
+ edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
+ .set(EdgGlassTaskInfo::getLine, cell)
+ .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_START)
+ .set(EdgGlassTaskInfo::getUpdateTime, new Date())
+ .eq(EdgGlassTaskInfo::getGlassId, glassId)
+ .eq(EdgGlassTaskInfo::getState, Const.EDG_GLASS_BEFORE));
+ if (cell == 1) {
+ glassIdOne = glassId;
+ } else {
+ glassIdTwo = glassId;
+ }
+ }
+
+ private boolean intoTask(EdgStorageDeviceTask task, String tableName, int deviceId) {
+ Date startDate = new Date();
+ log.info("寮�濮嬫墽琛岃繘鐗囦换鍔★紝浠诲姟淇℃伅涓猴細{},琛ㄥ悕涓猴細{},璁惧id:{},寮�濮嬫椂闂达細{}", task, tableName, deviceId, startDate);
+ //鑾峰彇鐜荤拑鐨勫熀鏈俊鎭�
+ GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
+ if (null == glassInfo) {
+ log.info("杩涚墖鐜荤拑淇℃伅涓嶅瓨鍦紝鐜荤拑id:{}", task.getGlassIdIn());
+ Date endDate = new Date();
+ log.info("缁撴潫杩涚墖浠诲姟璁惧涓簕}锛岀粨鏉熸椂闂翠负锛歿}锛屽叡鑰楁椂锛歿}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
+ return Boolean.FALSE;
+ }
+ if (glassInIdOne.equals(task.getGlassIdIn()) || glassInIdTwo.equals(task.getGlassIdIn())) {
+ log.info("鐜荤拑id涓庝笂娆＄浉鍚岋紝绂佹杩涚墖");
+ Date endDate = new Date();
+ log.info("缁撴潫杩涚墖浠诲姟璁惧涓簕}锛岀粨鏉熸椂闂翠负锛歿}锛屽叡鑰楁椂锛歿}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
+ return Boolean.FALSE;
+ }
+ int firstLength = minTwoFirstLength;
+ int secondLength = minTwoSecondLength;
+ if (deviceId == 1) {
+ firstLength = minOneFirstLength;
+ secondLength = minOneSecondLength;
+ }
+ if (Math.max(glassInfo.getWidth(), glassInfo.getHeight()) < firstLength || Math.min(glassInfo.getWidth(), glassInfo.getHeight()) < secondLength) {
+ log.info("杩涚墖鐜荤拑灏哄灏忎簬{}*{}锛岀姝㈣繘绗肩幓鐠僫d:{}锛屽昂瀵镐负{}銆亄}", firstLength, secondLength, task.getGlassIdIn(), glassInfo.getWidth(), glassInfo.getHeight());
+ Date endDate = new Date();
+ log.info("缁撴潫杩涚墖浠诲姟璁惧涓簕}锛岀粨鏉熸椂闂翠负锛歿}锛屽叡鑰楁椂锛歿}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
+ return Boolean.FALSE;
+ }
+ EdgStorageCage edgStorageCage = edgStorageCageService.selectNearestEmpty(task.getCurrentCell(), deviceId, Boolean.FALSE);
+ Assert.isTrue(null != edgStorageCage, "鏍煎瓙宸叉弧");
+ log.info("4銆佸皢鐜荤拑淇℃伅鎻掑叆鍗у紡鐞嗙墖绗�,褰撳墠鐜荤拑淇℃伅:{}", glassInfo);
+ EdgStorageCageDetails details = new EdgStorageCageDetails();
+ BeanUtils.copyProperties(glassInfo, details);
+ details.setState(Const.GLASS_STATE_IN);
+ details.setSlot(edgStorageCage.getSlot());
+ details.setDeviceId(edgStorageCage.getDeviceId());
+ edgStorageCageDetailsService.save(details);
+
+ //鏇存柊浠诲姟淇℃伅
+ task.setStartCell(edgStorageCage.getSlot());
+ task.setTaskRunning(Const.GLASS_CACHE_TYPE_IN);
+ edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
+ saveHistoryTask(task, deviceId);
+ //璁板綍杩涚墖浠诲姟鐨勭幓鐠僫d鐢ㄤ簬涓嬫浠诲姟鐨勬瘮杈冿紝闃叉鍚屼竴鍧楃幓鐠冮噸澶嶆墽琛�
+ if (deviceId == 1) {
+ glassInIdOne = task.getGlassIdIn();
+ } else {
+ glassInIdTwo = task.getGlassIdIn();
+ }
+ Date endDate = new Date();
+ log.info("缁撴潫杩涚墖浠诲姟璁惧涓簕}锛岀粨鏉熸椂闂翠负锛歿}锛屽叡鑰楁椂锛歿}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
+ return Boolean.TRUE;
+ }
+
+ private boolean outTask(EdgStorageDeviceTask task, String tableName, int deviceId, int cellFlag) throws Exception {
+ Date startDate = new Date();
+ //鑾峰彇瀵瑰簲鐨勮澶囩姸鎬佷俊鎭�
+ ReadWriteEntity oneOutStateEntity = miloService.readFromOpcUa("WL1.WL1.slotState");
+ ReadWriteEntity twoOutStateEntity = miloService.readFromOpcUa("WL2.WL2.slotState");
+ //鐘舵�佹湁3涓儏鍐碉細0绌洪棽 1蹇欑 2绂佺敤
+ String oneOutState = "2";
+ String twoOutState = "2";
+ if (null != oneOutStateEntity && null != oneOutStateEntity.getValue()) {
+ oneOutState = oneOutStateEntity.getValue().toString();
+ }
+ if (null != twoOutStateEntity && null != twoOutStateEntity.getValue()) {
+ twoOutState = twoOutStateEntity.getValue().toString();
+ }
+
+ if ((cellFlag == 2 && Const.OUT_BUSY.equals(oneOutState) && Const.OUT_BUSY.equals(twoOutState)) || (Const.OUT_DISABLE.equals(oneOutState) && Const.OUT_DISABLE.equals(twoOutState))) {
+ log.info("A09銆丄10涓簕},{}闈炶嚜鍔ㄧ姸鎬侊紝鏃犳硶鍑虹墖", oneOutState, oneOutState);
+ return Boolean.FALSE;
+ }
+ log.info("寮�濮嬫墽琛屽嚭鐗�/鐩撮�氫换鍔★紝浠诲姟淇℃伅涓猴細{},琛ㄥ悕涓猴細{},璁惧id:{},寮�濮嬫椂闂达細{},涓�鍙风嚎鐘舵�侊細{}锛屼簩鍙风嚎鐘舵�侊細{}",
+ task, tableName, deviceId, startDate, oneOutState, twoOutState);
+ //鑾峰彇褰撳墠闇�瑕佽蛋閭ｆ潯绾�
+ int cell = 0;
+ if (cellFlag == 1) {
+ cell = deviceId;
+ } else {
+ if (Const.OUT_FREE.equals(twoOutState)) {
+ cell = Const.TWO_OUT_TARGET_POSITION;
+ } else if (Const.OUT_FREE.equals(oneOutState)) {
+ cell = Const.ONE_OUT_TARGET_POSITION;
+ } else {
+ return Boolean.FALSE;
+ }
+ }
+ if (Const.OUT_FREE.equals(oneOutState) && Const.OUT_FREE.equals(twoOutState)) {
+ if (cellFlag == 2) {
+ if (!outChildTask(task, tableName, deviceId, cell, startDate)) {
+ cell = cell == Const.ONE_OUT_TARGET_POSITION ? Const.TWO_OUT_TARGET_POSITION : Const.ONE_OUT_TARGET_POSITION;
+ return outChildTask(task, tableName, deviceId, cell, startDate);
+ }
+ } else {
+ return outChildTask(task, tableName, deviceId, cell, startDate);
+ }
+ } else {
+ return outChildTask(task, tableName, deviceId, cell, startDate);
+ }
+ return Boolean.TRUE;
+ }
+
+ private boolean outChildTask(EdgStorageDeviceTask task, String tableName, int deviceId, int cell, Date startDate) {
+ EdgStorageCageDetails edgStorageCageDetails = null;
+
+ //绗煎唴鏄増鍥剧浉宸槸鍚﹁秴杩囬槇鍊�
+ boolean flag = queryMaxMinDiffByDevice(threshold, deviceId);
+ if (flag) {
+ //鍏堟壘鏈�灏忕増鍥剧増搴忕殑鐜荤拑灏忕墖
+ EdgStorageCageDetails minEdgDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
+ .inSql(EdgStorageCageDetails::getSlot, "select slot from edg_storage_cage where enable_state = " + Const.SLOT_ON)
+ .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .eq(EdgStorageCageDetails::getDeviceId, deviceId)
+ .orderByAsc(EdgStorageCageDetails::getTemperingLayoutId)
+ .orderByAsc(EdgStorageCageDetails::getTemperingFeedSequence)
+ .last("limit 1"));
+ double maxLength = Math.max(minEdgDetails.getWidth(), minEdgDetails.getHeight());
+ double minLength = Math.min(minEdgDetails.getWidth(), minEdgDetails.getHeight());
+ if ((cell == 1 && maxLength >= minOneFirstLength && minLength >= minOneSecondLength) ||
+ (cell == 2 && maxLength <= maxTwoFirstLength && minLength <= maxTwoSecondLength && minEdgDetails.getThickness() < maxThickness)) {
+ //鐜荤拑灏忕墖鍚屽昂瀵哥殑绂诲綋鍓嶆牸瀛愭渶杩戠殑鐜荤拑灏忕墖
+ edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getWidth, minEdgDetails.getWidth())
+ .eq(EdgStorageCageDetails::getHeight, minEdgDetails.getHeight())
+ .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .eq(EdgStorageCageDetails::getDeviceId, deviceId)
+ .last("order by abs(slot - " + task.getCurrentCell() + ") asc limit 1")
+ );
+ }
+ }
+ if (null == edgStorageCageDetails) {
+// 鑾峰彇鍘嗗彶琛ㄤ腑涓婃浠诲姟鏈�鍚庝竴鐗囧昂瀵�
+ EdgStorageDeviceTaskHistory edgeData = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>()
+ .eq(EdgStorageDeviceTaskHistory::getDeviceId, cell)
+ .in(EdgStorageDeviceTaskHistory::getTaskType, Const.GLASS_CACHE_TYPE_OUT, Const.GLASS_CACHE_TYPE_THROUGH)
+ .orderByDesc(EdgStorageDeviceTaskHistory::getId).last("limit 1"));
+ if (null != edgeData) {
+ GlassInfo glassOutInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, edgeData.getGlassIdOut()));
+ //绗煎唴鐨勭幓鐠冪殑灏哄鏄惁鍜屼笂涓�娆′换鍔′竴鑷�
+ edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(deviceId, task.getCurrentCell(), glassOutInfo.getWidth(), glassOutInfo.getHeight(), cell, maxThickness);
+ if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) {
+ GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
+ .eq(GlassInfo::getGlassId, task.getGlassIdIn())
+ .eq(GlassInfo::getWidth, glassOutInfo.getWidth())
+ .eq(GlassInfo::getHeight, glassOutInfo.getHeight()));
+ if (null != glassInInfo) {
+ if (cell == 2 && glassInInfo.getThickness() < maxThickness) {
+ edgStorageCageDetails = new EdgStorageCageDetails();
+ BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails);
+ }
+ }
+ }
+ }
+ }
+ //鍓嶉潰宸茬粡灏哄闂澶勭悊瀹屾瘯锛屽紑濮嬭绠楁棤鐩稿悓灏哄鐨勬柊鐜荤拑灏忕墖
+ if (null == edgStorageCageDetails) {
+ edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsByLimitSize(deviceId, task.getCurrentCell(), 0, 0,
+ cell, minOneFirstLength, minOneSecondLength, maxTwoFirstLength, maxTwoSecondLength, maxThickness);
+ }
+ if (edgStorageCageDetails == null && StringUtils.isNotBlank(task.getGlassIdIn())) {
+ //鍜屼笂娆′换鍔′笉瀛樺湪鐩稿悓灏哄
+ GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
+
+ double maxLength = Math.max(glassInInfo.getWidth(), glassInInfo.getHeight());
+ double minLength = Math.min(glassInInfo.getWidth(), glassInInfo.getHeight());
+ if ((cell == 1 && maxLength >= minOneFirstLength && minLength >= minOneSecondLength) ||
+ (cell == 2 && maxLength <= maxTwoFirstLength && minLength <= maxTwoSecondLength
+ && maxLength >= minTwoFirstLength && minLength >= minTwoSecondLength && glassInInfo.getThickness() < maxThickness)) {
+ //鐜荤拑灏忕墖鍚屽昂瀵哥殑绂诲綋鍓嶆牸瀛愭渶杩戠殑鐜荤拑灏忕墖
+ edgStorageCageDetails = new EdgStorageCageDetails();
+ BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails);
+ } else {
+ log.info("鐩撮�氫换鍔＄洰鏍囩嚎璺负{},杩涚墖鐜荤拑灏哄涓簕}*{},涓嶇鍚堝嚭鐗囨潯浠�", cell, maxLength, minLength);
+ }
+ }
+ if (edgStorageCageDetails == null) {
+ //鍜屼笂娆′换鍔′笉瀛樺湪鐩稿悓灏哄
+ log.info("绗煎唴娌℃湁鐜荤拑浜�");
+ return Boolean.FALSE;
+ }
+ int taskType = Const.GLASS_CACHE_TYPE_OUT;
+ String glassId = edgStorageCageDetails.getGlassId();
+ if (glassId.equals(task.getGlassIdIn())) {
+ if (3 != task.getTaskState()) {
+ return Boolean.FALSE;
+ }
+ log.info("5銆佺洿閫氫换鍔�,灏嗙幓鐠冧俊鎭彃鍏ュ崸寮忕悊鐗囩,褰撳墠鐜荤拑淇℃伅:{}", edgStorageCageDetails);
+ if (glassInIdOne.equals(task.getGlassIdIn()) || glassInIdTwo.equals(task.getGlassIdIn())) {
+ log.info("鐜荤拑id涓庝笂娆＄浉鍚岋紝绂佹杩涚墖");
+ return Boolean.FALSE;
+ }
+ //鐜荤拑淇℃伅鏇挎崲
+ String glassIdChange = queryAndChangeGlass(glassId);
+ //澶勭悊鍦ㄥ崸鐞嗗唴鐨勭幓鐠冧俊鎭細绗煎唴鐨勬暟鎹鐞�
+ queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange);
+ if (StringUtils.isNotBlank(glassIdChange)) {
+ edgStorageCageDetails = new EdgStorageCageDetails();
+ GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
+ BeanUtils.copyProperties(one, edgStorageCageDetails);
+ }
+ EdgStorageCage storageCage = edgStorageCageService.getOne(new LambdaQueryWrapper<EdgStorageCage>()
+ .eq(EdgStorageCage::getDeviceId, deviceId)
+ .eq(EdgStorageCage::getEnableState, Const.SLOT_ON)
+ .ge(EdgStorageCage::getRemainWidth, cellLength)
+ .last("order by abs(slot - " + task.getCurrentCell() + ") limit 1"));
+ Assert.isTrue(null != storageCage, "鏍煎瓙宸叉弧,鏃犳硶鎵ц鐩撮�氫换鍔�");
+ log.info("3銆佹煡璇㈠崸寮忕悊鐗囩閲岄潰鐨勭┖鏍�:{}", storageCage);
+ edgStorageCageDetails.setSlot(storageCage.getSlot());
+ edgStorageCageDetails.setDeviceId(storageCage.getDeviceId());
+ edgStorageCageDetails.setState(Const.GLASS_STATE_OUT);
+ edgStorageCageDetailsService.save(edgStorageCageDetails);
+ taskType = Const.GLASS_CACHE_TYPE_THROUGH;
+ } else {
+ log.info("5銆侀潪鐩撮�氫换鍔�,灏嗙幓鐠冧俊鎭彃鍏ュ崸寮忕悊鐗囩,褰撳墠鐜荤拑淇℃伅:{}", edgStorageCageDetails);
+ if (!edgStorageCageDetails.getSlot().equals(task.getCurrentCell())) {
+ EdgStorageCageDetails currentGlass = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .eq(EdgStorageCageDetails::getDeviceId, deviceId)
+ .eq(EdgStorageCageDetails::getSlot, task.getCurrentCell()).eq(EdgStorageCageDetails::getWidth, edgStorageCageDetails.getWidth())
+ .eq(EdgStorageCageDetails::getHeight, edgStorageCageDetails.getHeight()).eq(EdgStorageCageDetails::getThickness, edgStorageCageDetails.getThickness())
+ .orderByAsc(EdgStorageCageDetails::getId).last("limit 1")
+ );
+ if (null != currentGlass) {
+ edgStorageCageDetails = currentGlass;
+ }
+ }
+ //鐜荤拑淇℃伅鏇挎崲
+ String glassIdChange = queryAndChangeGlass(edgStorageCageDetails.getGlassId());
+ //澶勭悊鍦ㄥ崸鐞嗗唴鐨勭幓鐠冧俊鎭細绗煎唴鐨勬暟鎹鐞�
+ queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange);
+ LambdaUpdateWrapper<EdgStorageCageDetails> wrapper = new LambdaUpdateWrapper<>();
+ wrapper.eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId()).set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT);
+ edgStorageCageDetailsService.update(wrapper);
+ log.info("5銆佹洿鏂板嚭鐗囩幓鐠冪殑鐘舵�佷负{}", Const.GLASS_STATE_OUT);
+ }
+ //鐢熸垚鍑虹墖浠诲姟
+ task.setGlassIdOut(edgStorageCageDetails.getGlassId());
+ task.setStartCell(edgStorageCageDetails.getSlot());
+ task.setTaskRunning(taskType);
+ task.setEndCell(cell);
+
+ edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
+ saveHistoryTask(task, deviceId);
+ //璁板綍鐩撮�氫换鍔＄殑鐜荤拑id鐢ㄤ簬涓嬫浠诲姟鐨勬瘮杈冿紝闃叉鍚屼竴鍧楃幓鐠冮噸澶嶆墽琛�
+ if (3 == task.getTaskState()) {
+ if (deviceId == 1) {
+ glassInIdOne = edgStorageCageDetails.getGlassId();
+ } else {
+ glassInIdTwo = edgStorageCageDetails.getGlassId();
+ }
+ }
+ //鏇存柊璇︽儏琛ㄤ换鍔″嚭鐗囦腑
+ edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
+ .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT)
+ .eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId()));
+ //纾ㄨ竟瀵瑰垪琛ㄦ柊澧炰竴鏉℃暟鎹�
+ saveGlassSize(edgStorageCageDetails);
+ Date endDate = new Date();
+ log.info("缁撴潫鍑虹墖/鐩撮�氫换鍔¤澶囦负{}锛岀粨鏉熸椂闂翠负锛歿}锛屽叡鑰楁椂锛歿}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
+ return Boolean.TRUE;
+ }
+
+ private boolean finishTask(EdgStorageDeviceTask task, String tableName, int device) {
+ if (task.getTaskState() <= 4) {
+ log.info("鏈夋鍦ㄦ墽琛岀殑浠诲姟鎴栬繖浠诲姟宸叉墽琛屼换鍔＄姸鎬亄}锛屼换鍔″惎鍔ㄦ儏鍐祘}锛岀粨鏉�", task.getTaskState(), task.getTaskRunning());
+ return Boolean.FALSE;
+ }
+ Date startDate = new Date();
+ log.info("寮�濮嬫墽琛屽畬鎴愪换鍔″悗娓呴櫎鍔ㄤ綔锛屼换鍔′俊鎭负锛歿},琛ㄥ悕涓猴細{},寮�濮嬫椂闂达細{}", task, tableName, startDate);
+ task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
+ task.setGlassIdOut("");
+ task.setStartCell(0);
+ task.setEndCell(0);
+ EdgStorageDeviceTaskHistory taskHistory = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>()
+ .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
+ .eq(EdgStorageDeviceTaskHistory::getDeviceId, device)
+ .orderByDesc(EdgStorageDeviceTaskHistory::getCreateTime).last("limit 1"));
+ if (null != taskHistory) {
+ //濡傛灉浠诲姟绫诲瀷涓�1锛�3锛屽皢鍒囧壊瀹屾垚鐨勭幓鐠冭嚜鍔ㄦ姤宸�
+ if (Const.GLASS_CACHE_TYPE_IN_ALL.contains(taskHistory.getTaskType())) {
+ damageService.autoSubmitReport(taskHistory.getGlassIdIn(), taskHistory.getDeviceId(), "鍒囧壊", "杩涘崸鐞�", 1);
+ }
+
+ edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper<EdgStorageDeviceTaskHistory>()
+ .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
+ .eq(EdgStorageDeviceTaskHistory::getDeviceId, device)
+ .set(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS)
+ );
+ }
+ //鏈�鍚庢洿鏂颁换鍔★紝淇濊瘉浠诲姟鍓嶇殑鍔ㄤ綔閮藉仛瀹�
+ edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
+ Date endDate = new Date();
+ log.info("缁撴潫瀹屾垚浠诲姟鍚庢竻闄ゅ姩浣滐紝琛ㄥ悕涓猴細{},缁撴潫鏃堕棿涓猴細{}锛屽叡鑰楁椂锛歿}ms", tableName, endDate, endDate.getTime() - startDate.getTime());
+ return Boolean.TRUE;
+ }
+
+ private boolean damageTask(EdgStorageDeviceTask task, String tableName, int device) {
+ if (task.getTaskState() <= 5) {
+ log.info("浠诲姟鏈彂鐢熷紓甯告竻绌猴紝浠诲姟缁撴潫锛岀數姘旂姸鎬亄},mes鐘舵�亄}", task.getTaskState(), task.getTaskRunning());
+ return Boolean.FALSE;
+ }
+ Date startDate = new Date();
+ log.info("寮�濮嬫墽琛屽紓甯稿鐞嗕换鍔″悗娓呴櫎鍔ㄤ綔锛屼换鍔′俊鎭负锛歿},琛ㄥ悕涓猴細{},寮�濮嬫椂闂达細{}", task, tableName, startDate);
+ EdgStorageDeviceTaskHistory taskHistory = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>()
+ .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
+ .eq(EdgStorageDeviceTaskHistory::getDeviceId, device)
+ .orderByDesc(EdgStorageDeviceTaskHistory::getCreateTime).last("limit 1"));
+ if (null != taskHistory) {
+ Integer cell = taskHistory.getStartCell();
+ Integer taskType = taskHistory.getTaskType();
+ if (Const.GLASS_CACHE_TYPE_IN_ALL.contains(taskType)) {
+ String glassId = taskHistory.getGlassIdIn();
+ edgStorageCageDetailsService.remove(new LambdaQueryWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getDeviceId, device)
+ .eq(EdgStorageCageDetails::getSlot, cell)
+ .eq(EdgStorageCageDetails::getGlassId, glassId));
+ } else {
+ String glassId = taskHistory.getGlassIdOut();
+ edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
+ .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
+ .eq(EdgStorageCageDetails::getDeviceId, device)
+ .eq(EdgStorageCageDetails::getSlot, cell)
+ .eq(EdgStorageCageDetails::getGlassId, glassId));
+ }
+
+ edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper<EdgStorageDeviceTaskHistory>()
+ .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
+ .eq(EdgStorageDeviceTaskHistory::getDeviceId, device)
+ .set(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_FAILURE)
+ );
+ }
+ //鏈�鍚庢洿鏂颁换鍔★紝淇濊瘉浠诲姟鍓嶇殑鍔ㄤ綔閮藉仛瀹�
+ task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
+ task.setGlassIdOut("");
+ task.setStartCell(0);
+ task.setEndCell(0);
+ edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
+ Date endDate = new Date();
+ log.info("瀹屾垚鎵ц寮傚父澶勭悊浠诲姟鍚庢竻闄ゅ姩浣滐紝琛ㄥ悕涓猴細{},缁撴潫鏃堕棿涓猴細{}锛屽叡鑰楁椂锛歿}ms", tableName, endDate, endDate.getTime() - startDate.getTime());
+ return Boolean.TRUE;
+
+ }
+
+ /**
+ * 鏌ヨ鐜荤拑骞惰繘琛屼氦鎹�
+ *
+ * @param glassId
+ * @return
+ */
+ public String queryAndChangeGlass(String glassId) {
+ GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
+// .inSql(GlassInfo::getEngineerId, "select engineer_id from engineering where state = 1"));
+ Assert.isFalse(null == glassInfo, "鐜荤拑淇℃伅涓嶅瓨鍦�"); //鎸夌収鐜荤拑灏哄
+ LambdaQueryWrapper<GlassInfo> queryWrapper = new LambdaQueryWrapper<GlassInfo>()
+ .eq(GlassInfo::getWidth, glassInfo.getWidth())
+ .eq(GlassInfo::getHeight, glassInfo.getHeight())
+ .eq(GlassInfo::getThickness, glassInfo.getThickness())
+ .eq(GlassInfo::getFilmsid, glassInfo.getFilmsid())
+ .eq(GlassInfo::getFlowCardId, glassInfo.getFlowCardId())
+ .eq(GlassInfo::getTotalLayer, glassInfo.getTotalLayer())
+ .eq(GlassInfo::getLayer, glassInfo.getLayer())
+ .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
+ .notInSql(GlassInfo::getGlassId, "select distinct glass_id from edg_storage_cage_details " +
+ "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight()
+ + " and state != 100")
+ .orderByAsc(GlassInfo::getTemperingLayoutId)
+ .orderByAsc(GlassInfo::getTemperingFeedSequence)
+ .last("Limit 1");
+ GlassInfo swapGlassInfo = glassInfoService.getOne(queryWrapper);
+ if (swapGlassInfo != null && !glassInfo.getGlassId().equals(swapGlassInfo.getGlassId())) {
+ //寰呮浛鎹㈢殑鐜荤拑淇℃伅
+ Integer ishorizontal = glassInfo.getIshorizontal();
+ Integer temperingLayoutId = glassInfo.getTemperingLayoutId();
+ Integer temperingFeedSequence = glassInfo.getTemperingFeedSequence();
+ Integer xCoordinate = glassInfo.getXCoordinate();
+ Integer yCoordinate = glassInfo.getYCoordinate();
+ double angle = glassInfo.getAngle();
+ Integer ruleId = glassInfo.getRuleId();
+ //鏇挎崲鍚庣殑鐜荤拑淇℃伅
+ Integer swapIshorizontal = swapGlassInfo.getIshorizontal();
+ Integer swapTemperingLayoutId = swapGlassInfo.getTemperingLayoutId();
+ Integer swapTemperingFeedSequence = swapGlassInfo.getTemperingFeedSequence();
+ Integer swapXCoordinate = swapGlassInfo.getXCoordinate();
+ Integer swapYCoordinate = swapGlassInfo.getYCoordinate();
+ double swapAngle = swapGlassInfo.getAngle();
+ Integer swapRuleId = swapGlassInfo.getRuleId();
+ //鏇挎崲鐜荤拑淇℃伅
+ glassInfo.setIshorizontal(swapIshorizontal);
+ glassInfo.setTemperingLayoutId(swapTemperingLayoutId);
+ glassInfo.setTemperingFeedSequence(swapTemperingFeedSequence);
+ glassInfo.setXCoordinate(swapXCoordinate);
+ glassInfo.setYCoordinate(swapYCoordinate);
+ glassInfo.setAngle(swapAngle);
+ glassInfo.setRuleId(swapRuleId);
+
+ swapGlassInfo.setIshorizontal(ishorizontal);
+ swapGlassInfo.setTemperingLayoutId(temperingLayoutId);
+ swapGlassInfo.setTemperingFeedSequence(temperingFeedSequence);
+ swapGlassInfo.setXCoordinate(xCoordinate);
+ swapGlassInfo.setYCoordinate(yCoordinate);
+ swapGlassInfo.setAngle(angle);
+ swapGlassInfo.setRuleId(ruleId);
+
+ log.info("灏嗙幓鐠儃}鍜岀幓鐠儃}锛屼俊鎭簰鎹�(鍘熺墖搴忓彿鍙婂潗鏍囬櫎澶�),杩涚幓鐠� {}", glassInfo, swapGlassInfo, swapGlassInfo);
+ glassInfoService.updateById(swapGlassInfo);
+ glassInfoService.updateById(glassInfo);
+ return swapGlassInfo.getGlassId();
+ }
+ return "";
+ }
+
+
+ /**
+ * 鏌ヨ鍗у紡鐞嗙墖鐜荤拑骞惰繘琛屼氦鎹�
+ *
+ * @param glassId
+ * @return
+ */
+ public void queryEdgAndChangeGlass(String glassId, String swapGlassId) {
+ if (StringUtils.isBlank(swapGlassId)) {
+ log.info("褰撳墠鍑虹鐜荤拑涓嶅瓨鍦ㄩ渶瑕佹浛鎹㈢殑鐜荤拑");
+ return;
+ }
+ //鑾峰彇寰呭嚭绗肩殑鐜荤拑
+ EdgStorageCageDetails glassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getGlassId, glassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
+// 鑾峰彇寰呭嚭绗肩殑鐜荤拑闇�瑕佹浛鎹㈢殑鐜荤拑淇℃伅
+ EdgStorageCageDetails swapGlassDetailInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getGlassId, swapGlassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
+
+// 鐜荤拑灏忕墖琛ㄤ腑鐜荤拑宸茬粡鏇挎崲锛屾洿鏂板崸鐞嗙鍐呯幇鏈夌殑鍑嗗鍑虹鐨勭幓鐠冧俊鎭紝
+ if (null == swapGlassDetailInfo) {
+ GlassInfo glassInfoBase = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
+ .eq(GlassInfo::getGlassId, glassId));
+ //闇�瑕佹浛鎹㈢殑鐜荤拑涓哄瓨杩涘崸鐞嗭紝浠呴渶鏇存柊褰撳墠闇�瑕佸嚭绗肩殑鐜荤拑淇℃伅鍗冲彲
+ edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getGlassId, glassId)
+ .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfoBase.getTemperingLayoutId())
+ .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfoBase.getTemperingFeedSequence()));
+ } else {
+ //闇�瑕佹浛鎹㈢殑鐜荤拑閮藉湪鍗х悊鍐咃紝鎸夌収鐜荤拑id瀵硅皟鐜荤拑淇℃伅锛氬璋冪幓鐠僫d鍗冲彲
+ edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getId, glassInfo.getId())
+ .set(EdgStorageCageDetails::getTemperingLayoutId, swapGlassDetailInfo.getTemperingLayoutId())
+ .set(EdgStorageCageDetails::getTemperingFeedSequence, swapGlassDetailInfo.getTemperingFeedSequence())
+ );
+ edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
+ .eq(EdgStorageCageDetails::getId, swapGlassDetailInfo.getId())
+ .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
+ .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence())
+ );
+ }
+ }
+
+ /**
+ * 鑾峰彇璇︽儏琛ㄥ唴鏈�澶ф渶灏忕増鍥緄d鐨勫樊鍊硷紝鍒ゆ柇鏄惁鍑烘渶灏忕増鍥剧幓鐠�
+ *
+ * @return
+ */
+ public boolean queryMaxMinDiffByDevice(int threshold, int deviceId) {
+ //鑾峰彇绗煎瓙鍐呮渶澶х増鍥緄d鍜屾渶灏忕増鍥緄d鎻掑�硷紝鍒ゆ柇鏄惁澶т簬闃堝�硷紝澶т簬闃堝�肩洿鎺ュ嚭鏈�灏忕増鍥剧幓鐠�
+ QueryWrapper<EdgStorageCageDetails> queryWrapper = new QueryWrapper<>();
+ queryWrapper.select("max(tempering_layout_id)-min(tempering_layout_id) as diff")
+ .eq("state", Const.GLASS_STATE_IN)
+ .eq("device_id", deviceId)
+ .inSql("slot", "select slot from edg_storage_cage where enable_state = " + Const.SLOT_ON);
+ List<Object> list = edgStorageCageDetailsService.listObjs(queryWrapper);
+ //鑾峰彇绗煎唴鐜荤拑鐗堝浘宸�兼槸鍚﹀ぇ浜庨槇鍊�
+ if (CollectionUtil.isNotEmpty(list)) {
+ Long diff = (Long) list.get(0);
+ return diff > threshold;
+ } else {
+ return Boolean.FALSE;
+ }
+ }
+
+ public boolean saveHistoryTask(EdgStorageDeviceTask task, int deviceId) {
+ EdgStorageDeviceTaskHistory taskHistory = new EdgStorageDeviceTaskHistory();
+ BeanUtils.copyProperties(task, taskHistory);
+ taskHistory.setTaskType(task.getTaskRunning());
+ taskHistory.setCreateTime(new Date());
+ taskHistory.setTaskState(Const.RAW_GLASS_TASK_NEW);
+ taskHistory.setDeviceId(deviceId);
+ edgStorageDeviceTaskHistoryService.save(taskHistory);
+ return Boolean.TRUE;
+ }
+
+ private boolean saveGlassSize(EdgStorageCageDetails glassInfo) {
+ EdgGlassTaskInfo edgGlassTaskInfo = new EdgGlassTaskInfo();
+ BeanUtils.copyProperties(glassInfo, edgGlassTaskInfo);
+ edgGlassTaskInfo.setHeight((int) (glassInfo.getHeight() * ratio));
+ edgGlassTaskInfo.setWidth((int) (glassInfo.getWidth() * ratio));
+ edgGlassTaskInfo.setThickness((int) (glassInfo.getThickness() * ratio));
+ edgGlassTaskInfo.setState(Const.EDG_GLASS_BEFORE);
+ edgGlassTaskInfo.setCreateTime(new Date());
+ edgGlassTaskInfo.setUpdateTime(new Date());
+ //鍏堝皢鍘嗗彶瀵瑰垪琛ㄤ腑鏈幓鐠冪殑鏁版嵁鍒犻櫎锛岄噸鏂版柊澧炰竴浠芥渶鏂扮殑鏁版嵁
+ edgGlassTaskInfoService.remove(new LambdaQueryWrapper<EdgGlassTaskInfo>().eq(EdgGlassTaskInfo::getGlassId, glassInfo.getGlassId()));
+ return edgGlassTaskInfoService.save(edgGlassTaskInfo);
+ }
+
+ private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) {
+ return ReadWriteEntity.builder()
+ .identifier(identifier)
+ //Kep涓槸Long绫诲瀷锛屽嵆锛欼nt32锛孞ava涓殑int绫诲瀷
+ .value(value)
+ .build();
+ }
+}
--
Gitblit v1.8.0