1、卧理进出片任务功能初步完成，待调试

zhoushihao

2024-10-27 ef45387ac4b65538bb965dd7fe9c40d28bceca64

1、卧理进出片任务功能初步完成，待调试

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/common/config/Const.java

@@ -57,13 +57,22 @@
    public static final List<Integer> GLASS_STATE_IN_ALL_ZERO = Arrays.asList(0, 100, 102, 103, 104);

    /**
     * 卧式理片笼详情表玻璃状态
     * 进片任务1
     * 出片任务2
     * 卧离任务类型
     * 空任务 0
     * 进片任务 1
     * 出片任务 2
     * 直通任务 3
     * 进行中 4
     * 结束 5
     * 其他 6
     */
    public static final Integer GLASS_CACHE_TYPE_EMPTY = 0;
    public static final Integer GLASS_CACHE_TYPE_IN = 1;
    public static final Integer GLASS_CACHE_TYPE_OUT = 2;
    public static final Integer GLASS_CACHE_TYPE_THROUGH = 3;
    public static final Integer GLASS_CACHE_TYPE_RUNNING = 4;
    public static final Integer GLASS_CACHE_TYPE_FINISH = 5;
    public static final Integer GLASS_CACHE_TYPE_OTHER = 6;
    public static final List<Integer> GLASS_CACHE_TYPE_OUT_ALL = Arrays.asList(2, 3);

    /**
@@ -185,6 +194,9 @@
     * 原片仓储任务类型
     * 进片任务1
     * 出片任务2
     * 调度任务3
     * 进片请求4
     * 出片请求5
     */
    public static final Integer RAW_GLASS_TASK_TYPE_IN = 1;
    public static final Integer RAW_GLASS_TASK_TYPE_OUT = 2;
@@ -193,9 +205,9 @@
    public static final Integer RAW_GLASS_TASK_TYPE_OUT_REQUEST = 5;

    /**
     * 原片仓储任务类型
     * 进片任务1
     * 出片任务2
     * 原片仓储任务状态
     * 新建0
     * 已完成1
     */
    public static final Integer ENGINEERING_NEW = 0;
    public static final Integer ENGINEERING_RUNNING = 1;

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/mapper/EdgStorageCageDetailsMapper.java

@@ -13,4 +13,5 @@
 */
public interface EdgStorageCageDetailsMapper extends MPJBaseMapper<EdgStorageCageDetails> {

    EdgStorageCageDetails queryEdgStorageDetailsBySize(double width, double height);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/mapper/EdgStorageCageMapper.java

@@ -1,8 +1,8 @@
package com.mes.edgstoragecage.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.github.yulichang.base.MPJBaseMapper;
import com.mes.edgstoragecage.entity.EdgStorageCage;
import org.apache.ibatis.annotations.Param;

/**
 * <p>
@@ -14,4 +14,14 @@
 */
public interface EdgStorageCageMapper extends MPJBaseMapper<EdgStorageCage> {

    /**
     * 相同尺寸可以放下的格子
     *
     * @param deviceId
     * @param width
     * @param height
     * @param slot
     * @return
     */
    EdgStorageCage getEdgStorageCageBySize(@Param("deviceId") int deviceId, @Param("width") double width, @Param("height") double height, @Param("slot") int slot);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/EdgStorageCageDetailsService.java

@@ -78,4 +78,13 @@
     * @return
     */
    boolean inToVerify(String glassId);

    /**
     * 按照尺寸
     *
     * @param width
     * @param height
     * @return
     */
    EdgStorageCageDetails queryEdgStorageDetailsBySize(double width, double height);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/EdgStorageCageService.java

@@ -26,14 +26,17 @@
    EdgStorageCage selectNearestEmpty(int currentSlot, boolean flag);

    List<EdgStorageCage> selectCacheEmpty();

    /**
     * 查询笼内出片顺序详情
     *
     * @return
     */
    List<Map<String, Object>> selectCacheOut();

    /**
     * 查询笼内详情
     *
     * @return
     */
    List<Map<String, Object>> selectEdgStorageCages();
@@ -55,4 +58,15 @@
     */
    boolean updateEdgStorageCageDetails(int edgStorageCageId, EdgStorageCageDetails edgStorageCageDetails);

