1、原片仓出调度任务优化，未测试

zhoushihao

2024-11-07 251226a24312a1f3e168db93015be187fb3a44d4

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/job/RawGlassTask.java

@@ -8,10 +8,13 @@
import com.mes.common.config.Const;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.mapper.EngineeringMapper;
import com.mes.opctask.entity.LoadGlassDeviceTask;
import com.mes.opctask.service.LoadGlassDeviceTaskService;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.rawglasstask.entity.RawGlassStorageTask;
import com.mes.rawglasstask.service.RawGlassStorageTaskService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.entity.vo.UpPattenUsageVO;
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import lombok.extern.slf4j.Slf4j;
@@ -44,19 +47,23 @@
    @Resource
    private UpPattenUsageMapper upPattenUsageMapper;

    @Resource
    private LoadGlassDeviceTaskService loadGlassDeviceTaskService;

    @Autowired(required = false)
    private MiloService miloService;

    private static final List<Integer> LIFTING_STATION = Arrays.asList(4);
    private static final List<String> LOAD_STATION_01 = Arrays.asList("101", "102");
    private static final List<String> LOAD_STATION_02 = Arrays.asList("103", "104");
    private static final List<Integer> LOAD_STATION_MAX = Arrays.asList(102, 104);

    private static final String LOAD_GLASS_DEVICE_ONE_TASK = "load_glass_device_one_task";

    private static final String LOAD_GLASS_DEVICE_TWO_TASK = "load_glass_device_two_task";

    private static final List<Integer> LOAD_STATION_01 = Arrays.asList(101, 102);
    private static final List<Integer> LOAD_STATION_02 = Arrays.asList(103, 104);
    private static final Integer LEFTING_01 = 98;
    private static final Integer LEFTING_02 = 99;
    private static final Integer LOAD_GLASS_01_01 = 101;
    private static final Integer LOAD_GLASS_01_02 = 102;
    private static final Integer LOAD_GLASS_02_01 = 103;
    private static final Integer LOAD_GLASS_02_02 = 104;
    private static final Integer LOAD_GLASS_ONE_DEVICE = 5;
    private static final Integer LOAD_GLASS_TWO_DEVICE = 6;

    @Scheduled(fixedDelay = 1000)
    public void rawStorageTask() throws Exception {
@@ -74,7 +81,6 @@
            if ("1".equals(taskWord.getValue() + "")) {
                List<ReadWriteEntity> list = new ArrayList<>();
                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 0));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 0));
                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", 0));
                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", 0));
                miloService.writeToOpcWord(list);
