大理片调度逻辑修改，进出片改为升序，调度逻辑修改

ZengTao

2024-12-03 d219290089df8c9acd2e84ab0f135fc42e3b682d

大理片调度逻辑修改，进出片改为升序，调度逻辑修改

 UI-Project/src/router/index.js

@@ -291,6 +291,19 @@
      },
    ]
  },
  /*----------- 报表管理 ----------------*/
  {
    path: 'reportmanage',
    name: 'reportmanage',
    component: () => import('../views/Reportmanage/reportmanage.vue'),
    children:[
      {
        path: '/Reportmanage/reportmanage',
        name: 'reportmanage',
        component: () => import('../views/Reportmanage/reportmanage.vue')
      },
    ]
  },
        /*----------- 管理系统 ----------------*/
        {
          path: 'sys',

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

@@ -48,7 +48,7 @@
    EdgGlassTaskQueueInfoService edgGlassTaskQueueInfoService;
    private int sum = 0;

    @Scheduled(fixedDelay = 10)
//    @Scheduled(fixedDelay = 10)
    public void startOpcTask() throws Exception {
//        miloService.subscriptionFromOpcUa(Arrays.asList("C101-WL.S7-1200.plc_task_state", "D101-WL.S7-1200.plc_task_state"), cacheGlassStartCallback);
//        miloService.subscriptionFromOpcUa(Arrays.asList("mes.dec.edg_storage_device_one_task[1].task_state", "D101-WL.S7-1200.plc_task_state"), cacheGlassTestCallback);

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/CacheVerticalClassModuleApplication.java

@@ -18,7 +18,7 @@
@EnableSwagger2WebMvc
@EnableDiscoveryClient
@MapperScan(basePackages = "com.mes.*.mapper")
//@EnableScheduling
@EnableScheduling
public class CacheVerticalClassModuleApplication {
    public static void main(String[] args) {
        try {

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/impl/BigStorageCageDetailsServiceImpl.java

@@ -283,7 +283,7 @@
                    .eq(BigStorageCageDetails::getLayer, glassInfo.getLayer());
//            wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
        } else {
            wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() + 1);
            wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() - 1);
        }
        BigStorageCage bigStorageCage = bigStorageCageService.selectJoinOne(BigStorageCage.class, wrapper);
        if (null != bigStorageCage) {
@@ -327,15 +327,30 @@
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 6, 8)
        );
        if (glassInfo.getThickness() == 8) {
            deviceUsedList.removeIf(device -> device < 6);
        } else {
            if (engineerCount1.size() > engineerCount2.size()) {
        BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
                        .orderByAsc(BigStorageCageDetails::getSlot)
                        .last("limit 1")
        );
        if (bigStorageCageDetails == null) {
            if (glassInfo.getThickness() == 8) {
                deviceUsedList.removeIf(device -> device < 6);
            } else {
                if (engineerCount1.size() > engineerCount2.size()) {
                    deviceUsedList.removeIf(device -> device < 6);
                } else {
                    deviceUsedList.removeIf(device -> device > 5);
                }
            }
        } else {
            if (bigStorageCageDetails.getDeviceId() >= 1 && bigStorageCageDetails.getDeviceId() <= 5) {
                deviceUsedList.removeIf(device -> device > 5);
            } else {
                deviceUsedList.removeIf(device -> device < 6);
            }
        }

        if (CollectionUtils.isEmpty(deviceUsedList)) {
            deviceUsedList = deviceUseds;
        }
@@ -398,7 +413,6 @@
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        if (temperingGlassInfoList.size() == 0) {
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                    .selectAll(GlassInfo.class)
@@ -412,7 +426,7 @@
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                if ("0".equals(temperingFeedSequence)) {
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, "");
                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, 1);
                    }
                } else {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java

@@ -71,20 +71,20 @@
    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Scheduled(fixedDelay = Long.MAX_VALUE)
//    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void startOpcTask() throws Exception {
        //设备一二的进片请求
        miloService.subscriptionFromOpcUa(Arrays.asList("my.device01.x1", "my.device02.x1"), bigStorageStartCallback);
    }

    @Scheduled(fixedDelay = Long.MAX_VALUE)
