义乌项目
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
zhoushihao
2025-03-29 d799fbde44cc568a3e15d78dc6e582ff244ffa89 
 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/impl/HollowGlassRelationInfoServiceImpl.java


@@ -10,6 +10,7 @@


import com.mes.glassinfo.service.GlassInfoService;


import com.mes.hollow.entity.HollowBigStorageCage;


import com.mes.hollow.entity.HollowBigStorageCageDetails;


import com.mes.hollow.entity.HollowGlassOutRelationInfo;


import com.mes.hollow.entity.HollowGlassRelationInfo;


import com.mes.hollow.entity.dto.FlowCardGlassInfoDTO;


import com.mes.hollow.entity.dto.HollowBigStorageDTO;


@@ -19,6 +20,7 @@


import com.mes.hollow.mapper.HollowGlassRelationInfoMapper;


import com.mes.hollow.service.HollowBigStorageCageDetailsService;


import com.mes.hollow.service.HollowBigStorageCageService;


import com.mes.hollow.service.HollowGlassOutRelationInfoService;


import com.mes.hollow.service.HollowGlassRelationInfoService;


import lombok.extern.slf4j.Slf4j;


import org.springframework.beans.BeanUtils;


@@ -26,10 +28,7 @@


import org.springframework.stereotype.Service;




import javax.annotation.Resource;


import java.util.ArrayList;


import java.util.HashMap;


import java.util.List;


import java.util.Map;


import java.util.*;


import java.util.stream.Collectors;