    /**
     * 相同尺寸可以放下的格子
     *
     * @param deviceId
     * @param width
     * @param height
     * @param slot
     * @return
     */
    EdgStorageCage getEdgStorageCageBySize(int deviceId, double width, double height, int slot);

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/impl/EdgStorageCageDetailsServiceImpl.java

@@ -334,22 +334,22 @@
        for (int i = 1; i <= groupBy.keySet().size(); i++) {
            String key = i + "";
            if (key != null) {
                List<Map<String, Object>> galssInfo=groupBy.get(key);//当前钢化版图内玻璃小片集合
                if(!galssInfo.isEmpty()){
                    Map<String, Object> item=new HashMap<>();//新格式编排
                List<Map<String, Object>> galssInfo = groupBy.get(key);//当前钢化版图内玻璃小片集合
                if (!galssInfo.isEmpty()) {
                    Map<String, Object> item = new HashMap<>();//新格式编排
                    //以下为同层  {key:"groupBy.get(key)",olLayoutRate:"小片集合"}
                    //          {key:"groupBy.get(key)",olLayoutRate:[{},{},{},{}]}


                    item.put("listGlass",groupBy.get(key));
                    item.put("LayoutId",key);
                    item.put("olWidth",galssInfo.get(0).get("olWidth").toString());
                    item.put("olHeight",galssInfo.get(0).get("olHeight").toString());
                    item.put("olLayoutRate",galssInfo.get(0).get("olLayoutRate").toString());
                    item.put("listGlass", groupBy.get(key));
                    item.put("LayoutId", key);
                    item.put("olWidth", galssInfo.get(0).get("olWidth").toString());
                    item.put("olHeight", galssInfo.get(0).get("olHeight").toString());
                    item.put("olLayoutRate", galssInfo.get(0).get("olLayoutRate").toString());
                    result.add(item);
                }else{
                    log.info("当前钢化版图不存在小片数据请检查，版图号:{}"+key);
                    return null ;
                } else {
                    log.info("当前钢化版图不存在小片数据请检查，版图号:{}" + key);
                    return null;
                }
            }
        }
@@ -523,4 +523,9 @@
        }
        return false;
    }