//    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void outOpcTask() throws Exception {
        //设备1的出片请求
        miloService.subscriptionFromOpcUa(Arrays.asList("my.device03.x1"), bigStorageStartCallback);
    }


    @Scheduled(fixedDelay = 300)
//    @Scheduled(fixedDelay = 300)
    public void updateInGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼进片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
@@ -119,7 +119,7 @@

    }

    @Scheduled(fixedDelay = 300)
//    @Scheduled(fixedDelay = 300)
    public void updateOutGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
@@ -163,7 +163,7 @@

    }

    @Scheduled(fixedDelay = 300)
//    @Scheduled(fixedDelay = 300)
    public void updateScheduleGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼调度完成后更新大理片笼数据任务开始执行时间：{}", startDate);
@@ -203,7 +203,7 @@
    /**
     * 处理破损表任务
     */
    @Scheduled(fixedDelay = 300)
//    @Scheduled(fixedDelay = 300)
    public void dealDamageTask() {
        Date startDate = new Date();
        log.info("大理片笼破损玻璃清除任务开始执行时间：{}", startDate);

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/PlcStorageCageTask.java

@@ -22,7 +22,6 @@
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
@@ -33,6 +32,7 @@
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.S7control;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
@@ -98,6 +98,9 @@
    private String d01GlassId = "";
    private String d04GlassId = "";

    private List<BigStorageCageOutTask> allTask = new ArrayList<>();
    private List<BigStorageCageOutTask> notAllTask = new ArrayList<>();

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgScan() {
        Date startDate = new Date();
@@ -117,7 +120,7 @@
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();


//        d04Id="P24110503|17|4";
//        d01Id="P24111102|1|13";
//        d04ToMES="1";
//        d01ToMES="1";

@@ -132,13 +135,13 @@
        }
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃:  状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， （02玻璃id为空或者卧转立未启动）
        if (!REQUEST_WORD.equals(mesD01Value) && REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks=bigStorageCageFeedTaskService.list(
              new LambdaQueryWrapper<BigStorageCageFeedTask>()
              .gt(BigStorageCageFeedTask::getTargetSlot,0)
                    .eq(BigStorageCageFeedTask::getLine,Const.A09_OUT_TARGET_POSITION)
                      .eq(BigStorageCageFeedTask::getTaskState,Const.BIG_STORAGE_IN_UP)
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            if(CollectionUtils.isEmpty(bigStorageCageFeedTasks)){
            if (CollectionUtils.isEmpty(bigStorageCageFeedTasks)) {
                if (!d01GlassId.equals(d01Id)) {
                    judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
                    edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
@@ -149,13 +152,13 @@
        }
//        状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， 卧转立未启动
        if (!REQUEST_WORD.equals(mesD04Value) && REQUEST_WORD.equals(d04ToMES) && !REQUEST_WORD.equals(d05State)) {
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks=bigStorageCageFeedTaskService.list(
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
                            .gt(BigStorageCageFeedTask::getTargetSlot,0)
                            .eq(BigStorageCageFeedTask::getLine,Const.A10_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState,Const.BIG_STORAGE_IN_UP)
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            if(CollectionUtils.isEmpty(bigStorageCageFeedTasks)){
            if (CollectionUtils.isEmpty(bigStorageCageFeedTasks)) {
                if (!d04GlassId.equals(d04Id)) {
                    judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
                    edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
@@ -204,11 +207,6 @@
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            Date endDate = new Date();
            log.info("卧转立第一次没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            Date endDate = new Date();
            log.info("卧转立第二次没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
//        List<Integer> lines=new ArrayList<>();
@@ -260,8 +258,8 @@
                //获取卧转立剩余宽度
                if (computeIsRun(lineFirst, lineGlassId)) {
                    computeTargetByLine(lineFirst);
                }else{
                    log.info("当前线路：{}，有扫码玻璃：{}",lineFirst,lineGlassId);
                } else {
                    log.info("当前线路：{}，有扫码玻璃：{}", lineFirst, lineGlassId);
                }
            }
            Date endDate = new Date();
@@ -308,7 +306,7 @@
    @Scheduled(fixedDelay = 10000)
    public void plcToHomeEdgOutTask() {
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        log.info("大理片笼出片任务开始执行时间：{}", startDate);
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String e02State = plcMesObject.getPlcParameter("E02State").getValue();
        if (REQUEST_WORD.equals(e02State)) {
@@ -326,13 +324,16 @@
            //是否有正在钢化的玻璃
            List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                    .selectAll(TemperingGlassInfo.class)
                    .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                    .leftJoin(BigStorageCageOutTask.class, on -> on
                            .eq(TemperingGlassInfo::getGlassId, BigStorageCageOutTask::getGlassId)
                            .ne(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS))
                    .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                    .isNull(BigStorageCageOutTask::getGlassId)
                    .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
            log.info("查询的出片任务：{}", temperingGlassInfoList);
            if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
                log.info("有正在出片的钢化任务");
                computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, 1);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
@@ -345,7 +346,7 @@
                    .orderByAsc(BigStorageCageDetails::getSlot)
                    .orderByDesc(BigStorageCageDetails::getId));
            if (CollectionUtils.isNotEmpty(artificialList)) {
                computeOutMoreGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
                computeOutMoreGlassInfo(artificialList, Boolean.FALSE, 1);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
@@ -368,7 +369,7 @@
                                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                            temperingGlassInfoService.saveBatch(temperingGlassInfos);
                            computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                            computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, 1);
                            Date endDate = new Date();
                            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                            return;
@@ -376,43 +377,100 @@
                    }
                }
            }
        }
        //执行内部调度任务
        List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
            loop:
            for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
                for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                    SlotSequenceDTO first = slotSequenceList.get(i);
                    SlotSequenceDTO second = slotSequenceList.get(i + 1);
                    int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                    if (first.getMinSequence() == second.getMaxSequence() + 1
                            && second.getRemainWidth() > slotWidth && slotWidth >= 0) {
                        List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(list)) {
                            List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                            int serialNumber = 1;
                            for (BigStorageCageDetails item : list) {
                                outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
                                        item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
        } else {
            //执行内部调度任务
            List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
            if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
                loop:
                for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                    List<GlassInfo> glassInfoList = glassInfoService.list(
                            new LambdaQueryWrapper<GlassInfo>()
                                    .eq(GlassInfo::getTemperingLayoutId, temperingOccupySlot.getTemperingLayoutId())
                                    .eq(GlassInfo::getEngineerId, temperingOccupySlot.getEngineerId())
                                    .notInSql(GlassInfo::getGlassId, "select glass_id from damage where type=8 and engineer_id='"
                                            + temperingOccupySlot.getEngineerId() + "' and tempering_layout_id = '" + temperingOccupySlot.getTemperingLayoutId() + "'")
                    );
                    List<BigStorageCageDetails> glassInfoLists = new ArrayList<>();
                    glassInfoList.forEach(glassInfo -> {
                        BigStorageCageDetails details = new BigStorageCageDetails();
                        BeanUtils.copyProperties(glassInfo, details);
                        details.setSlot(1);
                        glassInfoLists.add(details);
                    });
                    List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsService.list(
                            new LambdaQueryWrapper<BigStorageCageDetails>()
                                    .eq(BigStorageCageDetails::getEngineerId, temperingOccupySlot.getEngineerId())
                                    .eq(BigStorageCageDetails::getTemperingLayoutId, temperingOccupySlot.getTemperingLayoutId())
                                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                    .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence)
                    );
//                    if (glassInfoLists.size() == bigStorageCageDetailsList.size()) {
                        computeOutMoreGlassInfo(glassInfoLists, Boolean.TRUE, 2);
                        computeOutMoreGlassInfo(bigStorageCageDetailsList, Boolean.TRUE, 3);
                        int allTrainNumber = allTask.stream()
                                .map(BigStorageCageOutTask::getTrainNumber)
                                .collect(Collectors.toSet())
                                .size();
                        int allTrainSlot = allTask.stream()
                                .map(BigStorageCageOutTask::getStartSlot)
                                .collect(Collectors.toSet())
                                .size();
                        int notallTrainNumber = notAllTask.stream()
                                .map(BigStorageCageOutTask::getTrainNumber)
                                .collect(Collectors.toSet())
                                .size();
                        int notallTrainSlot = notAllTask.stream()
                                .map(BigStorageCageOutTask::getStartSlot)
                                .collect(Collectors.toSet())
                                .size();
//                        if (allTrainNumber < notallTrainNumber || (allTrainNumber == notallTrainNumber && allTrainSlot < notallTrainSlot)) {
                            List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
                            for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                                SlotSequenceDTO first = slotSequenceList.get(i);
                                SlotSequenceDTO second = slotSequenceList.get(i + 1);
                                int slotWidth = first.getRemainWidth() - glassGap;
                                List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                        .eq(BigStorageCageDetails::getSlot, second.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                        .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                                if (CollectionUtils.isNotEmpty(list)) {
                                    List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                                    int serialNumber = 1;
                                    for (BigStorageCageDetails item : list) {
                                        int maxlength=(int)Math.max(item.getWidth(), item.getHeight());
                                        if (slotWidth > maxlength) {
                                            slotWidth = slotWidth - maxlength- glassGap;
                                            outTasks.add(new BigStorageCageOutTask(item.getGlassId(), second.getSlot(), first.getSlot(),
                                                    item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
                                        } else {
                                            outTasks.add(new BigStorageCageOutTask(item.getGlassId(), second.getSlot(), second.getSlot(),
                                                    item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
                                        }
                                    }
                                    List<String> glassList = outTasks.stream()
                                            .filter(item -> !item.getStartSlot().equals(item.getEndSlot()))
                                            .map(BigStorageCageOutTask::getGlassId)
                                            .collect(Collectors.toList());
                                    if(glassList.size()>0){
                                        //新增调度任务
                                        bigStorageCageOutTaskService.saveBatch(outTasks);
                                        //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
//                                    List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());

                                        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                                .set(BigStorageCageBaseInfo::getSlot, first.getSlot()).in(BigStorageCageDetails::getGlassId, glassList)
                                                .ne(BigStorageCageDetails::getState,Const.GLASS_STATE_OUT));

                                        //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                                        // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
                                        updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
                                        break loop;
                                    }

                                }
                            }
                            //新增调度任务
                            bigStorageCageOutTaskService.saveBatch(outTasks);
                            //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
                            List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
                            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                    .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList));
                            //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                            // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
                            updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
                            break loop;
                        }
                    }
//                        }
//                    }
                }
            }
//            //向plc写入确认字
//            int returnData = 0;
//            int count = 1;
@@ -422,10 +480,12 @@
//                returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
//                log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
//            }
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
        }

    }

    @Scheduled(fixedDelay = 300)
@@ -469,7 +529,8 @@
        log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
        //因为大理片笼和出片任务是两个库的数据，所以要分开查找
        List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
                .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING));
                .select(BigStorageCageDetails::getGlassId)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
@@ -627,19 +688,19 @@
        String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
        if (!REQUEST_WORD.equals(d01ToMES)) {
            log.info("地址：{}写入0",mesD01Address);
            log.info("地址：{}写入0", mesD01Address);
            S7object.getinstance().plccontrol.writeWord(mesD01Address, 0);
        }
        if (!REQUEST_WORD.equals(d04ToMES)) {
            log.info("地址：{}写入0",mesD04Address);
            log.info("地址：{}写入0", mesD04Address);
            S7object.getinstance().plccontrol.writeWord(mesD04Address, 0);
        }
        if (!REQUEST_WORD.equals(d03ToMES)) {
            log.info("地址：{}写入0",mesD03Address);
            log.info("地址：{}写入0", mesD03Address);
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
        }
        if (!REQUEST_WORD.equals(d05ToMES)) {
            log.info("地址：{}写入0",mesD05Address);
            log.info("地址：{}写入0", mesD05Address);
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
        }
    }
