Merge remote-tracking branch 'origin/master'

zhoushihao

2025-05-26 88cbf1a8c50a15f35dd78a50adc43e71a6530775

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

@@ -2,37 +2,41 @@

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.google.common.collect.Lists;
import com.mes.base.entity.vo.BigStorageVO;
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;
import com.mes.bigstoragecagetask.entity.BigStorageCageHistoryTask;
import com.mes.bigstoragecagetask.service.BigStorageCageHistoryTaskService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
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.common.config.ConstSysConfig;
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.sysconfig.entity.SysConfig;
import com.mes.sysconfig.service.SysConfigService;
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;

import javax.annotation.Resource;
@@ -70,23 +74,29 @@

    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;
    @Resource
    private SysConfigService sysConfigService;


    @Resource
    private DamageService damageService;
    @Resource
    private RedisUtil redisUtil;

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

    @Value("${mes.slotWidth}")
    private Integer slotWidth;

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

    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;
    @Resource
    BigStorageCageHistoryTaskService bigStorageCageHistoryTaskService;
//
//    @Value("${mes.minCount}")
//    private int minCount;
//
//    @Value("${mes.slotWidth}")
//    private Integer slotWidth;
//
//    @Value("${mes.glassGap}")
//    private Integer glassGap;
//
//    @Value("${mes.sequence.order}")
//    private boolean sequenceOrder;


    @Override
@@ -162,7 +172,7 @@
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
        ) {
            if (bigStorageCageDetails.getBigStorageCageFeedTask().getTaskState() == 0) {
                carWidth = carWidth - bigStorageCageDetails.getWidth() - glassGap;
                carWidth = carWidth - bigStorageCageDetails.getWidth() - 250;
            }
        }
        return carWidth;
@@ -188,7 +198,7 @@
        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper = new LambdaQueryWrapper<>();
        bigStorageCageDetailsWrapper
                .eq(BigStorageCageDetails::getGlassId, glassId)
                .eq(BigStorageCageDetails::getState,Const.GLASS_STATE_IN);
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
        BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(bigStorageCageDetailsWrapper);

        if (temperingGlassInfo != null) {
@@ -221,14 +231,14 @@
    @Override
    public List<BigStorageCageDetails> selectBigStorageCageDetails(String glassId) {
        LambdaQueryWrapper<GlassInfo> glassInfoWrapper = new LambdaQueryWrapper<>();
        List<BigStorageCageDetails> bigStorageCageDetailsList=new ArrayList<>();
        List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
        glassInfoWrapper.eq(GlassInfo::getGlassId, glassId);
        GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoWrapper);
        BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
        if (glassInfo != null) {
            BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
            bigStorageCageDetails.setState(1);
            bigStorageCageDetails.setGap(glassGap);
            bigStorageCageDetails.setGap(250);
            bigStorageCageDetailsList = new ArrayList<>();
            bigStorageCageDetailsList.add(bigStorageCageDetails);
        }
@@ -266,6 +276,7 @@
    @Override
    public BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) {
        BigStorageDTO bigStorageDTO = null;
        int slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
        MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>(BigStorageCage.class)
                .selectAll(BigStorageCage.class)
                .leftJoin(BigStorageCageDetails.class, BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
@@ -276,11 +287,11 @@
                .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
                .last("limit 1");
        if (glassInfo.getTemperingLayoutId() == 0) {
            wrapper.eq(BigStorageCageDetails::getFlowCardId,glassInfo.getFlowCardId())
                    .eq(BigStorageCageDetails::getLayer,glassInfo.getLayer());
            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) {
@@ -293,7 +304,7 @@
        }
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .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 engineer_id = '" + glassInfo.getEngineerId() + "' and tempering_layout_id = " + glassInfo.getTemperingLayoutId())
@@ -309,9 +320,32 @@

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主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);
        }
        if (CollectionUtils.isEmpty(deviceUsedList)) {
            deviceUsedList = deviceUseds;
        }
        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth)
                    .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                    .eq(BigStorageCage::getDeviceId, item)
                    .last("limit 1"));
@@ -354,7 +388,7 @@

    @Override
    public List<TemperingLayoutDTO> queryTemperingOccupySlot() {
        return baseMapper.queryTemperingOccupySlot(minCount);
        return baseMapper.queryTemperingOccupySlot(10);
    }

    @Override
