webservice标准接口增加

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/UniversalInterfaceImpl.java

@@ -1990,88 +1990,93 @@
            String finalSystemId = systemId;
            String libray="";
            boolean isCodeOrGroupCode=false;
            try {
                libray = classfyBZVO.getLibrary();
                CodeClassifyVO codeClassifyVO = getClassfy(classfyBZVO,libray);
                log.info("end：分类查询完毕");
                //获取分类模板信息
                if(codeClassifyVO==null || StringUtils.isBlank(codeClassifyVO.getOid())){
                    objerrorCode="100";
                    throw  new  Throwable ("根据传输的分类，未获取到分类信息");

            libray = classfyBZVO.getLibrary();
            CodeClassifyVO codeClassifyVO = getClassfy(classfyBZVO,libray);
            log.info("end：分类查询完毕");
            //获取分类模板信息
            if(codeClassifyVO==null || StringUtils.isBlank(codeClassifyVO.getOid())){
                objerrorCode="100";
                throw  new  Throwable ("根据传输的分类，未获取到分类信息");
            }
            String operation="";
            if(CODE_CHECKCONFIG) {
                //校验是否配置
                DockingSystemConfig dockingSystemConfig=null;
                dockingSystemConfig=checkIspass(finalSystemId, SysIntegrationDataFlowTypeEnum.ACCEPT.getValue(), sysIntegrationPushTypeEnum.ACCPET_APPCODE.getValue(),codeClassifyVO.getOid());
                if(dockingSystemConfig==null){
                    errorid[0] ="101";
                    throw new Throwable("系统标识为【"+ finalSystemId +"】，集成分类为【"+codeClassifyVO.getName()+"】以上分类，"+sysIntegrationPushTypeEnum.ACCPET_APPCODE.getText()+"接口配置已停用或者未配置，请联系编码管理员！");
                }
                String operation="";
                if(CODE_CHECKCONFIG) {
                    //校验是否配置
                    DockingSystemConfig dockingSystemConfig=null;
                    dockingSystemConfig=checkIspass(finalSystemId, SysIntegrationDataFlowTypeEnum.ACCEPT.getValue(), sysIntegrationPushTypeEnum.ACCPET_APPCODE.getValue(),codeClassifyVO.getOid());
                    if(dockingSystemConfig==null){
                        errorid[0] ="101";
                        throw new Throwable("系统标识为【"+ finalSystemId +"】，集成分类为【"+codeClassifyVO.getName()+"】以上分类，"+sysIntegrationPushTypeEnum.ACCPET_APPCODE.getText()+"接口配置已停用或者未配置，请联系编码管理员！");
                    }
                    isCodeOrGroupCode="true".equals(dockingSystemConfig.getIsGroupCodeFlag())?true:false;
                }
                CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
                if(templateVO==null||StringUtils.isBlank(templateVO.getOid())){
                    objerrorCode="1";
                    throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应模板");
                }
                log.info("end：模板查询完毕");
                ApplyBZDatasVO applyDatasVO = classfyBZVO.getObjects();
                isCodeOrGroupCode="true".equals(dockingSystemConfig.getIsGroupCodeFlag())?true:false;
            }
            CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
            if(templateVO==null||StringUtils.isBlank(templateVO.getOid())){
                objerrorCode="1";
                throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应模板");
            }
            log.info("end：模板查询完毕");
            ApplyBZDatasVO applyBZDatasVO = classfyBZVO.getObjects();
                DataObjectVO dataObjectVO = new DataObjectVO();
                List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
                ).collect(Collectors.toList());
                //this.getConfigDatas(finalSystemId, libray, applyDatasVO, attrVOS, dataObjectVO);
                log.info("end：数据组织完毕");
                //规则的主键需要去获取
                CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
                if(classifyFullInfo==null ||classifyFullInfo.getCurrentClassifyVO()==null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())){
                    objerrorCode="1";
                    log.info("classifyFullInfo:"+"根据传输的分类，未获取分类相关信息");
                    throw  new  Throwable ("根据传输的分类，未获取分类相关信息");
                }
                CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
                if(ruleVO==null||StringUtils.isBlank(ruleVO.getOid())){
                    objerrorCode="102";
                    throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应规则");
                }
                log.info("end：规则获取完毕");
                //List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(ruleVO,classifyFullInfo);
                log.info("end：码段获取完毕");
                CodeOrderDTO orderDTO = new CodeOrderDTO();
                orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
                //orderDTO.setSecDTOList(codeOrderSecDTOList);//分类码段
                mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs,isCodeOrGroupCode);
                //allResultDataObjectDetailDOS.add(resultDataObjectDetailDOs);
                log.info("end：申请获取完毕");
            } catch (Throwable e) {
                List<ApplyBZDataVO> applyDataVOList = classfyBZVO.getObjects().getObject();
                objerrorCode = "1";
                if (!CollectionUtils.isEmpty(applyDataVOList)) {
                    applyDataVOList.stream().forEach(applyDataVO -> {
            List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
            ).collect(Collectors.toList());
            List<ApplyBZDataVO> applyBZDataVOList=    applyBZDatasVO.getObject();
            String finalLibray = libray;
            ClassfyBZVO finalClassfyBZVO = classfyBZVO;
            applyBZDataVOList.stream().forEach(applyBZDataVO -> {
                try {
                    this.getConfigDatas(finalSystemId, finalLibray, applyBZDatasVO, attrVOS, dataObjectVO);
                    log.info("end：数据组织完毕");
                    //规则的主键需要去获取
                    CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
                    if(classifyFullInfo==null ||classifyFullInfo.getCurrentClassifyVO()==null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())){
                        objerrorCode="1";
                        log.info("classifyFullInfo:"+"根据传输的分类，未获取分类相关信息");
                        throw  new  Throwable ("根据传输的分类，未获取分类相关信息");
                    }
                    CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
                    if(ruleVO==null||StringUtils.isBlank(ruleVO.getOid())){
                        objerrorCode="102";
                        throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应规则");
                    }
                    log.info("end：规则获取完毕");
                    //List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(ruleVO,classifyFullInfo);
                    log.info("end：码段获取完毕");
                    CodeOrderDTO orderDTO = new CodeOrderDTO();
                    orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
                    //orderDTO.setSecDTOList(codeOrderSecDTOList);//分类码段
                    //mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs,isCodeOrGroupCode);
                    //allResultDataObjectDetailDOS.add(resultDataObjectDetailDOs);
                    log.info("end：申请获取完毕");
                } catch (Throwable e) {
                    List<ApplyBZDataVO> applyDataVOList = finalClassfyBZVO.getObjects().getObject();
                    objerrorCode = "1";
                    if (!CollectionUtils.isEmpty(applyDataVOList)) {
                        applyDataVOList.stream().forEach(applyDataVO -> {
                            XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
                            xmlResultDataObjectDetailDO.setCode("");
                            xmlResultDataObjectDetailDO.setId(applyDataVO.getId());
                            xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
                            xmlResultDataObjectDetailDO.setMsg("编码申请失败:" + e.getMessage());
                            resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
                        });
                    } else {
                        XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
                        xmlResultDataObjectDetailDO.setCode("");
                        xmlResultDataObjectDetailDO.setId(applyDataVO.getId());
                        xmlResultDataObjectDetailDO.setId("");
                        xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
                        xmlResultDataObjectDetailDO.setMsg("编码申请失败:" + e.getMessage());
                        resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
                    });
                } else {
                    XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
                    xmlResultDataObjectDetailDO.setCode("");
                    xmlResultDataObjectDetailDO.setId("");
                    xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
                    xmlResultDataObjectDetailDO.setMsg("编码申请失败:" + e.getMessage());
                    resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
                    }
                    e.printStackTrace();
                }
                e.printStackTrace();
            } finally {
                XMLResultClassfyVO resultClassfyVO = new XMLResultClassfyVO();
                resultClassfyVO.setClassCode(classfyBZVO.getClassCode());
                resultClassfyVO.setLibrary(classfyBZVO.getLibrary());
                resultClassfyVO.setFullclsfNamePath(classfyBZVO.getFullclsfNamePath());
                resultClassfyVO.setObjects(resultDataObjectDetailDOs);
                resultClassfyVOList.add(resultClassfyVO);
            }
            });
            XMLResultClassfyVO resultClassfyVO = new XMLResultClassfyVO();
            resultClassfyVO.setClassCode(finalClassfyBZVO.getClassCode());
            resultClassfyVO.setLibrary(finalClassfyBZVO.getLibrary());
            resultClassfyVO.setFullclsfNamePath(finalClassfyBZVO.getFullclsfNamePath());
            resultClassfyVO.setObjects(resultDataObjectDetailDOs);
            resultClassfyVOList.add(resultClassfyVO);
            XMLResultSystemVO xmlResultSystemVO = new XMLResultSystemVO();
            xmlResultSystemVO.setClassifys(resultClassfyVOList);
            xmlResultSystemVO.setMsg(msg);