@@ -315,140 +321,130 @@
            log.info("正在执行的工程原片无可上片的原片信息");
            return Boolean.FALSE;
        }
        //获取当前上片位1号架子信息
        int endSlot = stationCell == LOAD_GLASS_01_01 ? LOAD_GLASS_01_01 : LOAD_GLASS_02_01;
        int endSlot02 = stationCell == LOAD_GLASS_01_02 ? LOAD_GLASS_01_01 : LOAD_GLASS_02_02;
        //获取当前需要上片的原片数据
        Map<String, List<UpPattenUsageVO>> upListMap = pattenUsageList.stream()
                .collect(Collectors.groupingBy(UpPattenUsageVO::getGroupNumber));
        //1、查询2个上片的原片详情
        List<RawGlassStorageDetails> rawGlassDetailsList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN).in(RawGlassStorageDetails::getDeviceId, stationCell)
                .orderByAsc(RawGlassStorageDetails::getSlot));
        List<UpPattenUsageVO> upPattenUsage01VOS = upListMap.get("1");
        UpPattenUsageVO usageVO = upPattenUsage01VOS.get(0);
        if (CollectionUtils.isEmpty(rawGlassDetailsList)) {
            //表示1上片位没有架子，直接找原片放入对应路线的1号上片位
            RawGlassStorageDetails details = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
                            .eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
                            .eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
                            .eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
                            .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1")
                            .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
//                    .gt(RawGlassStorageDetails::getRemainQuantity, upPattenUsage01VOS.size())
                            .orderByAsc(RawGlassStorageDetails::getRemainQuantity)
                            .last("limit 1")
            );
            rawGlassStorageDetailsService.generateTask(details.getSlot(), endSlot, details.getSlot(), details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
        List<UpPattenUsageVO> usageVOS = upListMap.get("1");
        //获取当前上片位1号架子信息
        List<Integer> loadStation = LOAD_GLASS_ONE_DEVICE.equals(stationCell) ? LOAD_STATION_01 : LOAD_STATION_02;

            //结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101  目标位新增一条数据，架子号为（起始位）
            rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                    .eq(RawGlassStorageDetails::getSlot, details.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                    .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
        List<RawGlassStorageDetails> loadStationList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1")
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                .eq(RawGlassStorageDetails::getDeviceId, stationCell));
        log.info("获取{}上片线的工位信息{}", stationCell, loadStationList);
        if (CollectionUtils.isEmpty(loadStationList)) {
            log.info("1号上片位生成调度任务");
            return Boolean.TRUE;
        }
        RawGlassStorageDetails glassStorageDetails = rawGlassDetailsList.get(0);
        if (rawGlassDetailsList.size() == 2) {
            if (!((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId())))
                    || ((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId()))
                    && glassStorageDetails.getRemainQuantity() == 0)) {
                //将架子放回原工位上
                rawGlassStorageDetailsService.generateTask(endSlot, glassStorageDetails.getShelf(), glassStorageDetails.getShelf(), 0, Const.RAW_GLASS_TASK_TYPE_DISPATCH);
//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", endSlot));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", glassStorageDetails.getShelf()));
//                miloService.writeToOpcWord(list);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, glassStorageDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
                return Boolean.TRUE;
            }
            return Boolean.FALSE;
        }
        //todo:1条线且当条线为2号上片为
        if (LOAD_STATION_MAX.contains(glassStorageDetails.getSlot())) {
            log.info("上片位2号有架子，结束本条线{}的调度任务", stationCell);
            if (!((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId())))
                    || ((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId()))
                    && glassStorageDetails.getRemainQuantity() == 0)) {
                //将架子放回原工位上
                rawGlassStorageDetailsService.generateTask(endSlot02, glassStorageDetails.getShelf(), glassStorageDetails.getShelf(), 0, Const.RAW_GLASS_TASK_TYPE_DISPATCH);
//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", endSlot02));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", glassStorageDetails.getShelf()));
//                miloService.writeToOpcWord(list);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, glassStorageDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
                return Boolean.TRUE;
            }
            return Boolean.FALSE;
        } else {
            //比较当前1号架子上的玻璃剩余数量是否为0或者已用完
            if (usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId())) {
                RawGlassStorageDetails details = null;
                if (upPattenUsage01VOS.size() > glassStorageDetails.getRemainQuantity()) {
                    //2号位上片：继续当前尺寸的原片
                    details = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
                            .eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
                            .eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
                            .eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
                            .gt(RawGlassStorageDetails::getRemainQuantity, upPattenUsage01VOS.size())
                            .orderByAsc(RawGlassStorageDetails::getRemainQuantity)
                            .last("limit 1"));
        RawGlassStorageDetails oneLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(0))).findFirst().orElse(null);
        if (null == oneLoadStation) {
            RawGlassStorageDetails twoLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(1))).findFirst().orElse(null);
            if (twoLoadStation.getRemainQuantity() > 0) {
                if (compareRawSize(usageVOS.get(0), twoLoadStation)) {
//                    2号上片位的原片信息源工程信息一致，可上片操作，结束本次任务
                    return Boolean.FALSE;
                } else {
                    //2号位上片：获取第二种尺寸的原片
                    List<UpPattenUsageVO> upPattenUsage02VOS = upListMap.get("2");
                    if (CollectionUtils.isEmpty(upPattenUsage01VOS)) {
                        return Boolean.FALSE;
                    }
                    usageVO = upPattenUsage02VOS.get(0);
                    details = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
                            .eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
                            .eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
                            .eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
                            .gt(RawGlassStorageDetails::getRemainQuantity, upPattenUsage01VOS.size())
                            .orderByAsc(RawGlassStorageDetails::getRemainQuantity)
                            .last("limit 1"));
//                    生成1号位入库任务
                    log.info("2号上片位玻璃尺寸不一致，1号上片位生成调度任务");
                    //按照尺寸及数量获取数量最接近的格子信息
                    RawGlassStorageDetails rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
                    rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), loadStation.get(0), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                    //结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101  目标位新增一条数据，架子号为（起始位）
                    rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                            .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
                    return Boolean.TRUE;
                }
                //将工位的架子传送到上片位
                rawGlassStorageDetailsService.generateTask(details.getSlot(), endSlot02, details.getShelf(), details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, details.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));

