1、指定钢化工程接口

zhoushihao

2024-12-23 eae89f75a208938dba8787a73f68a8ae2e44e165

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

@@ -2,16 +2,14 @@

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.toolkit.CollectionUtils;
import com.github.yulichang.base.MPJBaseServiceImpl;
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.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.entity.dto.*;
import com.mes.bigstorage.entity.vo.BigStorageQueryVO;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
@@ -21,15 +19,17 @@
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
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.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.job.PlcStorageCageTask;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
@@ -49,6 +49,7 @@
 * @author zhoush
 * @since 2024-03-27
 */
@Slf4j
@Service
public class BigStorageCageDetailsServiceImpl extends MPJBaseServiceImpl<BigStorageCageDetailsMapper, BigStorageCageDetails> implements BigStorageCageDetailsService {

@@ -70,6 +71,9 @@
    private TemperingGlassInfoService temperingGlassInfoService;

    @Resource
    private PlcStorageCageTask plcStorageCageTask;

    @Resource
    private DamageService damageService;
    @Resource
    private RedisUtil redisUtil;
@@ -88,10 +92,10 @@


    @Override
    public List<BigStorageCageDetails> selectFeedTask(){
    public List<BigStorageCageDetails> selectFeedTask() {
        //进片任务数据
        LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
        feedWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
        feedWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW);
        List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(feedWrapper);

        LambdaQueryWrapper<BigStorageCageFeedTask> feedTaskWrapper = new LambdaQueryWrapper<>();
@@ -101,40 +105,39 @@
        List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(feedTaskWrapper);
        Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
            Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
            while (iterator.hasNext()) {
                BigStorageCageDetails bigStorageCageDetails = iterator.next();
                BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
            }
            return bigStorageCageDetailsList;
        Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
        while (iterator.hasNext()) {
            BigStorageCageDetails bigStorageCageDetails = iterator.next();
            BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
        }
        return bigStorageCageDetailsList;
    }

    @Override
    public List<BigStorageCageDetails> selectOutTask(){
            LambdaQueryWrapper<BigStorageCageDetails> outWrapper = new LambdaQueryWrapper<>();
            outWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(outWrapper);
    public List<BigStorageCageDetails> selectOutTask() {
        LambdaQueryWrapper<BigStorageCageDetails> outWrapper = new LambdaQueryWrapper<>();
        outWrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING, Const.GLASS_STATE_SCHEDULE_ING);
        List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(outWrapper);
        LambdaQueryWrapper<BigStorageCageOutTask> outTaskWrapper = new LambdaQueryWrapper<>();
        outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS);
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = bigStorageCageOutTaskMapper.selectList(outTaskWrapper);