    @Override
    public EdgStorageCageDetails queryEdgStorageDetailsBySize(double width, double height) {
        return baseMapper.queryEdgStorageDetailsBySize(width, height);
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/impl/EdgStorageCageServiceImpl.java

@@ -19,7 +19,6 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -36,9 +35,9 @@
@Service
public class EdgStorageCageServiceImpl extends MPJBaseServiceImpl<EdgStorageCageMapper, EdgStorageCage> implements EdgStorageCageService {

    @Resource
    @Autowired
    EdgStorageCageDetailsMapper edgStorageCageDetailsMapper;
    @Resource
    @Autowired
    UpPattenUsageMapper upPattenUsageMapper;

    @Autowired
@@ -183,5 +182,10 @@
        return true;
    }

    @Override
    public EdgStorageCage getEdgStorageCageBySize(int deviceId, double width, double height, int slot) {
        return baseMapper.getEdgStorageCageBySize(deviceId, width, height, slot);
    }


}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassTask.java

@@ -1,11 +1,32 @@
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.service.MiloService;
import com.mes.common.config.Const;
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.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import javax.annotation.Resource;
import java.util.List;

/**
 * @Author : zhoush
@@ -16,8 +37,28 @@
@Slf4j
public class OpcCacheGlassTask {

    @Autowired(required = false)
    MiloService miloService;
    @Resource
    EdgStorageDeviceTaskService edgStorageDeviceTaskService;
    @Resource
    GlassInfoService glassInfoService;
    @Resource
    EdgStorageCageDetailsService edgStorageCageDetailsService;
    @Resource
    EdgStorageCageService edgStorageCageService;
    @Resource
    EdgStorageDeviceTaskHistoryService edgStorageDeviceTaskHistoryService;

    @Value("${mes.glassGap}")
    private int glassGap;
    @Value("${mes.cellLength}")
    private int cellLength;

    @Value("${mes.threshold}")
    private int threshold;
//    @Autowired
//    MiloService miloService;
//    MPJBaseService edgStorageDeviceTaskService;
//
//    @Autowired
//    SubscriptionCallback cacheGlassSubscriptionCallback;
@@ -26,4 +67,291 @@
//    public void startOpcTask() throws Exception {
//        miloService.subscriptionFromOpcUa(Arrays.asList("my.device.x1", "my.device.x2"), cacheGlassSubscriptionCallback);
//    }

    @Scheduled(fixedDelay = 1000)
    public void startOpcTask() throws Exception {
        int request = 1;
//        获取笼内玻璃信息
        taskByDevice();
    }

    @Scheduled(fixedDelay = 1000)
    public void finishOpcTask() throws Exception {
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage("edg_storage_device_one_task");
        if (task == null) {
            log.info("任务表基础数据录入失败，请检查数据是否录入成功");
            return;
        }
        if (task.getTaskState() <= 3) {
            log.info("不存在未完成的任务");
            return;
        }
        Integer cell = task.getStartCell();
        Integer state = task.getTaskState();
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
        task.setTaskState(Const.GLASS_CACHE_TYPE_EMPTY);
        task.setStartCell(-1);
        edgStorageDeviceTaskService.updateTaskMessage("edg_storage_device_one_task", task);
        edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper<EdgStorageDeviceTaskHistory>()
                .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
                .set(EdgStorageDeviceTaskHistory::getTaskState,
                        Const.GLASS_CACHE_TYPE_RUNNING.equals(state) ? Const.RAW_GLASS_TASK_SUCCESS : Const.RAW_GLASS_TASK_FAILURE)
        );
        updateCellRemainWidth(cell);
    }

    private void taskByDevice() throws Exception {
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage("edg_storage_device_one_task");
        if (task == null) {
            log.info("任务表基础数据录入失败，请检查数据是否录入成功");
            return;
        }
        int request = task.getTaskState();
        if (request == 0) {
            log.info("未收到任务请求，结束本次任务");
        } else if (request == 1) {
            //进片任务
            intoTask(task);
        } else if (request == 2) {
            //出片任务
            outTask(task);
        } else if (request == 3) {
            //todo:直通任务

        } else {
            log.info("异常数据，结束本次任务");
        }
    }

    private boolean intoTask(EdgStorageDeviceTask task) {
        //获取玻璃的基本信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
        if (null == glassInfo) {
            log.info("进片玻璃信息不存在，玻璃id:{}", task.getGlassIdIn());
            return Boolean.FALSE;
        }
        //获取当前进片玻璃id和进片格子  相同尺寸可以放下的格子
//        select * from edg_storage_cage t left join edg_storage_cage_details t1 on t.slot = t1.slot
//        where t.device_id =1 and t1.state = 100 and t.remain_width >= 827 and t1.width = 827 and t1.height = 1124 order by abs(t.slot - 10)
        EdgStorageCage edgStorageCage = edgStorageCageService.getEdgStorageCageBySize(1, 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<EdgStorageCage> storageCageList = edgStorageCageService.list(new LambdaQueryWrapper<EdgStorageCage>().eq(EdgStorageCage::getDeviceId, 1)
                    .eq(EdgStorageCage::getEnableState, Const.SLOT_ON)
                    .ge(EdgStorageCage::getRemainWidth, glassInfo.getWidth()).last("order by abs(slot - " + task.getCurrentCell() + ")"));
//            //直通任务
//            if (flag && CollectionUtil.isNotEmpty(emptyList)) {
//                return emptyList.get(0);
//            }
            if (CollectionUtil.isEmpty(storageCageList) || storageCageList.size() == 1) {
                log.info("没有多余的空格子");
                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(task.getTaskState());
        edgStorageDeviceTaskService.updateTaskMessage("edg_storage_device_one_task", task);
        saveHistoryTask(task);
        return Boolean.TRUE;
    }

    private boolean outTask(EdgStorageDeviceTask task) {
        EdgStorageCageDetails edgStorageCageDetails = null;
        //笼内是版图相差是否超过阈值
        boolean flag = queryMaxMinDiff(threshold);
        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)
                    .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<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getWidth, minEdgDetails.getWidth())
                    .eq(EdgStorageCageDetails::getHeight, minEdgDetails.getHeight())
                    .inSql(EdgStorageCageDetails::getId, "select min(id ) from edg_storage_cage_details where state = 100 group by slot ")
                    .last("order by abs(t.slot - " + task.getCurrentCell() + ")  asc limit 1")
            );
            if (null == edgStorageCageDetails) {
                edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                        .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(EdgStorageCageDetails::getSlot, minEdgDetails.getSlot())
                        .orderByAsc(EdgStorageCageDetails::getId)
                        .last("limit 1")
                );
            }
        }
        if (null == edgStorageCageDetails) {
            //        获取上次任务
//        获取历史表中上次任务最后一片尺寸
            EdgStorageDeviceTaskHistory edgeData = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>()
                    .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS).
                            orderByDesc(EdgStorageDeviceTaskHistory::getId).last("limit 1"));
            GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, edgeData.getGlassIdOut()));
            //笼内的玻璃的尺寸是否和上一次任务一致
            edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(one.getWidth(), one.getHeight());
        }
        if (null == edgStorageCageDetails) {
            edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(0, 0);
        }
        if (edgStorageCageDetails == null) {
            //和上次任务不存在相同尺寸
            log.info("笼内没有玻璃了");
            return Boolean.FALSE;
        }
        //玻璃信息替换
        String glassIdChange = queryAndChangeGlass(edgStorageCageDetails.getGlassId());
        //处理在卧理内的玻璃信息：笼内的数据处理
        queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange);
        //生成出片任务
        task.setGlassIdOut(edgStorageCageDetails.getGlassId());
        task.setCurrentCell(edgStorageCageDetails.getSlot());
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_OUT);
        edgStorageDeviceTaskService.updateTaskMessage("edg_storage_device_one_task", task);
        saveHistoryTask(task);
        //更新详情表任务出片中
        edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId()));
        return Boolean.TRUE;
    }

    private boolean updateCellRemainWidth(int slot) {
        List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getSlot, slot)
                .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
        if (CollectionUtil.isEmpty(list)) {
            log.info("格子{}内无玻璃，无法更新", slot);
            return Boolean.FALSE;
        }
        int widthTotal = (int) list.stream().map(e -> e.getWidth() + glassGap).mapToDouble(Double::intValue).sum();
        int remainWidth = cellLength - widthTotal >= 0 ? cellLength - widthTotal : 0;
        edgStorageCageService.update(new LambdaUpdateWrapper<EdgStorageCage>().
                set(EdgStorageCage::getRemainWidth, remainWidth).eq(EdgStorageCage::getSlot, slot));
        return Boolean.FALSE;
    }


    /**
     * 查询玻璃并进行交换
     *
     * @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)
                .orderBy(Boolean.TRUE, Boolean.TRUE, GlassInfo::getTemperingFeedSequence)
                .last("Limit 1");
        GlassInfo swapGlassInfo = glassInfoService.getOne(queryWrapper);
        if (swapGlassInfo != null && !glassInfo.getGlassId().equals(swapGlassInfo.getGlassId())) {
            String swapGlassId = swapGlassInfo.getGlassId();
            log.info("将玻璃{}和玻璃{}，信息互换,进玻璃 {}", glassInfo, swapGlassInfo, swapGlassInfo);
            swapGlassInfo.setGlassId(glassId);
            glassInfo.setGlassId(swapGlassId);
            glassInfoService.updateById(swapGlassInfo);
            glassInfoService.updateById(glassInfo);
            return swapGlassId;
        }
        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对调玻璃信息：对调玻璃id即可
            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())
            );
        }
    }

    /**
     * 获取详情表内最大最小版图id的差值，判断是否出最小版图玻璃
     *
     * @return
     */
    public boolean queryMaxMinDiff(int threshold) {
        //获取笼子内最大版图id和最小版图id插值，判断是否大于阈值，大于阈值直接出最小版图玻璃
        QueryWrapper<EdgStorageCageDetails> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("max(tempering_layout_id)-min(tempering_layout_id) as diff")
                .eq("state", Const.GLASS_STATE_IN)
                .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) {
        EdgStorageDeviceTaskHistory taskHistory = new EdgStorageDeviceTaskHistory();
        BeanUtils.copyProperties(task, taskHistory);
        task.setTaskType(task.getTaskRunning());
        task.setTaskState(Const.RAW_GLASS_TASK_NEW);
        edgStorageDeviceTaskHistoryService.save(taskHistory);
        return Boolean.TRUE;
    }

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/controller/EdgStorageDeviceController.java

New file
@@ -0,0 +1,9 @@
package com.mes.opctask.controller;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:35
 * @Description:
 */
public class EdgStorageDeviceController {
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/controller/EdgStorageDeviceTaskHistoryController.java

New file
@@ -0,0 +1,86 @@
package com.mes.opctask.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;
import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService;
import com.mes.utils.Result;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.List;

/**
 * (EdgStorageDeviceTaskHistory)表控制层
 *
 * @author makejava
 * @since 2024-10-27 21:04:29
 */
@RestController
@RequestMapping("edgStorageDeviceTaskHistory")
public class EdgStorageDeviceTaskHistoryController {
    /**
     * 服务对象
     */
    @Resource
    private EdgStorageDeviceTaskHistoryService edgStorageDeviceTaskHistoryService;