//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", glassStorageDetails.getShelf()));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", endSlot02));
//                miloService.writeToOpcWord(list);

                return Boolean.TRUE;
            } else {
                //将架子放回原工位上
                rawGlassStorageDetailsService.generateTask(endSlot, glassStorageDetails.getShelf(), glassStorageDetails.getShelf(), glassStorageDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
//                生成1号位入库任务
                log.info("2号上片位仅剩空架子，1号上片位生成调度任务");
                RawGlassStorageDetails rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
                rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), loadStation.get(0), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, endSlot).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
                return Boolean.TRUE;
            }
        } else {
            String tableName = stationCell == 5 ? LOAD_GLASS_DEVICE_ONE_TASK : LOAD_GLASS_DEVICE_TWO_TASK;
            if (oneLoadStation.getRemainQuantity() > 0) {
                if (compareRawSize(usageVOS.get(0), oneLoadStation)) {
                    //结束仓储调度，等待上片任务
                    //在上片任务执行空闲过程中,可执行二号位出入库任务  二号架子的信息是否需要调度,不需要调度直接放回false
                    log.info("获取二号位原片信息");
                    RawGlassStorageDetails twoLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(1))).findFirst().orElse(null);
                    if (null == twoLoadStation) {
                        //按照尺寸生成二号位上片任务信息
                        LoadGlassDeviceTask loadTask = loadGlassDeviceTaskService.queryTaskMessage(tableName);
                        RawGlassStorageDetails rawDetails = null;
                        if (oneLoadStation.getRemainQuantity() > (loadTask.getTotalCount() + loadTask.getDamageCount())) {
                            usageVOS = upListMap.get("2");
                            if (CollectionUtils.isEmpty(usageVOS)) {
                                log.info("当前工程的原片即将用完，结束本次调度");
                                return Boolean.FALSE;
                            }
                            rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
                        } else {
                            rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());

//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", endSlot));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", glassStorageDetails.getShelf()));
//                miloService.writeToOpcWord(list);
                        }
                        rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), loadStation.get(1), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                        //结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101  目标位新增一条数据，架子号为（起始位）
                        rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                                .eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                                .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
                        return Boolean.TRUE;
                    } else {
                        //todo:当二号为的尺寸大于0时，是否执行调度任务，更换当前原片的尺寸，等待下一次任务的直接执行；还是继续等待，当尺寸不一样，等待一号工位的进出库调度任务。
                        if (twoLoadStation.getRemainQuantity() > 0) {
                            LoadGlassDeviceTask loadTask = loadGlassDeviceTaskService.queryTaskMessage(tableName);
                            if (oneLoadStation.getRemainQuantity() > (loadTask.getTotalCount() + loadTask.getDamageCount())) {
                                usageVOS = upListMap.get("2");
                                if (CollectionUtils.isEmpty(usageVOS)) {
                                    log.info("当前工程的原片即将用完，结束本次调度");
                                    return Boolean.FALSE;
                                }
                            }
                            if (compareRawSize(usageVOS.get(0), twoLoadStation)) {
//                              //2号上片位的原片信息源工程信息一致，可上片操作，结束本次任务
                                return Boolean.FALSE;
                            } else {
//                    生成1号位入库任务
                                log.info("2号上片位玻璃尺寸不一致，2号上片位生成出片调度任务");
                                //按照尺寸及数量获取数量最接近的格子信息
                                rawGlassStorageDetailsService.generateTask(loadStation.get(1), twoLoadStation.getShelf(), twoLoadStation.getShelf(), twoLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                                //结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101  目标位新增一条数据，架子号为（起始位）
                                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                                        .eq(RawGlassStorageDetails::getSlot, loadStation.get(1)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                                        .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
                                return Boolean.TRUE;
                            }
                        } else {
                            //todo:生成出库任务
                            rawGlassStorageDetailsService.generateTask(loadStation.get(1), twoLoadStation.getShelf(), twoLoadStation.getShelf(), twoLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                            //结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101  目标位新增一条数据，架子号为（起始位）
                            rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                                    .eq(RawGlassStorageDetails::getSlot, loadStation.get(1)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                                    .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
                            return Boolean.TRUE;
                        }
                    }
//                    return Boolean.FALSE;
                } else {
                    log.info("2号上片位仅剩空架子，1号上片位生成出库调度任务");
                    rawGlassStorageDetailsService.generateTask(loadStation.get(0), oneLoadStation.getShelf(), oneLoadStation.getShelf(), oneLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                    rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getSlot, loadStation.get(0)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                            .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
                    return Boolean.TRUE;
                }
            } else {
                log.info("1号上片位玻璃尺寸不一致，1号上片位生成出库调度任务");
                rawGlassStorageDetailsService.generateTask(loadStation.get(0), oneLoadStation.getSlot(), oneLoadStation.getShelf(), oneLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, loadStation.get(0)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
                return Boolean.TRUE;
            }
        }
@@ -478,5 +474,29 @@
        return readWriteEntity;
    }

    private RawGlassStorageDetails getRawGlassStorageDetailsBySize(UpPattenUsageVO usageVO, int remainQuantity) {
        return rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
                .eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
                .eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
                .eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
                .orderByAsc(RawGlassStorageDetails::getRemainQuantity)
                .last("order by abs(t.remain_quantity - " + remainQuantity + ")  asc")
                .last("limit 1"));
    }

    /**
     * 尺寸一样并且原片数量大于0
     *
     * @param upPattenUsage
     * @param details
     * @return
     */
    private boolean compareRawSize(UpPattenUsage upPattenUsage, RawGlassStorageDetails details) {
        boolean flag = upPattenUsage.getWidth() == details.getPatternWidth() && upPattenUsage.getHeight() == details.getPatternHeight() &&
                upPattenUsage.getThickness() == details.getPatternThickness() && upPattenUsage.getFilmsId().equals(details.getFilmsId());
        return flag;
    }

}