            LambdaQueryWrapper<BigStorageCageOutTask> outTaskWrapper = new LambdaQueryWrapper<>();
            outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS);
            List<BigStorageCageOutTask> bigStorageCageOutTaskList = bigStorageCageOutTaskMapper.selectList(outTaskWrapper);

            Map<String, BigStorageCageOutTask> listMap = bigStorageCageOutTaskList.stream()
                    .collect(Collectors.toMap(BigStorageCageOutTask::getGlassId, task -> task));
            for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList) {
                BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
            }
            Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
            while (iterator.hasNext()) {
                BigStorageCageDetails bigStorageCageDetails = iterator.next();
                BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
            }
            return bigStorageCageDetailsList;
        Map<String, BigStorageCageOutTask> listMap = bigStorageCageOutTaskList.stream()
                .collect(Collectors.toMap(BigStorageCageOutTask::getGlassId, task -> task));
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList) {
            BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
        }
        Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
        while (iterator.hasNext()) {
            BigStorageCageDetails bigStorageCageDetails = iterator.next();
            BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
        }
        return bigStorageCageDetailsList;
    }


    /**
     * 判断当前玻璃是否能上车
@@ -185,30 +188,34 @@
        TemperingGlassInfo temperingGlassInfo = temperingGlassInfoMapper.selectOne(temperingGlassInfoWrapper);

        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper = new LambdaQueryWrapper<>();
        bigStorageCageDetailsWrapper.eq(BigStorageCageDetails::getGlassId, glassId);
        bigStorageCageDetailsWrapper
                .eq(BigStorageCageDetails::getGlassId, glassId)
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
        BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(bigStorageCageDetailsWrapper);

        if (temperingGlassInfo != null) {
            if (status == 0) {
                temperingGlassInfo.setState(Const.TEMPERING_DAMAGE);
                temperingGlassInfo.setState(Const.GLASS_STATE_DAMAGE);
            } else {
                temperingGlassInfo.setState(Const.TEMPERING_TAKE);
                temperingGlassInfo.setState(Const.GLASS_STATE_TAKE);
            }
            temperingGlassInfoMapper.updateById(temperingGlassInfo);
        }
        Damage damage = new Damage();
        if (status == 0) {
            bigStorageCageDetails.setState(Const.GLASS_STATE_DAMAGE);
            damage.setType(Const.GLASS_STATE_DAMAGE);
        } else {
            bigStorageCageDetails.setState(Const.GLASS_STATE_TAKE);
            damage.setType(Const.GLASS_STATE_TAKE);
        }
        baseMapper.updateById(bigStorageCageDetails);
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
        //todo:插入破损数据
        Damage damage = new Damage();
        damage.setGlassId(bigStorageCageDetails.getGlassId());
        damage.setWorkingProcedure("冷加工");
        damage.setRemark("大理片笼破损");
        damage.setStatus(2);
        damage.setWorkingProcedure("钢化");
        damage.setLine(4001);
        damage.setRemark("大理片笼");
        damage.setStatus(1);
        damageService.insertDamage(damage);
    }

@@ -216,6 +223,7 @@
    @Override
    public List<BigStorageCageDetails> selectBigStorageCageDetails(String glassId) {
        LambdaQueryWrapper<GlassInfo> glassInfoWrapper = new LambdaQueryWrapper<>();
        List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
        glassInfoWrapper.eq(GlassInfo::getGlassId, glassId);
        GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoWrapper);
        BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
@@ -223,13 +231,10 @@
            BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
            bigStorageCageDetails.setState(1);
            bigStorageCageDetails.setGap(glassGap);
            List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
            bigStorageCageDetailsList = new ArrayList<>();
            bigStorageCageDetailsList.add(bigStorageCageDetails);
            return bigStorageCageDetailsList;
        } else {
            return null;
        }

        return bigStorageCageDetailsList;
    }

    //理片笼详情添加
@@ -267,16 +272,21 @@
                .selectAll(BigStorageCage.class)
                .leftJoin(BigStorageCageDetails.class, BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)
                .eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
                .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
                .last("limit 1");
        if (glassInfo.getTemperingLayoutId() == 0) {
            wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
            wrapper.eq(BigStorageCageDetails::getFlowCardId, glassInfo.getFlowCardId())
                    .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) {
            log.info("无钢化版图id或根据当前玻璃片序+1找到目标格子：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
@@ -285,12 +295,13 @@
        }
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
//                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .inSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where tempering_layout_id = " + glassInfo.getTemperingLayoutId())
                        "select distinct device_id from big_storage_cage_details where engineer_id = '" + glassInfo.getEngineerId() + "' and tempering_layout_id = " + glassInfo.getTemperingLayoutId())
                .last("limit 1"));
        if (null != bigStorageCage) {
            log.info("根据版图id找到笼子内的目标格子：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
@@ -298,35 +309,65 @@
            return bigStorageDTO;
        }

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .notInSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where state in (100,102,103)")
                .ge(BigStorageCage::getMaxThickness, glassInfo.getThickness())
                .orderByAsc(BigStorageCage::getDeviceId)
                .last("limit 1"));
        if (null != bigStorageCage) {
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
            bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
            return bigStorageDTO;
        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness());
        List<Integer> deviceUseds = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness());
        List<BigStorageCageDetails> engineerCount1 = baseMapper.selectList(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 1, 5)
        );
        List<BigStorageCageDetails> engineerCount2 = baseMapper.selectList(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 6, 8)
        );
        if (engineerCount1.size() > engineerCount2.size()) {
            deviceUsedList.removeIf(device -> device < 6);
        } else {
            deviceUsedList.removeIf(device -> device > 5);
        }
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .ge(BigStorageCage::getMaxThickness, glassInfo.getThickness())
                .orderByAsc(BigStorageCage::getDeviceId)
                .last("limit 1"));
        if (CollectionUtils.isEmpty(deviceUsedList)) {
            deviceUsedList = deviceUseds;
        }
        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                    .eq(BigStorageCage::getDeviceId, item)
                    .last("limit 1"));
            if (null != bigStorageCage) {
                log.info("按照存笼玻璃格子数占用最少方式获取信息格子为：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
                bigStorageDTO = new BigStorageDTO();
                bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
                bigStorageDTO.setSlot(bigStorageCage.getSlot());
                bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
                return bigStorageDTO;
            }
        }

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择
//        List<Integer> deviceNotUsedList = bigStorageCageService.queryFreeDeviceByNotUsed(glassInfo.getThickness());
//        for (Integer item : deviceNotUsedList) {
//            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
//                    .eq(BigStorageCage::getRemainWidth, slotWidth)
//                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
//                    .eq(BigStorageCage::getDeviceId, item)
//                    .last("limit 1"));
//            if (null != bigStorageCage) {
//                log.info("按照存笼玻璃格子数剩余最多得方式获取信息版图id:{},格子：{},玻璃id：{}", glassInfo.getTemperingLayoutId(), bigStorageCage.getSlot(), glassInfo.getGlassId());
//                bigStorageDTO = new BigStorageDTO();
//                bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
//                bigStorageDTO.setSlot(bigStorageCage.getSlot());
//                bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
//                return bigStorageDTO;
//            }
//        }
        Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃");
        bigStorageDTO = new BigStorageDTO();
        bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
        bigStorageDTO.setSlot(bigStorageCage.getSlot());
        bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
        return bigStorageDTO;
    }

@@ -347,7 +388,7 @@
    }

    @Override
    public boolean temperingGlass(String temperingLayoutId, String engineerId) {
    public boolean temperingGlass(String temperingLayoutId, String engineerId, String temperingFeedSequence) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
@@ -364,7 +405,13 @@
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                temperingGlassInfoService.saveBatch(temperingGlassInfos);
                if ("0".equals(temperingFeedSequence)) {
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, "");
                    }
                } else {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                }
                return true;
            }
        }
@@ -373,13 +420,8 @@


    @Override
    public List<Map<String, Object>> selectTemperingGlass() {
        QueryWrapper<BigStorageCageDetails> wrapper = new QueryWrapper<>();
        wrapper.select("engineer_id,tempering_layout_id,count(*) as count")
                .in("state", Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL)
                .groupBy("engineer_id,tempering_layout_id");
        List<Map<String, Object>> TemperingGlass = baseMapper.selectMaps(wrapper);
        return TemperingGlass;
    public List<TemperingGlassCountDTO> selectTemperingGlass(int isTempering) {
        return baseMapper.selectTemperingGlassCount(isTempering);
    }

    @Override
@@ -388,8 +430,70 @@
    }

    @Override
    public String dispatchSwitch(Boolean flag) {
        redisUtil.setCacheObject("dispatchSwitch", flag);
        return "success";
    }

    @Override
    public List<GlassInfoLackDTO> queryLackGlassInfo(BigStorageQueryVO bigStorageQueryVO) {
        return baseMapper.queryLackGlassInfo(bigStorageQueryVO);
    }

    @Override
    public String temperingSwitch(Boolean flag) {
        redisUtil.setCacheObject("temperingSwitch", flag);
        return "success";
    }

    @Override
    public boolean appointTemperingEngineerId(String engineerId) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        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)
                    .select("-1 as state")
                    .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .ne(GlassInfo::getTemperingLayoutId, 0)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderByAsc(GlassInfo::getTemperingLayoutId)
                    .orderByAsc(GlassInfo::getTemperingFeedSequence)
            );
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                temperingGlassInfoService.saveBatch(temperingGlassInfos);
                return true;
            }
        }
        return false;
    }

    @Override
    public List<BigStorageRelationDTO> queryIsAllNeedDispatchVirtualSlot() {
        return baseMapper.queryIsAllNeedDispatchVirtualSlot();
    }

    @Override
    public List<BigStorageSequenceDTO> dispatchBigStorageGlassInfo(BigStorageRelationDTO bigStorageRelationDTO) {
        return baseMapper.queryNeedDispatchSlot(bigStorageRelationDTO);
    }

    @Override
    public String bigStorageGlassDamageByGlassId(String glassId) {
        Damage damage = new Damage();
        damage.setGlassId(glassId);
        damage.setType(Const.GLASS_STATE_DAMAGE);
        damageService.insertDamage(damage);
        return "success";
    }

    @Override
    public void updateDeviceIdBySlot(List<Integer> slotList) {
        baseMapper.updateDeviceIdBySlot(slotList);
    }
}