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.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; import com.kangaroohy.milo.model.ReadWriteEntity; import com.kangaroohy.milo.service.MiloService; import com.mes.common.config.Const; 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 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.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 OpcCacheGlassTask { 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; private int glassGap; private int threshold; private int cellLength; private int ratio; private int minOneFirstLength; private int minOneSecondLength; private int minTwoFirstLength; private int minTwoSecondLength; private String glassInIdOne = ""; private String glassInIdTwo = ""; private String glassIdOne = ""; private String glassIdTwo = ""; // @Scheduled(fixedDelay = 1000) public void startOneOpcTask() { startOneOpcTaskChild(EDG_STORAGE_DEVICE_ONE_TASK, 1); } // @Scheduled(fixedDelay = 1000) public void startTwoOpcTask() { startOneOpcTaskChild(EDG_STORAGE_DEVICE_TWO_TASK, 2); } private void startOneOpcTaskChild(String tableName, int device) { EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(tableName); // try { if (task == null) { log.info("任务表基础数据录入失败，请检查数据是否录入成功"); return; } if (task.getTaskState() == 2) { //防止出片任务且笼前有玻璃的情况，将进片id置空，即出片仅考虑笼内的玻璃 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("进片任务：进片玻璃id为：{}", task.getGlassIdIn()); intoTask(task, tableName, device); } else if (request == 2 && taskRunning == 0) { //出片任务 outTask(task, tableName, device); } else if (request == 3 && taskRunning == 0) { //直通任务 log.info("设备：{}状态：{}", device, request); if (!outTask(task, tableName, device)) { 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); } else { log.info("玻璃异常处理"); damageTask(task, tableName); } // } 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 { GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper().eq(GlassInfo::getGlassId, glassId).last("limit 1")); if (glassInfo == null) { log.info("对列表中的玻璃id错误，请检查数据，玻璃id：{}", glassId); return; } String toEndingId = glassInfo.getTemperingLayoutId() + "" + glassInfo.getTemperingFeedSequence(); List 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() * 10, glassInfo.getHeight() * 10))); list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".height", (int) Math.min(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))); miloService.writeToOpcUa(list); miloService.writeToOpcWord(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".thickness", (int) glassInfo.getThickness() * 10)); //修改磨边对列中的磨边线路及状态 edgGlassTaskInfoService.update(new LambdaUpdateWrapper() .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().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("进片玻璃尺寸小于{}*{}，禁止进笼玻璃id:{}，尺寸为{}、{}", firstLength, secondLength, task.getGlassIdIn(), glassInfo.getWidth(), glassInfo.getHeight()); Date endDate = new Date(); log.info("结束进片任务设备为{}，结束时间为：{}，共耗时：{}ms", deviceId, endDate, endDate.getTime() - startDate.getTime()); return Boolean.FALSE; } //获取当前进片玻璃id和进片格子 相同尺寸可以放下的格子 EdgStorageCage edgStorageCage = edgStorageCageService.getEdgStorageCageBySize(deviceId, glassInfo.getWidth(), glassInfo.getHeight(), task.getCurrentCell()); if (edgStorageCage == null) { log.info("相同尺寸可以放下的格子未找到，格子id:{}", task.getCurrentCell()); // SELECT * from edg_storage_cage where device_id = 1 and remain_width > 1000 order by abs(slot - 10) List storageCageList = edgStorageCageService.list(new LambdaQueryWrapper() .eq(EdgStorageCage::getDeviceId, deviceId) .eq(EdgStorageCage::getEnableState, Const.SLOT_ON) .ge(EdgStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight())).last("order by abs(slot - " + task.getCurrentCell() + ")")); if (CollectionUtil.isEmpty(storageCageList) || storageCageList.size() == 1) { log.info("没有多余的空格子"); Date endDate = new Date(); log.info("结束进片任务设备为{}，结束时间为：{}，共耗时：{}ms", deviceId, endDate, endDate.getTime() - startDate.getTime()); return Boolean.FALSE; } edgStorageCage = storageCageList.get(0); } 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); //记录进片任务的玻璃id用于下次任务的比较，防止同一块玻璃重复执行 if (deviceId == 1) { glassInIdOne = task.getGlassIdIn(); } else { glassInIdTwo = task.getGlassIdIn(); } edgStorageCageService.update(new UpdateWrapper() .setSql("remain_width = remain_width -" + (glassGap + Math.max(details.getWidth(), details.getHeight()))).eq("device_id", deviceId) .eq("slot", task.getStartCell())); 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) { Date startDate = new Date(); log.info("开始执行出片/直通任务，任务信息为：{},表名为：{},设备id:{},开始时间：{}", task, tableName, deviceId, startDate); EdgStorageCageDetails edgStorageCageDetails = null; //笼内是版图相差是否超过阈值 boolean flag = queryMaxMinDiffByDevice(threshold, deviceId); if (flag) { EdgStorageCageDetails minEdgDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper() .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) .orderBy(Boolean.TRUE, Boolean.TRUE, EdgStorageCageDetails::getTemperingFeedSequence) .last("limit 1")); // select * from edg_storage_cage_details where width = 551 and height = 1151 and id in (select min(id ) from edg_storage_cage_details where state = 100 group by slot ) edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper() .eq(EdgStorageCageDetails::getWidth, minEdgDetails.getWidth()) .eq(EdgStorageCageDetails::getHeight, minEdgDetails.getHeight()) .eq(EdgStorageCageDetails::getDeviceId, deviceId) .inSql(EdgStorageCageDetails::getId, "select min(id) from edg_storage_cage_details where state = 100 group by slot ") .last("order by abs(slot - " + task.getCurrentCell() + ") asc limit 1") ); //给直通任务 if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) { GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper() .eq(GlassInfo::getGlassId, task.getGlassIdIn()) .eq(GlassInfo::getWidth, minEdgDetails.getWidth()) .eq(GlassInfo::getHeight, minEdgDetails.getHeight())); if (null != glassInInfo) { edgStorageCageDetails = new EdgStorageCageDetails(); BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails); } } if (null == edgStorageCageDetails) { edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper() .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(EdgStorageCageDetails::getDeviceId, deviceId) .eq(EdgStorageCageDetails::getSlot, minEdgDetails.getSlot()) .orderByAsc(EdgStorageCageDetails::getId) .last("limit 1") ); } } if (null == edgStorageCageDetails) { // 获取上次任务 // 获取历史表中上次任务最后一片尺寸 EdgStorageDeviceTaskHistory edgeData = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper() .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS) .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().eq(GlassInfo::getGlassId, edgeData.getGlassIdOut())); //笼内的玻璃的尺寸是否和上一次任务一致 edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(deviceId, task.getCurrentCell(), glassOutInfo.getWidth(), glassOutInfo.getHeight(), 0, 0); if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) { GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper() .eq(GlassInfo::getGlassId, task.getGlassIdIn()) .eq(GlassInfo::getWidth, glassOutInfo.getWidth()) .eq(GlassInfo::getHeight, glassOutInfo.getHeight())); if (null != glassInInfo) { edgStorageCageDetails = new EdgStorageCageDetails(); BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails); } } } } if (null == edgStorageCageDetails) { edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(deviceId, task.getCurrentCell(), 0, 0, 0, 0); } if (edgStorageCageDetails == null && StringUtils.isNotBlank(task.getGlassIdIn())) { //和上次任务不存在相同尺寸 int firstLength = minTwoFirstLength; int secondLength = minTwoSecondLength; if (deviceId == 1) { firstLength = minOneFirstLength; secondLength = minOneSecondLength; } GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper().eq(GlassInfo::getGlassId, task.getGlassIdIn())); if (Math.max(glassInInfo.getWidth(), glassInInfo.getHeight()) < firstLength || Math.min(glassInInfo.getWidth(), glassInInfo.getHeight()) < secondLength) { log.info("直通任务进片玻璃尺寸小于{}*{}", firstLength, secondLength); return Boolean.FALSE; } edgStorageCageDetails = new EdgStorageCageDetails(); BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails); } 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().eq(GlassInfo::getGlassId, glassId)); BeanUtils.copyProperties(one, edgStorageCageDetails); } EdgStorageCage storageCage = edgStorageCageService.getOne(new LambdaQueryWrapper() .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() .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 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); 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() .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT) .eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId())); //磨边对列表新增一条数据 saveGlassSize(edgStorageCageDetails); // edgStorageCageService.update(new UpdateWrapper() // .setSql("remain_width = remain_width +" + Math.max(edgStorageCageDetails.getWidth(), edgStorageCageDetails.getHeight())) // .eq("device_id", deviceId) // .eq("slot", task.getStartCell())); Date endDate = new Date(); log.info("结束出片/直通任务设备为{}，结束时间为：{}，共耗时：{}ms", deviceId, endDate, endDate.getTime() - startDate.getTime()); return Boolean.TRUE; } private boolean finishTask(EdgStorageDeviceTask task, String tableName) { if (task.getTaskState() <= 4) { log.info("有正在执行的任务或这任务已执行任务状态{}，任务启动情况{}，结束", task.getTaskState(), task.getTaskRunning()); return Boolean.FALSE; } Date startDate = new Date(); log.info("开始执行完成任务后清除动作，任务信息为：{},表名为：{},开始时间：{}", task, tableName, startDate); Integer cell = task.getStartCell(); task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY); task.setGlassIdOut(""); task.setStartCell(0); int device = tableName.equals("edg_storage_device_one_task") ? 1 : 2; EdgStorageDeviceTaskHistory taskHistory = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper() .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW) .eq(EdgStorageDeviceTaskHistory::getDeviceId, device) .orderByDesc(EdgStorageDeviceTaskHistory::getCreateTime).last("limit 1")); //如果任务类型为1，3，将切割完成的玻璃自动报工 if (Const.GLASS_CACHE_TYPE_IN_ALL.contains(taskHistory.getTaskType())) { damageService.autoSubmitReport(taskHistory.getGlassIdIn(), taskHistory.getDeviceId(), "切割", "进卧理", 1); } updateCellRemainWidth(cell, device, taskHistory); edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper() .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) { if (task.getTaskState() <= 5) { log.info("任务未发生异常清空，任务结束，电气状态{},mes状态{}", task.getTaskState(), task.getTaskRunning()); return Boolean.FALSE; } Date startDate = new Date(); log.info("开始执行异常处理任务后清除动作，任务信息为：{},表名为：{},开始时间：{}", task, tableName, startDate); int device = tableName.equals("edg_storage_device_one_task") ? 1 : 2; EdgStorageDeviceTaskHistory taskHistory = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper() .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW) .eq(EdgStorageDeviceTaskHistory::getDeviceId, device) .orderByDesc(EdgStorageDeviceTaskHistory::getCreateTime).last("limit 1")); 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() .eq(EdgStorageCageDetails::getDeviceId, device) .eq(EdgStorageCageDetails::getSlot, cell) .eq(EdgStorageCageDetails::getGlassId, glassId)); } else { String glassId = taskHistory.getGlassIdOut(); edgStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(EdgStorageCageDetails::getDeviceId, device) .eq(EdgStorageCageDetails::getSlot, cell) .eq(EdgStorageCageDetails::getGlassId, glassId)); } updateCellRemainWidth(cell, device, taskHistory); edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper() .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); 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().eq(GlassInfo::getGlassId, glassId)); // .inSql(GlassInfo::getEngineerId, "select engineer_id from engineering where state = 1")); Assert.isFalse(null == glassInfo, "玻璃信息不存在"); //按照玻璃尺寸 LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper() .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() .eq(EdgStorageCageDetails::getGlassId, glassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)); // 获取待出笼的玻璃需要替换的玻璃信息 EdgStorageCageDetails swapGlassDetailInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper() .eq(EdgStorageCageDetails::getGlassId, swapGlassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)); // 玻璃小片表中玻璃已经替换，更新卧理笼内现有的准备出笼的玻璃信息， if (null == swapGlassDetailInfo) { GlassInfo glassInfoBase = glassInfoService.getOne(new LambdaQueryWrapper() .eq(GlassInfo::getGlassId, glassId)); //需要替换的玻璃为存进卧理，仅需更新当前需要出笼的玻璃信息即可 edgStorageCageDetailsService.update(new LambdaUpdateWrapper() .eq(EdgStorageCageDetails::getGlassId, glassId) .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfoBase.getTemperingLayoutId()) .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfoBase.getTemperingFeedSequence())); } else { //需要替换的玻璃都在卧理内，按照玻璃id对调玻璃信息：对调玻璃id即可 edgStorageCageDetailsService.update(new LambdaUpdateWrapper() .eq(EdgStorageCageDetails::getId, glassInfo.getId()) .set(EdgStorageCageDetails::getTemperingLayoutId, swapGlassDetailInfo.getTemperingLayoutId()) .set(EdgStorageCageDetails::getTemperingFeedSequence, swapGlassDetailInfo.getTemperingFeedSequence()) ); edgStorageCageDetailsService.update(new LambdaUpdateWrapper() .eq(EdgStorageCageDetails::getId, swapGlassDetailInfo.getId()) .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId()) .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence()) ); } } /** * 获取详情表内最大最小版图id的差值，判断是否出最小版图玻璃 * * @return */ public boolean queryMaxMinDiffByDevice(int threshold, int deviceId) { //获取笼子内最大版图id和最小版图id插值，判断是否大于阈值，大于阈值直接出最小版图玻璃 QueryWrapper 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 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; } public boolean updateCellRemainWidth(int slot, int device, EdgStorageDeviceTaskHistory taskHistory) { List list = edgStorageCageDetailsService.list(new LambdaQueryWrapper().eq(EdgStorageCageDetails::getSlot, slot) .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)); int remainWidth = cellLength; if (CollectionUtil.isNotEmpty(list)) { if (2 == taskHistory.getTaskType()) { remainWidth = 0; } else { for (EdgStorageCageDetails item : list) { remainWidth = remainWidth - glassGap - (int) Math.max(item.getWidth(), item.getHeight()); } if (remainWidth <= 0) { remainWidth = 0; } } } edgStorageCageService.update(new LambdaUpdateWrapper(). set(EdgStorageCage::getRemainWidth, remainWidth).eq(EdgStorageCage::getSlot, slot).eq(EdgStorageCage::getDeviceId, device)); 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().eq(EdgGlassTaskInfo::getGlassId, glassInfo.getGlassId())); return edgGlassTaskInfoService.save(edgGlassTaskInfo); } private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) { return ReadWriteEntity.builder() .identifier(identifier) //Kep中是Long类型，即：Int32，Java中的int类型 .value(value) .build(); } }