@@ -680,8 +741,8 @@
                    .filter(glassIds1::contains)
                    .distinct()
                    .collect(Collectors.toList());
            log.info("D3id{},匹配id:{}",glassIds1,matchingIds1);
            if(CollectionUtils.isNotEmpty(matchingIds1)){
            log.info("D3id{},匹配id:{}", glassIds1, matchingIds1);
            if (CollectionUtils.isNotEmpty(matchingIds1)) {
                bigStorageCageFeedTaskService.update(
                        new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, matchingIds1)
@@ -696,8 +757,8 @@
                    .filter(glassIds2::contains)
                    .distinct()
                    .collect(Collectors.toList());
            log.info("D5id{},匹配id:{}",glassIds2,matchingIds2);
            if(CollectionUtils.isNotEmpty(matchingIds2)){
            log.info("D5id{},匹配id:{}", glassIds2, matchingIds2);
            if (CollectionUtils.isNotEmpty(matchingIds2)) {
                bigStorageCageFeedTaskService.update(
                        new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, matchingIds2)
@@ -708,7 +769,7 @@
        }
        if (CollectionUtils.isEmpty(glassIds1)) {
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
            log.info("{}线修改玻璃状态为3",Const.A09_OUT_TARGET_POSITION);
            log.info("{}线修改玻璃状态为3", Const.A09_OUT_TARGET_POSITION);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
@@ -720,7 +781,7 @@
        }
        if (CollectionUtils.isEmpty(glassIds2)) {
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
            log.info("{}线修改玻璃状态为3",Const.A10_OUT_TARGET_POSITION);
            log.info("{}线修改玻璃状态为3", Const.A10_OUT_TARGET_POSITION);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
@@ -770,8 +831,8 @@
                );
                EdgGlassTaskInfo edgGlassTaskInfo = new EdgGlassTaskInfo();
                BeanUtils.copyProperties(glassInfo, edgGlassTaskInfo);
                edgGlassTaskInfo.setWidth((int) glassInfo.getWidth());
                edgGlassTaskInfo.setHeight((int) glassInfo.getHeight());
                edgGlassTaskInfo.setWidth((int) glassInfo.getWidth() * 10);
                edgGlassTaskInfo.setHeight((int) glassInfo.getHeight() * 10);
                edgGlassTaskInfoList.add(edgGlassTaskInfo);
                log.info("在玻璃信息表中获取玻璃信息{}", edgGlassTaskInfoList);
            }
@@ -927,8 +988,12 @@
                .collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
        for (BigStorageCageFeedTask e : taskList) {
            //替换玻璃id
            queryAndChangeGlass(e.getGlassId());
            GlassInfo info = glassInfoMap.get(e.getGlassId());
//            queryAndChangeGlass(e.getGlassId());
            GlassInfo info = glassInfoService.getOne(
                    new LambdaQueryWrapper<GlassInfo>()
                            .eq(GlassInfo::getGlassId, e.getGlassId())
            );
//            GlassInfo info = glassInfoMap.get(e.getGlassId());
            if (info == null) {
                continue;
            }
@@ -996,7 +1061,7 @@
                returnData = glassIds2;
            }
//            returnData = s7control.readWord(outLine, 1).get(0);
            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2,returnData);
            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2, returnData);
        }
