义乌项目
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
zhoushihao
1 天以前 b7bbb981103d865be75a16b95d188326015b8aa6 
 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/impl/HollowGlassRelationInfoServiceImpl.java


@@ -6,30 +6,34 @@


import com.baomidou.mybatisplus.core.toolkit.StringUtils;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.mes.common.config.Const;


import com.mes.common.config.ConstSysConfig;


import com.mes.glassinfo.entity.GlassInfo;


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;


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


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


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


import com.mes.hollow.entity.vo.HollowAllFlowCardVO;


import com.mes.hollow.entity.vo.HollowBigStorageDetailsQueryVO;


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 com.mes.sysconfig.service.SysConfigService;


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;


import java.math.BigInteger;


import java.util.ArrayList;


import java.util.HashMap;


import java.util.Comparator;


import java.util.List;


import java.util.Map;


import java.util.regex.Matcher;


import java.util.regex.Pattern;


import java.util.stream.Collectors;




/**


@@ -49,14 +53,18 @@


    @Resource


    HollowGlassRelationInfoService hollowGlassRelationInfoService;


    @Resource


    HollowGlassOutRelationInfoService hollowGlassOutRelationInfoService;


    @Resource


    HollowBigStorageCageDetailsService hollowBigStorageCageDetailsService;


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


    private Integer slotWidth;


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


    private Integer glassGap;




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


    private Integer outCarMaxSize;


    @Resource


    SysConfigService sysConfigService;


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


//    private Integer slotWidth;


//    @Value("${mes.glassGap}")


//    private Integer glassGap;


//


//    @Value("${mes.outCarMaxSize}")


//    private Integer outCarMaxSize;




    @Override


    public HollowBigStorageDTO queryHollowTargetSlot(String flowCardId, double width, double height, int totalLayer, int layer) {


@@ -72,9 +80,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)


@@ -86,14 +103,29 @@


                    .last("limit 1")


            );


        }


        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);


        //详情表内获取本组是否已经有玻璃在笼子内（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 +197,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;


@@ -216,6 +248,11 @@


//        List<HollowBigStorageCage> hollowSlotList = HollowBigStorageCageService.list(new LambdaQueryWrapper<HollowBigStorageCage>()


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


        //方式二：将玻璃按流程卡、尺寸、版图、版序 ，优先将格子全部补全后 依次计算后面的格子号




        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);


//        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);


        Integer glassGap = getGlassGapByThickness(tempGlassList.get(0).getThickness());


        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_OUT_CAR_SIZE);


        List<HollowGlassRelationInfo> relationInfoList = new ArrayList();


        List<List<HollowGlassRelationInfo>> tempHollowList = new ArrayList<>();


        int slotNumber = 1;


@@ -262,7 +299,7 @@


    }




    @Override


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


    public List<HollowAllFlowCardVO> queryHollowAllFlowCard(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())


@@ -272,7 +309,44 @@


        );


        if (CollectionUtil.isEmpty(detailsList)) {


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


            return new HashMap<>();


            return new ArrayList<>();


        }


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


        List<HollowAllFlowCardVO> resultList = new ArrayList<>();


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


            HollowAllFlowCardVO hollowAllFlowCardVO = new HollowAllFlowCardVO();


            HollowBigStorageCageDetails cageDetails = v.get(0);


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


            OrderDetailsDTO orderDetails = baseMapper.queryProductNameByFlowCardId(cageDetails.getFlowCardId());


            if (null != orderDetails) {


                BeanUtils.copyProperties(orderDetails, hollowAllFlowCardVO);


            }


            hollowAllFlowCardVO.setFlowCardId(e);


            if (cageDetails.getHollowSequence() == 0) {


                hollowAllFlowCardVO.setIsThroughSlot(Boolean.TRUE);


            } else {


                hollowAllFlowCardVO.setIsThroughSlot(Boolean.FALSE);


            }


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


            hollowAllFlowCardVO.setFlowCardGlassInfoDTOList(flowCardInfoList);


            resultList.add(hollowAllFlowCardVO);


        });


        sortFlowCardIdList(resultList);


        return resultList;


    }




    @Override


    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())


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


                .eq(query.getThickness() != 0, HollowBigStorageCageDetails::getThickness, query.getThickness())


                .orderByAsc(HollowBigStorageCageDetails::getFlowCardId)


        );


        if (CollectionUtil.isEmpty(detailsList)) {


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


            return null;


        }


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


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


@@ -280,7 +354,32 @@


            HollowBigStorageCageDetails cageDetails = v.get(0);


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


        });


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


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


                .collect(Collectors.toMap(


                        FlowCardGlassInfoDTO::getFlowCardId,


                        dto -> {


                            FlowCardGlassInfoDTO newDto = new FlowCardGlassInfoDTO();


                            newDto.setFlowCardId(dto.getFlowCardId());


                            newDto.setSumCount(dto.getSumCount());


                            newDto.setPairCount(dto.getPairCount());


                            newDto.setRealCount(dto.getRealCount());


                            newDto.setLayer(dto.getLayer());


                            newDto.setSlotCount(dto.getSlotCount());


                            return newDto;


                        },


                        (dto1, dto2) -> {


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


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


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


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


                        }


                ));


        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


@@ -294,11 +393,54 @@


    public int queryLayerByFlowCardId(String flowCardId) {


        return baseMapper.queryLayerByFlowCardId(flowCardId);


    }




    @Override


    public Integer getGlassGapByThickness(Double thickness) {


        int sysKey = 0;


        if (thickness >= 12) {


            sysKey = ConstSysConfig.HOLLOW_GLASS_GAP_12;


        } else if (thickness == 8) {


            sysKey = ConstSysConfig.HOLLOW_GLASS_GAP_8;


        } else if (thickness == 10) {


            sysKey = ConstSysConfig.HOLLOW_GLASS_GAP_10;


        } else {


            sysKey = ConstSysConfig.HOLLOW_GLASS_GAP;


        }


        return sysConfigService.queryConfigValue(sysKey);


    }


    //    @Override


//    public List<LackDetailsDTO> queryLackByFlowCard(String flowCardId) {


//        List<LackDetailsDTO> lackDetailsList = this.baseMapper.queryLackByFlowCard(flowCardId);


//        return lackDetailsList;


//    }




    private void sortFlowCardIdList(List<HollowAllFlowCardVO> list) {


        Pattern pattern = Pattern.compile("^NG(\\d+)([A-Za-z]+)(\\d+)$");




        list.sort((v1, v2) -> {


            Matcher m1 = pattern.matcher(v1.getFlowCardId());


            Matcher m2 = pattern.matcher(v2.getFlowCardId());




            if (!m1.find() || !m2.find()) {


                throw new IllegalArgumentException("获取到的流程卡不符合校验规则");


            }




            // 提取部分


            BigInteger order1 = new BigInteger(m1.group(1));


            BigInteger order2 = new BigInteger(m2.group(1));


            String layer1 = m1.group(2);


            String layer2 = m2.group(2);


            BigInteger seq1 = new BigInteger(m1.group(3));


            BigInteger seq2 = new BigInteger(m2.group(3));




            // 优先级排序


            int cmp = order1.compareTo(order2);


            if (cmp != 0) return cmp;


            cmp = layer1.compareTo(layer2);


            if (cmp != 0) return cmp;


            return seq1.compareTo(seq2);


        });


    }




}