/**


@@ -48,6 +47,8 @@


    HollowBigStorageCageService hollowBigStorageCageService;


    @Resource


    HollowGlassRelationInfoService hollowGlassRelationInfoService;


    @Resource


    HollowGlassOutRelationInfoService hollowGlassOutRelationInfoService;


    @Resource


    HollowBigStorageCageDetailsService hollowBigStorageCageDetailsService;


    @Value("${mes.slotWidth}")


@@ -72,9 +73,18 @@


                .last("limit 1")


        );


        if (relationInfoOne == null) {


            //查看mes是否有对应的流程卡信息


            int count = hollowGlassRelationInfoService.count(new LambdaQueryWrapper<HollowGlassRelationInfo>()


                    .eq(HollowGlassRelationInfo::getFlowCardId, flowCardId)


                    .eq(HollowGlassRelationInfo::getLayer, layer));


            if (count == 0) {


                generateHollowGlassInfo(flowCardId, totalLayer, layer);


            } else {


                //比较关系表及中空理片笼详情表的流程卡数据，处理脏数据：将不在笼内的流程卡匹配数据职位空


                this.baseMapper.clearDirtyFlowCardData(flowCardId, layer);


            }


            //理片笼关系表中没有对应的数据，查看理片笼虚拟位置表是否有本工程下的所有玻璃虚拟信息


            //虚拟位置表没有本工程下的所有玻璃虚拟信息，按照玻璃id生成本工程下所有玻璃的虚拟信息


            generateHollowGlassInfo(flowCardId, totalLayer, layer);


            relationInfoOne = this.getOne(new LambdaQueryWrapper<HollowGlassRelationInfo>()


                    .eq(HollowGlassRelationInfo::getFlowCardId, flowCardId)


                    .eq(HollowGlassRelationInfo::getWidth, width)


@@ -87,13 +97,27 @@


            );


        }


        //详情表内获取本组是否已经有玻璃在笼子内（0表示提前占用）


        int taskCount = hollowGlassOutRelationInfoService.count(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()


                .eq(HollowGlassOutRelationInfo::getFlowCardId, flowCardId));


        HollowBigStorageCage storageCage = null;


        //如果不存在则选择笼内未用的新格子


        if (taskCount > 0) {


            storageCage = hollowBigStorageCageService.getOne(new LambdaQueryWrapper<HollowBigStorageCage>()


                    .eq(HollowBigStorageCage::getEnableState, Const.SLOT_ON).eq(HollowBigStorageCage::getRemainWidth, slotWidth)


                    .le(HollowBigStorageCage::getMinThickness, relationInfoOne.getThickness())


                    .ge(HollowBigStorageCage::getMaxThickness, relationInfoOne.getThickness())


                    .orderByAsc(HollowBigStorageCage::getMaxThickness).last("limit 1"));


            HollowBigStorageDTO storageDTO = new HollowBigStorageDTO();


            BeanUtils.copyProperties(storageCage, storageDTO);


            BeanUtils.copyProperties(relationInfoOne, storageDTO);


            return storageDTO;


        }       //详情表内获取本组是否已经有玻璃在笼子内（0表示提前占用）


        List<HollowBigStorageCageDetails> hollowDetailsList = hollowBigStorageCageDetailsService.list(new LambdaQueryWrapper<HollowBigStorageCageDetails>()


                .eq(HollowBigStorageCageDetails::getFlowCardId, relationInfoOne.getFlowCardId())


                .eq(HollowBigStorageCageDetails::getTotalLayer, totalLayer)


                .eq(HollowBigStorageCageDetails::getLayer, layer)


                .eq(HollowBigStorageCageDetails::getVirtualSlot, relationInfoOne.getVirtualSlot())


                .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO));


        HollowBigStorageCage storageCage = null;


        //如果不存在则选择笼内未用的新格子


        if (CollectionUtil.isEmpty(hollowDetailsList)) {


            storageCage = hollowBigStorageCageService.getOne(new LambdaQueryWrapper<HollowBigStorageCage>()


@@ -165,7 +189,7 @@


    public void generateHollowGlassInfo(String flowCardId, int totalLayer, int layer) {




        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getFlowCardId, flowCardId)


                .eq(GlassInfo::getLayer, layer).last("limit 1"));


                .eq(GlassInfo::getLayer, layer).orderByDesc(GlassInfo::getId).last("limit 1"));


        if (null == glassInfo) {


            log.info("当前流程卡信息为导入mes系统流程卡：{}，层数{}", flowCardId, layer);


            return;


@@ -278,7 +302,13 @@


        List<FlowCardGlassInfoDTO> dtos = new ArrayList<>();


        listMap.forEach((e, v) -> {


            HollowBigStorageCageDetails cageDetails = v.get(0);


            dtos.addAll(hollowBigStorageCageDetailsService.hollowIsAll(e, cageDetails.getTotalLayer(), Boolean.FALSE));


            //按照流程卡获取对应的产品名称


            String productName = baseMapper.queryProductNameByFlowCardId(cageDetails.getFlowCardId());


            List<FlowCardGlassInfoDTO> flowCardInfoList = hollowBigStorageCageDetailsService.hollowIsAll(e, cageDetails.getTotalLayer(), Boolean.FALSE);


            for (FlowCardGlassInfoDTO item : flowCardInfoList) {


                item.setProductName(productName);


                dtos.add(item);


            }


        });


        Map<String, FlowCardGlassInfoDTO> result = dtos.stream()


                .collect(Collectors.toMap(


@@ -294,15 +324,15 @@


                        },


                        (dto1, dto2) -> {


                            dto1.setRealCount(dto1.getRealCount() + dto2.getRealCount()); // 累加 realCount


                            dto1.setLayer(Math.max(dto1.getLayer(),dto2.getLayer())); // 累加 最大层数


                            dto1.setLayer(Math.max(dto1.getLayer(), dto2.getLayer())); // 累加 最大层数


                            return dto1; // 返回合并后的对象


                        }


                ));


        return dtos.stream().collect(Collectors.groupingBy(FlowCardGlassInfoDTO::getFlowCardId));


        return dtos.stream().collect(Collectors.groupingBy(e -> e.getFlowCardId() + ":" + e.getProductName()));


    }




    @Override


    public Map<String, FlowCardGlassInfoDTO> queryHollowAllFlowCardSummary(HollowBigStorageDetailsQueryVO query) {


    public List<FlowCardGlassInfoDTO> queryHollowAllFlowCardSummary(HollowBigStorageDetailsQueryVO query) {


        List<HollowBigStorageCageDetails> detailsList = hollowBigStorageCageDetailsService.list(new LambdaQueryWrapper<HollowBigStorageCageDetails>()


                .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)


                .like(StringUtils.isNotBlank(query.getFilmsId()), HollowBigStorageCageDetails::getFilmsId, query.getFilmsId())


@@ -312,7 +342,7 @@


        );


        if (CollectionUtil.isEmpty(detailsList)) {


            log.info("笼内无玻璃");


            return new HashMap<>();


            return null;


        }


        Map<String, List<HollowBigStorageCageDetails>> listMap = detailsList.stream().collect(Collectors.groupingBy(HollowBigStorageCageDetails::getFlowCardId));


        List<FlowCardGlassInfoDTO> dtos = new ArrayList<>();


@@ -335,12 +365,17 @@


                        },


                        (dto1, dto2) -> {


                            dto1.setRealCount(dto1.getRealCount() + dto2.getRealCount()); // 累加 realCount


                            dto1.setLayer(Math.max(dto1.getLayer(),dto2.getLayer())); // 累加 最大层数


                            dto1.setLayer(Math.max(dto1.getLayer(), dto2.getLayer())); // 累加 最大层数


                            dto1.setSlotCount(dto1.getSlotCount() + dto2.getSlotCount());


                            return dto1; // 返回合并后的对象


                        }


                ));


        return result;


        List<FlowCardGlassInfoDTO> resultList = new ArrayList<>(result.values());


        List<FlowCardGlassInfoDTO> sortedList = resultList.stream()


                .sorted(Comparator.comparing(FlowCardGlassInfoDTO::getRealCount).reversed()  // 第一个字段倒序


                        .thenComparing(FlowCardGlassInfoDTO::getSumCount, Comparator.reverseOrder()))  // 第二个字段倒序


                .collect(Collectors.toList());


        return sortedList;


    }




    @Override