@@ -2081,6 +2086,7 @@
            e.printStackTrace();
            msg="申请编码失败:"+e.getMessage();
        }finally {

            XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
            xmlResultSystemVO.setClassifys(resultClassfyVOList);
            xmlResultSystemVO.setMsg(msg);
@@ -2286,6 +2292,115 @@
        }
        return codeOrderSecDTOList;
    }

    public void getConfigDatas(String systemId,String libray, ApplyBZDatasVO applyDatasVO,List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList,DataObjectVO dataObjectVO) throws Throwable {

        LinkedHashMap<String,LinkedHashMap<String,String>> dataKeyValueMap=new LinkedHashMap<>();
        //如果将数据转换成所需要的数据对象
        Map<String, String> attrMapConfigMap=new HashMap<>();
        Map<String, String> propMaps=new HashMap<>();
        try {
            log.info("开始读取系统配置文件 start");
            Map<String, String> stringStringMap=attributeMapConfig.getSystem_attrmap();
            log.info("集成系统属性映射配置文件条目数-》"+stringStringMap.size());
            //stringStringMap.put("RLM","D:\\RLM.xml");
            if(!CollectionUtils.isEmpty(stringStringMap)) {
                log.info("info：需要读取配置文件");
                LibraryDO libraryDO = gennerAttrMapUtil.getNewInstance().gennerAttrMapBySystem(systemId, stringStringMap);
                List<LibraryClsfDO> libraryClsfDOList = libraryDO.getClsf();
                if(!CollectionUtils.isEmpty(libraryClsfDOList)) {
                    Map<String, List<ClsfAttrMappingDO>> libPropMaps = libraryClsfDOList.stream().collect(Collectors.toMap(LibraryClsfDO::getLibrary, LibraryClsfDO::getProp, (key1, key2) -> key2));
                    log.info("根据参数：libray：-》" + libray + "从配置文件中找对应属性映射配置");
                    String path=stringStringMap.get(systemId);
                    if (libPropMaps.containsKey(libray)) {
                        log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息");
                        List<ClsfAttrMappingDO> clsfAttrMappingDOList = libPropMaps.get(libray);
                        propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2));
                        log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息,属性映射条目数+" + clsfAttrMappingDOList.size());
                    }else{
                        throw new Throwable("根据系统标识【"+systemId+"】找到对应的配置文件:【"+path+"】，但未获取到对应的库【"+libray+"】属性映射信息配置");
                    }
                }
            }
            log.info("根据参数：libray：-》"+libray+"从配置文件中找对应属性映射配置 end ");
        }catch (Throwable e){
            objerrorCode="1";
            e.printStackTrace();
            throw new Throwable("MDM集成属性配置文件读取失败");
        }
        LinkedList<String> rowNameList=new LinkedList<>();
        LinkedHashMap<String,Integer> filedIndexMap=new LinkedHashMap<>();
        //根据分类模板组织数据
        final int[] index = {0};
        try {
            codeClassifyTemplateAttrVOList.stream().forEach(codeClassifyTemplateAttrVO -> {
                String attrName = codeClassifyTemplateAttrVO.getName();
                String field = codeClassifyTemplateAttrVO.getId();
                rowNameList.add(attrName);
                filedIndexMap.put(field, index[0]++);
            });
            dataObjectVO.setColName(rowNameList);//放入属性
            attrMapConfigMap.putAll(propMaps);
            LinkedList<RowDatas> rowDataList = new LinkedList<>();
            List<ApplyBZDataVO> applyBZDataVOList=new ArrayList<>();

            if(!CollectionUtils.isEmpty(applyDatasVO.getObject())){
                applyBZDataVOList=applyDatasVO.getObject();
            }
            //Map<String, List<ProppertyVO>> dataPropMap = applyDataVOList.stream().collect(Collectors.toMap(ApplyDataVO::getId, ApplyDataVO::getProp, (key1, key2) -> key2));
            final int[] rowIndex = {0};
            applyBZDataVOList.stream().forEach(applyDataVO -> {
                rowIndex[0]++;
                RowDatas rowDatas = new RowDatas();
                rowDatas.setOid(applyDataVO.getId());
                rowDatas.setCreator(applyDataVO.getCreator());
                rowDatas.setEditor(applyDataVO.getEditor());
                rowDatas.setCode(applyDataVO.getCode());
                rowDatas.setOperation("create");
                rowDatas.setStatus(applyDataVO.getStatus());
                rowDatas.setRowIndex(rowIndex[0] + "");
                List<ProppertyVO> proppertyVOList = applyDataVO.getProp();

                LinkedHashMap<Integer, String> integerValueMap = new LinkedHashMap<>();
                Map<String, String> filedValueMap = new HashMap<>();
                if (!CollectionUtils.isEmpty(proppertyVOList)) {
                    Map<String, String> sourceKeyValueMap = proppertyVOList.stream().collect(Collectors.toMap(ProppertyVO::getKey, ProppertyVO::getValue, (key1, key2) -> key2));
                    Map<String, String> keyValueMap = new HashMap<>();
                    //判断attrMapConfigMap是否有值，如果没有则说明基础默认的是编码系统字段
                    if (!CollectionUtils.isEmpty(attrMapConfigMap)) {
                        sourceKeyValueMap.keySet().forEach(sourceKey -> {
                            String dataValue = sourceKeyValueMap.get(sourceKey);
                            if (attrMapConfigMap.containsKey(sourceKey)) {
                                String targetKey = attrMapConfigMap.get(sourceKey);
                                keyValueMap.put(targetKey, StringUtils.isBlank(dataValue)?"":dataValue);
                            }
                        });
                    } else {
                        sourceKeyValueMap.forEach((filed,value)->{
                            keyValueMap.put(filed,StringUtils.isBlank(value)?"":value) ;
                        });
                    }

                    filedIndexMap.forEach((attrKey, column) -> {
                        String keyValue = "";
                        if (keyValueMap.containsKey(attrKey)) {
                            keyValue =StringUtils.isBlank(keyValueMap.get(attrKey))?"":keyValueMap.get(attrKey);
                        }
                        integerValueMap.put(column, keyValue);
                        filedValueMap.put(attrKey, keyValue);
                    });
                }
                rowDatas.setData(integerValueMap);
                rowDatas.setFiledValue(filedValueMap);
                rowDataList.add(rowDatas);
            });
            dataObjectVO.setRowData(rowDataList);
        }catch (Throwable e){
            objerrorCode="1";
            throw new   Throwable("组织数据映射值失败");
        }
    }

    /***
     * 根据属性映射转换编码所需字段
     */