@@ -363,24 +397,42 @@
    }

    @Override
    public boolean temperingGlass(String temperingLayoutId, String engineerId) {
    public boolean temperingGlass(String temperingLayoutId, String engineerId, String temperingFeedSequence) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        SysConfig sysConfig = sysConfigService.queryConfigById(ConstSysConfig.CACHE_SEQUENCE_ORDER_TRUE);
        boolean sequenceOrder = Boolean.parseBoolean(sysConfig.getConfigValue());
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        int dispatchCount = bigStorageCageHistoryTaskService.count(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_DISPATCH));

        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)
            MPJLambdaWrapper<GlassInfo> wrapper = JoinWrappers.lambda(GlassInfo.class)
                    .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                            ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                            "t.angle,t1.slot,t.engineer_id")
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getTemperingLayoutId, temperingLayoutId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));

                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence);
            if (dispatchCount > 0) {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL);
            } else {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            }
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, wrapper);
            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;
            }
        }
@@ -389,14 +441,62 @@


    @Override
    public List<Map<String, Object>> selectTemperingGlass() {
        List<Map<String, Object>> temperingGlass = baseMapper.selectTemperingGlassCount();
        return temperingGlass;
    public List<TemperingGlassCountDTO> selectTemperingGlass(int isTempering) {
        return baseMapper.selectTemperingGlassCount(isTempering);
    }

    @Override
    public void updateBySlot(List<UpdateBigStorageCageDTO> glassList, int state) {
        baseMapper.updateBySlot(glassList, state);
    }

    @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 List<BigStorageCageDetails> queryRealGlassInfo(BigStorageQueryVO bigStorageQueryVO) {
        return this.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getEngineerId, bigStorageQueryVO.getEngineerId())
                .eq(BigStorageCageDetails::getTemperingLayoutId, bigStorageQueryVO.getTemperingLayoutId())
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).orderByAsc(BigStorageCageDetails::getTemperingFeedSequence));
    }

    @Override
    public Map<Integer, List<BigStorageVO>> querybigStorageCageDetail() {
        List<BigStorageVO> bigStorageCages = baseMapper.querybigStorageCageDetail();
        return bigStorageCages.stream().collect(Collectors.groupingBy(item -> item.getDeviceId()));
    }

    @Override
    public boolean cancelTemperingTask() {
        //当前正在执行的出片任务
        List<BigStorageCageHistoryTask> historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTargetSlot, Const.TEMPERING_OUT_TARGET_POSITION));
        //不存在出片任务，直接删除钢化小片表未出片的任务
        if (CollectionUtils.isEmpty(historyTaskList)) {
            temperingGlassInfoMapper.delete(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW));
            return Boolean.TRUE;
        }
        //存在出片任务，删除钢化小片表
        List<String> glassIdList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList());
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList)
                .orderByDesc(GlassInfo::getTemperingFeedSequence).last("limit 1"));
        temperingGlassInfoMapper.delete(new LambdaQueryWrapper<TemperingGlassInfo>()
                .eq(TemperingGlassInfo::getEngineerId, glassInfo.getEngineerId())
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .ge(TemperingGlassInfo::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .gt(TemperingGlassInfo::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence())
        );
        return Boolean.TRUE;
    }

    @Override
@@ -406,7 +506,66 @@
    }

    @Override
    public void appointEngineerId(String engineerId){
        redisUtil.setCacheObject("temperingengineerId", engineerId);
    public boolean appointTemperingEngineerId(String engineerId) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        int dispatchCount = bigStorageCageHistoryTaskService.count(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_DISPATCH));

        if (temperingGlassInfoList.size() == 0) {
            MPJLambdaWrapper<GlassInfo> wrapper = JoinWrappers.lambda(GlassInfo.class)
                    .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                            ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                            "t.angle,t1.slot,t.engineer_id")
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .ne(GlassInfo::getTemperingLayoutId, 0)
                    .orderByAsc(BigStorageCageDetails::getTemperingLayoutId)
                    .orderByAsc(BigStorageCageDetails::getTemperingFeedSequence);
            if (dispatchCount > 0) {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL);
            } else {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            }
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, wrapper);

            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                //避免大量数据插入导致sqlserver数据库异常，分批次每调存储依次
                List<List<TemperingGlassInfo>> temperingGlassInfoLists = Lists.partition(temperingGlassInfos, 50);
                for (List<TemperingGlassInfo> item : temperingGlassInfoLists) {
                    temperingGlassInfoService.saveBatch(item);
                }
                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);
    }
}