    /**
     * 分页查询所有数据
     *
     * @param page                        分页对象
     * @param edgStorageDeviceTaskHistory 查询实体
     * @return 所有数据
     */
    @GetMapping
    public Result selectAll(Page<EdgStorageDeviceTaskHistory> page, EdgStorageDeviceTaskHistory edgStorageDeviceTaskHistory) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.page(page, new QueryWrapper<>(edgStorageDeviceTaskHistory)));
    }

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("{id}")
    public Result selectOne(@PathVariable Serializable id) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.getById(id));
    }

    /**
     * 新增数据
     *
     * @param edgStorageDeviceTaskHistory 实体对象
     * @return 新增结果
     */
    @PostMapping
    public Result insert(@RequestBody EdgStorageDeviceTaskHistory edgStorageDeviceTaskHistory) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.save(edgStorageDeviceTaskHistory));
    }

    /**
     * 修改数据
     *
     * @param edgStorageDeviceTaskHistory 实体对象
     * @return 修改结果
     */
    @PutMapping
    public Result update(@RequestBody EdgStorageDeviceTaskHistory edgStorageDeviceTaskHistory) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.updateById(edgStorageDeviceTaskHistory));
    }

    /**
     * 删除数据
     *
     * @param idList 主键结合
     * @return 删除结果
     */
    @DeleteMapping
    public Result delete(@RequestParam("idList") List<Long> idList) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.removeByIds(idList));
    }
}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/entity/EdgStorageDeviceTask.java