//        while (returnData != 0) {
//            s7control.writeWord(outLine, 2);
@@ -1070,11 +1135,11 @@
     *
     * @param list
     * @param isTempering
     * @param mesToPLCAddress
     * @param isTask
     * @param <T>
     * @return
     */
    public <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
    public <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, Integer isTask) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
@@ -1082,26 +1147,44 @@
        int trainNumber = 1;
        int serialNumber = 1;
        int maxX = 0;
        int slot = 0;
        for (T e : list) {
            int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
            if (serialNumber > outCarMaxSize || maxLength > remainWidth) {
                remainWidth = carWidth;
                trainNumber = trainNumber + 1;
                serialNumber = 1;
                maxX = 0;
            }
            remainWidth = remainWidth - maxLength - glassGap;
            if (isTempering) {
                int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
                if (maxX + minLength <= xMaxSize) {
                if (maxX + minLength <= xMaxSize && serialNumber <= outCarMaxSize && remainWidth > maxLength) {
                    if (slot != e.getSlot() && slot != 0) {
                        int finalMaxX = maxX;
                        int finalSerialNumber = serialNumber;
                        int finalRemainWidth = remainWidth;
                        List<T> lists = list.stream().filter(t -> t.getSlot() == (int) e.getSlot()).collect(Collectors.toList());
                        for (T x : lists) {
                            int finalMinLength = Math.min((int) x.getWidth(), (int) x.getHeight());
                            int finalMaxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
                            if (finalMaxX + finalMinLength > xMaxSize || finalSerialNumber > outCarMaxSize || finalMaxLength > finalRemainWidth) {
                                remainWidth = carWidth;
                                trainNumber = trainNumber + 1;
                                serialNumber = 1;
                                maxX = 0;
                                break;
                            } else {
                                finalMaxX = Math.max(maxX, x.getXCoordinate());
                                finalRemainWidth = finalRemainWidth - finalMaxLength - glassGap;
                                finalSerialNumber++;
                            }
                        }
                    }
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                    remainWidth = remainWidth - maxLength - glassGap;
                    maxX = Math.max(maxX, e.getXCoordinate());
                    slot = e.getSlot();
                } else {
                    remainWidth = carWidth - maxLength - glassGap;
                    trainNumber = trainNumber + 1;
                    serialNumber = 1;
                    maxX = e.getXCoordinate();
                    slot = e.getSlot();
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
                }
@@ -1109,6 +1192,13 @@
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
            }
        }
        if (isTask == 2) {
            allTask = bigStorageCageOutTaskList;
            return Boolean.FALSE;
        } else if (isTask == 3) {
            notAllTask = bigStorageCageOutTaskList;
            return Boolean.FALSE;
        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
@@ -1182,7 +1272,7 @@
                .eq(GlassInfo::getLayer, glassInfo.getLayer())
                .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
                .notInSql(GlassInfo::getGlassId, "select distinct glass_id from big_storage_cage_details " +
                        "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight())
                        "where state!=101 and engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight())
                .orderByAsc(GlassInfo::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                .last("Limit 1");

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/opccallback/BigStorageStartCallback.java

@@ -121,7 +121,7 @@
    }


    @Scheduled(fixedDelay = 10000)
//    @Scheduled(fixedDelay = 10000)
    public void plcToHomeEdgOutTask() {
        String mesToPLCAddress = "";
        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
@@ -233,7 +233,7 @@
    /**
     * 确认字清空
     */
    @Scheduled(fixedDelay = 300)
//    @Scheduled(fixedDelay = 300)
    public void confirmClear() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
@@ -261,7 +261,7 @@
    /**
     * 进片状态修改
     */
    @Scheduled(fixedDelay = 300)
//    @Scheduled(fixedDelay = 300)
    public void feedStatusUpdate() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        List<String> glassIds1 = new ArrayList<>();
@@ -716,7 +716,7 @@
        return null;
    }

    @Scheduled(fixedDelay = 300)
//    @Scheduled(fixedDelay = 300)
    public void querySizeByEngineerTask() {
        log.info("查询结果：{}", querySizeByEngineer("P24072402", 1, 10, 8));
        log.info("查询结果：{}", querySizeByEngineer("P24072402", 1, 5, 8));

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

@@ -11,16 +11,16 @@
  task:
    scheduling:
      pool:
        size: 2
        size: 10
      thread-name-prefix: task-cacheVertical
mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
#  configuration:
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
mes:
  sequence:
    order: false
  minCount: 20
    order: true
  minCount: 2
  carWidth: 5000   #大车宽度
  slotWidth: 5500   #大车宽度
  inCarMaxSize: 2    #进片大车最大存放玻璃数量

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageDetailsMapper.xml

@@ -46,17 +46,16 @@
                 INNER JOIN ENGINEERING T4 ON T2.ENGINEER_ID=T4.ENGINEER_ID
        ORDER BY T4.ID, T2.TEMPERING_LAYOUT_ID
    </select>

    <select id="queryTemperingOccupySlot" resultMap="temperingLayoutDTO">
        SELECT ENGINEER_ID,
               TEMPERING_LAYOUT_ID,
               COUNT(DISTINCT SLOT) as SLOT_COUNT
        FROM BIG_STORAGE_CAGE_DETAILS
        WHERE STATE = 100
        WHERE STATE = 100 AND TEMPERING_LAYOUT_ID!=0
        GROUP BY ENGINEER_ID,
                 TEMPERING_LAYOUT_ID
        HAVING SLOT_COUNT &gt;= #{count}
        ORDER BY SLOT_COUNT DESC
        ORDER BY ID DESC
    </select>
    <select id="queryGlassMaxAndMin" resultMap="slotSequenceDTO">
        SELECT T.*,
@@ -70,6 +69,7 @@
                 FROM BIG_STORAGE_CAGE_DETAILS
                 WHERE ENGINEER_ID = #{engineerId}
                   AND TEMPERING_LAYOUT_ID = #{temperingLayoutId}
                   AND STATE = 100
                 GROUP BY ENGINEER_ID,
                          TEMPERING_LAYOUT_ID,
                          SLOT
@@ -89,12 +89,13 @@
                (#{item.glassId}, #{item.targetSlot})
            </foreach>
            )
            and state!=101
        </where>
    </update>

    <select id="selectTemperingGlassCount" resultType="java.util.Map">
        select a.engineer_id,a.tempering_layout_id,count2,count1,count2-count1 as count3,count(c.glass_id) as count4 from
            (select engineer_id,tempering_layout_id,count(*) as count1 from big_storage_cage_details where state=100 group by engineer_id,tempering_layout_id) as a
            (select engineer_id,tempering_layout_id,count(*) as count1 from big_storage_cage_details where state=100 and tempering_layout_id!=0 group by engineer_id,tempering_layout_id) as a
                left join
            (select engineer_id,tempering_layout_id,count(*) as count2 from glass_info group by engineer_id,tempering_layout_id) as b
            on a.engineer_id=b.engineer_id and a.tempering_layout_id=b.tempering_layout_id

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/test/java/com/mes/CacheVerticalGlassModuleApplicationTest.java

@@ -7,11 +7,14 @@
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.common.config.Const;
@@ -19,10 +22,12 @@
import com.mes.damage.service.DamageService;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.job.PlcStorageCageTask;
import com.mes.pp.entity.ReportingWork;
import com.mes.pp.entity.ReportingWorkDetail;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -30,6 +35,7 @@
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
@@ -254,6 +260,19 @@
        plcStorageCageTask.queryAndChangeGlass("P24110503|17|4");
    }

    @Resource
    TemperingGlassInfoService temperingGlassInfoService;
    @Test
    public void computeOutMoreGlassInfo() {
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                .selectAll(TemperingGlassInfo.class)
                .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .isNull(BigStorageCageOutTask::getGlassId)
                .orderByAsc(TemperingGlassInfo::getTemperingFeedSequence));
        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfoList,true,1);
    }

    @Test
    public void ca() {
        try {

 hangzhoumesParent/moduleService/GlassStorageModule/src/test/java/mes/GlassStorageModuleApplicationTest.java

@@ -3,13 +3,7 @@
import com.mes.GlassStorageApplication;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.rawglasstask.entity.RawGlassStorageTask;
import com.mes.rawglasstask.entity.request.RawGlassTaskRequest;
import com.mes.rawglasstask.service.RawGlassStorageTaskService;
import com.mes.rawusage.entity.RawUsage;
import com.mes.rawusage.service.RawUsageService;
import com.mes.shelfrack.service.ShelfRackService;
import com.mes.storagetask.service.StorageTaskService;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -17,12 +11,7 @@
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
@@ -37,13 +26,6 @@
public class GlassStorageModuleApplicationTest {



    @Autowired
    private StorageTaskService storageTaskService;
    @Autowired
    private ShelfRackService shelfRackService;
    @Autowired
    private RawUsageService rawUsageService;
    @Autowired
    private RawGlassStorageDetailsService rawGlassStorageDetailsService;
    @Autowired
@@ -64,12 +46,12 @@
//        storageTaskService.getBaseMapper().deleteById(1);
       // storageTaskService.findList(storageTask);
        ///storageTaskService.findLatestTasks();
        storageTaskService.Tasks();
//        storageTaskService.Tasks();
    }
    @Test
    public void selectshelf_rack() {

        shelfRackService.selectshelf_rack();
//        shelfRackService.selectshelf_rack();
    }

    /**
@@ -108,13 +90,13 @@



    @Test
    public void updateRawPackageAndStorageRack() {
        RawUsage raw=new RawUsage();

        raw.setId(null);
        rawUsageService.updateRawPackageAndStorageRack(raw);
    }
//    @Test
//    public void updateRawPackageAndStorageRack() {
//        RawUsage raw=new RawUsage();
//
//        raw.setId(null);
//        rawUsageService.updateRawPackageAndStorageRack(raw);
//    }
    @Test
    public void txt() {
        RawGlassStorageDetails rs=new RawGlassStorageDetails();