1、代码补充提交

ZengTao

2025-09-11 924ce82faeec6d896fcdc360b279215e84b69fb9

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

@@ -11,6 +11,7 @@
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.FlowCardDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
@@ -25,6 +26,8 @@
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.mapper.EngineeringMapper;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.glassinfo.service.GlassInfoService;
@@ -82,6 +85,8 @@
    private BigStorageCageOutTaskService bigStorageCageOutTaskService;
    @Resource
    private BigStorageCageDetailsService bigStorageCageDetailsService;
    @Resource
    private EngineeringMapper engineeringMapper;

    @Value("${mes.minCount}")
    private int minCount;
@@ -108,6 +113,13 @@
                .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                .isNotNull(BigStorageCageFeedTask::getTargetSlot);
        List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(feedTaskWrapper);

        List<String> glassIds = bigStorageCageDetailsList.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
        List<BigStorageCageFeedTask> feedTasks = bigStorageCageFeedTaskList.stream()
                .filter(task -> !glassIds.contains(task.getGlassId()))
                .collect(Collectors.toList());


        Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
        Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
@@ -116,6 +128,14 @@
            BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
        }
        for (BigStorageCageFeedTask bigStorageCageFeedTask : feedTasks
        ) {
            BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
            bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
            bigStorageCageDetailsList.add(bigStorageCageDetails);
        }
        bigStorageCageDetailsList.sort(Comparator
                .comparing((BigStorageCageDetails detail) -> detail.getBigStorageCageFeedTask().getId()));
        return bigStorageCageDetailsList;
    }

@@ -125,7 +145,8 @@
        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);
        outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
                .orderByAsc(BigStorageCageOutTask::getId);
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = bigStorageCageOutTaskMapper.selectList(outTaskWrapper);

        Map<String, BigStorageCageOutTask> listMap = bigStorageCageOutTaskList.stream()
@@ -140,6 +161,10 @@
            BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
        }
        bigStorageCageDetailsList.sort(Comparator
                .comparing((BigStorageCageDetails detail) -> detail.getBigStorageCageOutTask().getTrainNumber())
                .thenComparingInt((BigStorageCageDetails detail) -> detail.getBigStorageCageOutTask().getSerialNumber()));

        return bigStorageCageDetailsList;
    }

@@ -199,22 +224,23 @@
        BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(bigStorageCageDetailsWrapper);

        if (temperingGlassInfo != null) {
            if (status == 0) {
            if (status == 8) {
                temperingGlassInfo.setState(Const.GLASS_STATE_DAMAGE);
            } else {
                temperingGlassInfo.setState(Const.GLASS_STATE_TAKE);
            }
            temperingGlassInfoMapper.updateById(temperingGlassInfo);
            temperingGlassInfoMapper.deleteById(temperingGlassInfo);
        }
        Damage damage = new Damage();
        if (status == 0) {
            bigStorageCageDetails.setState(Const.GLASS_STATE_DAMAGE);
        if (status == 8) {
//            bigStorageCageDetails.setState(Const.GLASS_STATE_DAMAGE);
            damage.setType(Const.GLASS_STATE_DAMAGE);
        } else {
            bigStorageCageDetails.setState(Const.GLASS_STATE_TAKE);
//            bigStorageCageDetails.setState(Const.GLASS_STATE_TAKE);
            damage.setType(Const.GLASS_STATE_TAKE);
        }
        baseMapper.updateById(bigStorageCageDetails);
//        baseMapper.updateById(bigStorageCageDetails);
        baseMapper.deleteById(bigStorageCageDetails);
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
        damage.setGlassId(bigStorageCageDetails.getGlassId());
        damage.setWorkingProcedure("钢化");
@@ -288,6 +314,7 @@
                .eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
                .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
                .gt(BigStorageCage::getSlotHeight, Math.min(glassInfo.getWidth(), glassInfo.getHeight()))
                .in(BigStorageCageDetails::getGlassId, glassIds)
                .last("limit 1");
        if (glassInfo.getTemperingLayoutId() == 0) {
@@ -309,9 +336,10 @@
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .lt(BigStorageCage::getSlotHeight, Math.min(glassInfo.getWidth(), glassInfo.getHeight()))
//                .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())
                        "select distinct device_id from big_storage_cage_details where state!=101 and engineer_id = '" + glassInfo.getEngineerId() + "' and tempering_layout_id = " + glassInfo.getTemperingLayoutId())
                .last("limit 1"));
        if (null != bigStorageCage) {
            log.info("根据版图id找到笼子内的目标格子：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
@@ -323,8 +351,8 @@
        }

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness());
        List<Integer> deviceUseds = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness());
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness(), Math.min(glassInfo.getWidth(), glassInfo.getHeight()));
        List<Integer> deviceUseds = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness(), Math.min(glassInfo.getWidth(), glassInfo.getHeight()));
        List<BigStorageCageDetails> engineerCount1 = baseMapper.selectList(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
@@ -366,6 +394,7 @@
        if (CollectionUtils.isEmpty(deviceUsedList)) {
            deviceUsedList = deviceUseds;
        }

        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth)