New file
@@ -0,0 +1,57 @@
package com.mes.opctask.entity;

import lombok.Data;

import java.util.Date;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 10:22
 * @Description:
 */
@Data
public class EdgStorageDeviceTask {

    /**
     * 任务请求 0无任务 1进片 2出片 3直通
     */
    private Integer taskRunning;
    /**
     * 进片玻璃id
     */
    private String glassIdIn;
    /**
     * 出片玻璃id
     */
    private String glassIdOut;
    /**
     * 当前层号
     */
    private Integer currentCell;
    /**
     * 层号
     */
    private Integer startCell;
    /**
     * 预留层号
     */
    private Integer endCell;
    /**
     * 任务状态 0默认空任务 1执行中 2结束任务
     */
    private Integer taskState;
    /**
     * 任务类型
     */
    private Integer taskType;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;


}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/entity/EdgStorageDeviceTaskHistory.java

New file
@@ -0,0 +1,63 @@
package com.mes.opctask.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;

import java.util.Date;

/**
 * (EdgStorageDeviceTaskHistory)表实体类
 *
 * @author makejava
 * @since 2024-10-27 21:04:33
 */
@SuppressWarnings("serial")
@Data
public class EdgStorageDeviceTaskHistory extends Model<EdgStorageDeviceTaskHistory> {
    /**
     * 工程表id
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;
    /**
     * 进片玻璃id
     */
    private String glassIdIn;
    /**
     * 出片玻璃id
     */
    private String glassIdOut;
    /**
     * 当前层号
     */
    private Integer currentCell;
    /**
     * 层号
     */
    private Integer startCell;
    /**
     * 预留层号
     */
    private Integer endCell;
    /**
     * 任务状态 0默认空任务 1 进片 2出片 3 直通 4执行中 5结束任务 6其他
     */
    private Integer taskState;
    /**
     * 任务状态 0默认空任务 1 进片 2出片 3 直通 4执行中 5结束任务 6其他
     */
    private Integer taskType;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;


}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/entity/device/EdgStorageDeviceOneTask.java

New file
@@ -0,0 +1,9 @@
package com.mes.opctask.entity.device;

import com.mes.opctask.entity.EdgStorageDeviceTask;
import lombok.Data;

@Data
public class EdgStorageDeviceOneTask extends EdgStorageDeviceTask {
}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/entity/device/EdgStorageDeviceTwoTask.java

New file
@@ -0,0 +1,9 @@
package com.mes.opctask.entity.device;

import com.mes.opctask.entity.EdgStorageDeviceTask;
import lombok.Data;

@Data
public class EdgStorageDeviceTwoTask extends EdgStorageDeviceTask {
}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/mapper/EdgStorageDeviceTaskHistoryMapper.java

New file
@@ -0,0 +1,15 @@
package com.mes.opctask.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;

/**
 * (EdgStorageDeviceTaskHistory)表数据库访问层
 *
 * @author makejava
 * @since 2024-10-27 21:04:29
 */
public interface EdgStorageDeviceTaskHistoryMapper extends BaseMapper<EdgStorageDeviceTaskHistory> {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/mapper/EdgStorageDeviceTaskMapper.java

New file
@@ -0,0 +1,15 @@
package com.mes.opctask.mapper;

import com.mes.opctask.entity.EdgStorageDeviceTask;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:39
 * @Description:
 */
public interface EdgStorageDeviceTaskMapper {

    EdgStorageDeviceTask queryTaskMessage(String tableName);

    boolean updateTaskMessage(String tableName, EdgStorageDeviceTask edgStorageDeviceTask);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/EdgStorageDeviceTaskHistoryService.java

New file
@@ -0,0 +1,15 @@
package com.mes.opctask.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;

/**
 * (EdgStorageDeviceTaskHistory)表服务接口
 *
 * @author makejava
 * @since 2024-10-27 21:04:33
 */
public interface EdgStorageDeviceTaskHistoryService extends IService<EdgStorageDeviceTaskHistory> {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/EdgStorageDeviceTaskService.java

New file
@@ -0,0 +1,21 @@
package com.mes.opctask.service;

import com.mes.opctask.entity.EdgStorageDeviceTask;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:35
 * @Description:
 */
public interface EdgStorageDeviceTaskService {

    /**
     * 查询任务信息
     *
     * @return
     */
    EdgStorageDeviceTask queryTaskMessage(String tableName);

    boolean updateTaskMessage(String tableName, EdgStorageDeviceTask edgStorageDeviceTask);

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/impl/EdgStorageDeviceTaskHistoryServiceImpl.java

New file
@@ -0,0 +1,19 @@
package com.mes.opctask.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;
import com.mes.opctask.mapper.EdgStorageDeviceTaskHistoryMapper;
import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService;
import org.springframework.stereotype.Service;

/**
 * (EdgStorageDeviceTaskHistory)表服务实现类
 *
 * @author makejava
 * @since 2024-10-27 21:04:33
 */
@Service("edgStorageDeviceTaskHistoryService")
public class EdgStorageDeviceTaskHistoryServiceImpl extends ServiceImpl<EdgStorageDeviceTaskHistoryMapper, EdgStorageDeviceTaskHistory> implements EdgStorageDeviceTaskHistoryService {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/impl/EdgStorageDeviceTaskServiceImpl.java

New file
@@ -0,0 +1,32 @@
package com.mes.opctask.service.impl;

import com.mes.opctask.entity.EdgStorageDeviceTask;
import com.mes.opctask.mapper.EdgStorageDeviceTaskMapper;
import com.mes.opctask.service.EdgStorageDeviceTaskService;

import javax.annotation.Resource;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:36
 * @Description:
 */
public class EdgStorageDeviceTaskServiceImpl implements EdgStorageDeviceTaskService {
//    @Override
//    public void updateTaskMessage(Integer slot, Integer taskRunning, String glassIdOut) {

    //    }
    @Resource
    EdgStorageDeviceTaskMapper edgStorageDeviceTaskMapper;

    @Override
    public EdgStorageDeviceTask queryTaskMessage(String tableName) {
        edgStorageDeviceTaskMapper.queryTaskMessage(tableName);
        return null;
    }