@@ -421,32 +450,40 @@

    @Override
    public boolean temperingGlass(String temperingLayoutId, String engineerId, String temperingFeedSequence) {
        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::getTemperingLayoutId, temperingLayoutId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                if ("0".equals(temperingFeedSequence)) {
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, 1);
        Engineering engineering = engineeringMapper.selectOne(
                new LambdaQueryWrapper<Engineering>()
                        .eq(Engineering::getEngineerId, engineerId)
        );
        if(engineering.getState()!=2){
            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::getTemperingLayoutId, temperingLayoutId)
                        .eq(GlassInfo::getEngineerId, engineerId)
                        .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                    if ("0".equals(temperingFeedSequence)) {
                        if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                            plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, 1);
                        }
                    } else {
                        temperingGlassInfoService.saveBatch(temperingGlassInfos);
                    }
                } else {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                    return true;
                }
                return true;
            }
            return false;
        }else{
            return false;
        }
        return false;
    }


@@ -468,8 +505,22 @@
    }

    @Override
    public void appointEngineerId(String engineerId) {
        redisUtil.setCacheObject("temperingengineerId", engineerId);
    public String appointEngineerId(String engineerId) {
        if(engineerId!=""){
            Engineering engineering = engineeringMapper.selectOne(
                    new LambdaQueryWrapper<Engineering>()
                            .eq(Engineering::getEngineerId, engineerId)
            );
            if (engineering.getState() != 2) {
                redisUtil.setCacheObject("temperingengineerId", engineerId);
                return "指定成功";
            } else {
                return "指定失败，此工程已经被禁止生产";
            }
        }else{
            redisUtil.setCacheObject("temperingengineerId", engineerId);
            return "指定成功";
        }
    }

    @Override
@@ -524,7 +575,35 @@
        }
        long startSlotCount = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getStartSlot).distinct().count();
        long endSlotCount = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getEndSlot).distinct().count();
        long time = (startSlotCount * 10 + endSlotCount * 20) / 60;
        long time = (startSlotCount * 30 + endSlotCount * 20) / 60;
        return time;
    }

    @Override
    public void cancelOutTask() {
        List<BigStorageCageOutTask> bigStorageCageOutTasks = bigStorageCageOutTaskService.list(
                new LambdaQueryWrapper<BigStorageCageOutTask>()
                        .in(BigStorageCageOutTask::getEndSlot, Const.OUT_TARGET_POSITION_ALL)
                        .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW)
        );
        if (bigStorageCageOutTasks.size() > 0) {
            List<String> outGlassId = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
            temperingGlassInfoService.remove(
                    new LambdaUpdateWrapper<TemperingGlassInfo>()
                            .in(TemperingGlassInfo::getGlassId, outGlassId)
            );
            bigStorageCageDetailsService.update(
                    new LambdaUpdateWrapper<BigStorageCageDetails>()
                            .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                            .in(BigStorageCageDetails::getGlassId, outGlassId)
            );
            bigStorageCageOutTaskService.deleteTask(bigStorageCageOutTasks);
        }
    }

    @Override
    public List<FlowCardDTO> selectFlowCardCount() {
        return baseMapper.selectFlowCardCount();
    }
}