    @Override
    public boolean updateTaskMessage(String tableName, EdgStorageDeviceTask edgStorageDeviceTask) {
        return edgStorageDeviceTaskMapper.updateTaskMessage(tableName, edgStorageDeviceTask);
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/application.yml

@@ -28,6 +28,8 @@
    two: #第二条磨边线的最小尺寸信息
      firstLength: 400
      secondLength: 400
    glassGap: 300
    cellLength: 2700
  sequence:
    order: false
kangaroohy:

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/mapper/EdgStorageCageDetailsMapper.xml

New file
@@ -0,0 +1,58 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mes.edgstoragecage.mapper.EdgStorageCageDetailsMapper">

    <resultMap id="baseMap" type="com.mes.edgstoragecage.entity.EdgStorageCageDetails">
        <id column="id" property="id"/>
        <result column="engineer_id" property="engineerId"/>
        <result column="device_id" property="deviceId"/>
        <result column="slot" property="slot"/>
        <result column="glass_id" property="glassId"/>
        <result column="sequence" property="sequence"/>
        <result column="flow_card_id" property="flowCardId"/>
        <result column="glass_type" property="glassType"/>
        <result column="width" property="width"/>
        <result column="height" property="height"/>
        <result column="thickness" property="thickness"/>
        <result column="edg_width" property="edgWidth"/>
        <result column="edg_height" property="edgHeight"/>
        <result column="tempering_layout_id" property="temperingLayoutId"/>
        <result column="tempering_feed_sequence" property="temperingFeedSequence"/>
        <result column="pattern_sequence" property="patternSequence"/>
        <result column="state" property="state"/>
        <result column="gap" property="gap"/>
        <result column="glass_count" property="count"/>
    </resultMap>

    <select id="queryEdgStorageDetailsBySize" resultMap="baseMap">
        with min_id_temp as (
        select slot, min(id) as id, count(*) as glass_count
        from edg_storage_cage_details
        where state = 100
        group by slot
        ),
        size_max_temp as (
        select width, height, count(*) as total_count
        from edg_storage_cage_details t
        inner join min_id_temp t1 on t.id = t1.id
        group by width, height
        ),
        slot_temp as (
        select t.*, t1.glass_count
        from edg_storage_cage_details t
        inner join min_id_temp t1 on t.id = t1.id
        inner join size_max_temp t2 on t.width = t2.width and t.height = t2.height
        <where>
            <if test="width != 0">
                t.width = #{width}
            </if>
            <if test="height != 0">
                t.height = #{height}
            </if>
        </where>
        order by total_count desc, glass_count, abs(t.slot - 10)
        )
        select *
        from slot_temp limit 1
    </select>
</mapper>

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/mapper/EdgStorageCageMapper.xml

New file
@@ -0,0 +1,26 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mes.edgstoragecage.mapper.EdgStorageCageMapper">

    <resultMap id="baseMap" type="com.mes.edgstoragecage.entity.EdgStorageCage">
        <id column="id" property="id" jdbcType="INTEGER"/>
        <result column="device_id" property="deviceId" jdbcType="INTEGER"/>
        <result column="slot" property="slot" jdbcType="INTEGER"/>
        <result column="enable_state" property="enableState" jdbcType="INTEGER"/>
        <result column="remain_width" property="remainWidth" jdbcType="INTEGER"/>
    </resultMap>

    <select id="getEdgStorageCageBySize" resultMap="baseMap">
        select t.*
        from edg_storage_cage t
                 left join edg_storage_cage_details t1 on t.slot = t1.slot
        where t.device_id = #{deviceId}
          and t1.state = 100
          and t.remain_width >= #{width}
          and t1.width = #{width}
          and t1.height = #{height}
          and t.enable_state = 1
        order by abs(t.slot - #{slot})
        limit 1
    </select>
</mapper>

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/mapper/EdgStorageDeviceTaskMapper.xml

New file
@@ -0,0 +1,34 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mes.opctask.mapper.EdgStorageDeviceTaskMapper">

    <resultMap id="baseMap" type="com.mes.opctask.entity.EdgStorageDeviceTask">
        <id column="task_running" property="taskRunning"/>
        <id column="glass_id_in" property="glassIdIn"/>
        <id column="glass_id_out" property="glassIdOut"/>
        <id column="current_cell" property="currentCell"/>
        <id column="start_cell" property="startCell"/>
        <id column="enc_cell" property="endCell"/>
        <id column="task_state" property="taskState"/>
        <id column="create_time" property="createTime"/>
        <id column="update_time" property="updateTime"/>
    </resultMap>

    <select id="queryTaskMessage" resultMap="baseMap">
        select *
        from #{tableName}
        limit 1
    </select>

    <update id="updateTaskMessage">
        UPDATE #{tableName}
        SET task_running = #{taskRunning},
        glass_id_out = #{glassIdOut},
        current_cell = #{currentCell},
        start_cell = #{startCell},
        enc_cell = #{endCell},
        <if test="taskState == 0">
            task_state = #{taskState},
        </if>
    </update>
</mapper>