以及发布webservice接口功能搭建,将通通用接口移植过来

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/mapper/CodeClassifyMapper.java

@@ -88,4 +88,15 @@
    @MapKey("OID")
    List<Map<String,Object>> selectByFieldPath(@Param("fieldPath") String fieldPath);


    /**
     * 查根据id层级获取对象
     *
     * @param fieldPath 分类的主键
     *  @param fieldName 分类的主键
     * @return 数据集合
     */
    List<CodeClassify> selectByFieldNamePath(@Param("fieldPath") String fieldPath,@Param("fieldName") String fieldName);


}

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

@@ -228,4 +228,20 @@
     * @return 分类上级，下级的信息
     */
    CodeClassifyFullInfoBO getClassifyFullInfo(String codeClassifyOid);


    /**
     * 使用编号的路径获取对象
     * @param clsfNamePath 分类名称的路径，一定要从最顶层节点开始，格式为xxx/yyy/zz 这样
     * @return 分类的显示对象
     */
    CodeClassifyVO getObjectByClsfNamePath(String clsfNamePath);

    /***
     * 根据上级节点获取下级节点代号路径和名称路径
     * @param classifyId
     * @param enable
     * @return
     */
    public List<CodeClassifyVO> getIdPathToNamePathByParentId(String classifyId,boolean enable);
}

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

@@ -1,39 +1,46 @@
//package com.vci.ubcs.code.service;
//
//
//import com.baomidou.mybatisplus.extension.service.IService;
//import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
//import com.vci.ubcs.code.dto.CodeOrderDTO;
//import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
//import com.vci.ubcs.code.entity.CodeAllCode;
//import com.vci.ubcs.code.vo.CodeClstemplateVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
//import com.vci.ubcs.starter.web.pagemodel.KeyValue;
//
//import java.util.List;
//
///**
// * 主数据引擎服务
// * @author weidy
// * @date 2022-2-21
// */
//public interface MdmEngineService extends IService<CodeAllCode> {
////    /**
////     * 使用分类的主键获取可以使用的模板对象
////     * @param codeClassifyOid 分类的主键
////     * @return 模板的显示对象
////     */
////    CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid);
////
////    /**
////     * 使用分类的主键获取可以使用的模板对象
////     * @param codeClassifyOid 分类的主键
////     * @param hasAttr 包含属性
////     * @return 模板的显示对象
////     */
////    CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr);
package com.vci.ubcs.code.service;


import com.baomidou.mybatisplus.extension.service.IService;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.entity.CodeAllCode;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;

import java.util.List;

/**
 * 主数据引擎服务
 * @author weidy
 * @date 2022-2-21
 */
public interface MdmEngineService extends IService<CodeAllCode> {


    /**
     * 使用分类的主键获取可以使用的模板对象
     * @param codeClassifyOid 分类的主键
     * @return 模板的显示对象
     */
    CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid);

    /**
     * 使用分类的主键获取可以使用的模板对象
     * @param codeClassifyOid 分类的主键
     * @param hasAttr 包含属性
     * @return 模板的显示对象
     */
    CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr);



    /**
     * 使用分类的全部信息获取编码规则
     * @param fullInfoBO 分类的全部信息
     * @return 规则的内容
     */
    CodeRuleVO getCodeRuleByClassifyFullInfo(CodeClassifyFullInfoBO fullInfoBO);

////
////    /**
////     * 获取枚举的下拉选项
@@ -133,4 +140,4 @@
////     * @param orderDTO 数据的内容，不用包含码段的内容了
////     */
////    void editSaveCode(CodeOrderDTO orderDTO);
//}
}

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

@@ -468,6 +468,28 @@
        }
        return tree;
    }
    /**
     * 使用编号的路径获取对象
     *
     * @param fieldPath 编号的路径，一定要从最顶层节点开始，格式为xxx/yyy/zz 这样
     * @return 分类的显示对象
     */
    @Override
    public CodeClassifyVO getObjectByClsfNamePath(String fieldPath){

        CodeClassify classify = (CodeClassify) codeClassifyMapper.selectByFieldNamePath(fieldPath, "name");
        return codeClassifyDO2VO(classify);
    }
    /***
     * 根据上级节点获取下级节点代号路径和名称路径
     * @param classifyId
     * @param enable
     * @return
     */
    @Override
    public List<CodeClassifyVO> getIdPathToNamePathByParentId(String classifyId, boolean enable) {
        return null;
    }


//    /**

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

@@ -1,60 +1,34 @@
//package com.vci.ubcs.code.service.impl;
package com.vci.ubcs.code.service.impl;
import com.alibaba.cloud.commons.lang.StringUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.entity.CodeAllCode;
import com.vci.ubcs.code.mapper.CodeAllCodeMapper;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
import com.vci.ubcs.starter.exception.VciBaseException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
//
//import com.alibaba.fastjson.JSONObject;
//import com.alibaba.nacos.common.utils.StringUtils;
//import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
//import com.baomidou.mybatisplus.extension.service.IService;
//import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
//import com.sun.corba.se.impl.orbutil.ObjectUtility;
//import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
//import com.vci.ubcs.code.dto.CodeOrderDTO;
//import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
//import com.vci.ubcs.code.entity.CodeAllCode;
//import com.vci.ubcs.code.entity.CodeOsbtmtypeEntity;
//import com.vci.ubcs.code.entity.CodeRule;
//import com.vci.ubcs.code.entity.CodeWupinEntity;
//import com.vci.ubcs.code.enumpack.CodeDefaultLC;
//import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
//import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
//import com.vci.ubcs.code.mapper.CodeAllCodeMapper;
//import com.vci.ubcs.code.mapper.CodeOsbtmtypeMapper;
//import com.vci.ubcs.code.mapper.CodeRuleMapper;
//import com.vci.ubcs.code.service.*;
//import com.vci.ubcs.code.vo.CodeClstemplateVO;
//import com.vci.ubcs.code.vo.CodeKeyattrrepeatVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeBasicSecVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
//import com.vci.ubcs.omd.entity.Dict;
//import com.vci.ubcs.starter.exception.VciBaseException;
//import com.vci.ubcs.starter.revision.model.BaseModel;
//import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
//import com.vci.ubcs.starter.web.pagemodel.KeyValue;
//import com.vci.ubcs.starter.web.toolmodel.DateConverter;
//import com.vci.ubcs.starter.web.util.VciBaseUtil;
//import com.vci.ubcs.starter.web.util.VciDateUtil;
//import com.vci.ubcs.starter.web.util.VciQueryWrapperForDO;
//import com.vci.ubcs.starter.web.util.WebUtil;
//import com.vci.ubcs.system.entity.DictBiz;
//import com.vci.ubcs.system.feign.IDictBizClient;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springblade.core.mp.support.Query;
//import org.springblade.core.secure.utils.AuthUtil;
//import org.springblade.core.tool.api.R;
//import org.springframework.beans.BeanUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//
///**
// * 主数据引擎服务
// *
// * @author weidy
// * @date 2022-2-22
// */
//@Service
//public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService {


/**
 * 主数据引擎服务
 *
 * @author weidy
 * @date 2022-2-22
 */
@Slf4j
@Service
public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService {
//
//
//    /**
@@ -76,29 +50,75 @@
//    //    @Autowired
//    //    private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
//
//    /**
//     * 使用分类的主键获取可以使用的模板对象
//     *
//     * @param codeClassifyOid 分类的主键
//     * @return 模板的显示对象
//     */
//    @Override
//    public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) {
//        return getUsedTemplateByClassifyOid(codeClassifyOid, true);
//    }
    /**
     * 模板的服务
     */
    @Autowired(required = false)
    private ICodeClassifyTemplateAttrService codeClassifyTemplateAttrService;

    /***
     * 编码规则服务
     */
    @Autowired(required = false)
    private ICodeRuleService codeRuleService;
    /**
     * 使用分类的主键获取可以使用的模板对象
     *
     * @param codeClassifyOid 分类的主键
     * @return 模板的显示对象
     */
    @Override
    public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) {
        return getUsedTemplateByClassifyOid(codeClassifyOid, true);
    }
//
//    /**
//     * 使用分类的主键获取可以使用的模板对象
//     *
//     * @param codeClassifyOid 分类的主键
//     * @param hasAttr         包含属性
//     * @return 模板的显示对象
//     */
//    @Override
//    public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) {
//        List<CodeClstemplateVO> templateVOs = templateService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr);
//        return templateVOs.get(templateVOs.size() - 1);
//    }
    /**
     * 使用分类的主键获取可以使用的模板对象
     *
     * @param codeClassifyOid 分类的主键
     * @param hasAttr         包含属性
     * @return 模板的显示对象
     */
    @Override
    public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) {
        List<CodeClassifyTemplateVO> templateVOs=new ArrayList<>();
        //templateVOs = codeClassifyTemplateAttrService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr);
        return templateVOs.get(templateVOs.size() - 1);
    }


    /**
     * 使用分类的全部信息获取编码规则
     *
     * @param fullInfoBO 分类的全部信息
     * @return 规则的内容
     */
    @Override
    public CodeRuleVO getCodeRuleByClassifyFullInfo(CodeClassifyFullInfoBO fullInfoBO) {
        //往上找
        String codeRuleOid = "";
        if (StringUtils.isNotBlank(fullInfoBO.getCurrentClassifyVO().getCoderuleoid())) {
            codeRuleOid = fullInfoBO.getCurrentClassifyVO().getCoderuleoid();
        } else {
            if (CollectionUtils.isEmpty(fullInfoBO.getParentClassifyVOs())) {
                //说明已经是最高层级,
                throw new VciBaseException("当前主题库分类，以及它的所有的上级分类都没有设置编码规则");
            }
            List<CodeClassifyVO> parentClassifyVOList = fullInfoBO.getParentClassifyVOs().stream().sorted((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel())).collect(Collectors.toList());
            //从最高的level开始获取
            for (int i = 0; i < parentClassifyVOList.size(); i++) {
                CodeClassifyVO record = parentClassifyVOList.get(i);
                if (StringUtils.isNotBlank(record.getCoderuleoid())) {
                    codeRuleOid = record.getCoderuleoid();
                    break;
                }
            }
            if (StringUtils.isBlank(codeRuleOid)) {
                throw new VciBaseException("当前主题库分类，以及它的所有的上级分类都没有设置编码规则");
            }
        }
        return codeRuleService.getObjectHasSecByOid(codeRuleOid);
    }
//
//    /**
//     * 获取枚举的下拉选项
@@ -1788,4 +1808,4 @@
////        batchSaveSelectChar(templateVO, cboList);
////    }
//
//}
}

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

@@ -2,16 +2,13 @@

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
import com.vci.ubcs.code.entity.CodeBasicSec;
import com.vci.ubcs.code.entity.CodeClassify;
import com.vci.ubcs.code.entity.DockingLog;
import com.vci.ubcs.code.entity.*;
import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.util.gennerAttrMapUtil;
@@ -69,8 +66,8 @@
    /**
     * 主数据引擎的服务
     */
    //@Resource
    //private MdmEngineService engineService;
    @Resource
    private MdmEngineService engineService;

    /**
     * 密级的服务
@@ -99,152 +96,152 @@
    @Override
    public String applyCode(String data, String dataType) throws Throwable {
        {
//            String resultStr = "";
//            String errorid="0";
//            msg="成功";
//            objerrorCode="0";
//            objerrorMsg="成功";
//            logger.info("申请编码的数据参数:->"+data);
//            logger.info("申请编码的数据类型:->"+dataType);
//            String systemId="";
//            List<XMLResultClassfyVO> resultClassfyVOList = new ArrayList<>();
//            try {
//                if(StringUtils.isBlank(data)) {
//                    errorid="101";
//                    throw new Throwable("接口参数：传递为空");
//                }
//                InterParameterVO interParameterVO  =new InterParameterVO();
//                //如果dataType是xml则，通过xml序列化成对象形式，如果是json则通过json转换成对象格式
//                try {
//                    if ("xml".equals(dataType)) {
//                        XStream xStream = new XStream(new DomDriver());
//                        xStream.processAnnotations(RootDataVO.class);
//                        xStream.autodetectAnnotations(true);
//                        RootDataVO rootDataVO = (RootDataVO) xStream.fromXML(data);
//                        interParameterVO.setData(rootDataVO);
//                    } else {
//                        interParameterVO = JSONObject.toJavaObject(JSONObject.parseObject(data), InterParameterVO.class);
//                    }
//                }catch (Throwable e){
//                    errorid="101";
//                    throw new Throwable("接口参数：传入数据参数解析失败");
//                }
//                ClassfysVO classfysVO = interParameterVO.getData().getClassifys();
//                systemId = interParameterVO.getData().getSystemId();
//                UserVO userVo = interParameterVO.getData().getUser();
//                List<ClassfyVO> classVOList = classfysVO.getClassify();
//                InterParameterVO finalInterParameterVO = interParameterVO;
//
//                //这是账号信息
//                SessionInfo sessionInfo = new SessionInfo();
//                sessionInfo.setUserId(userVo.getUserName());
//                sessionInfo.setUserName(userVo.getTrueName());
//                sessionInfo.setIp(userVo.getIp());
//                VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
//
//                String finalSystemId = systemId;
//                classVOList.stream().forEach(classVO -> {
//                    logger.info("参数：分类COde:" + classVO.getClassCode());
//                    LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
//                    //获取分类信息
//                    try {
//                        String libray = classVO.getLibrary();
//                        CodeClassifyVO codeClassifyVO = getClassfy(classVO);
//                        logger.info("end：分类查询完毕");
//                        //获取分类模板信息
//                        if(codeClassifyVO==null || StringUtils.isBlank(codeClassifyVO.getOid())){
//                            objerrorCode="100";
//                            throw  new  Throwable ("根据传输的分类，未获取到分类信息");
//                        }
//                        CodeClstemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
//                        if(templateVO==null||StringUtils.isBlank(templateVO.getOid())){
//                            objerrorCode="1";
//                            throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应模板");
//                        }
//                        logger.info("end：模板查询完毕");
//                        ApplyDatasVO applyDatasVO = classVO.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);
//                        logger.info("end：数据组织完毕");
//                        //规则的主键需要去获取
//                        CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
//                        if(classifyFullInfo==null ||classifyFullInfo.getCurrentClassifyVO()==null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())){
//                            objerrorCode="1";
//                            logger.info("classifyFullInfo:"+"根据传输的分类，未获取分类相关信息");
//                            throw  new  Throwable ("根据传输的分类，未获取分类相关信息");
//                        }
//                        CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
//                        if(ruleVO==null|| StringUtils.isBlank(ruleVO.getOid())){
//                            objerrorCode="102";
//                            throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应规则");
//                        }
//                        logger.info("end：规则获取完毕");
//                        List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(classVO.getSections().getSection(), ruleVO);
//                        logger.info("end：码段获取完毕");
//                        CodeOrderDTO orderDTO = new CodeOrderDTO();
//                        orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
//                        orderDTO.setSecDTOList(codeOrderSecDTOList);//分类码段
//                        mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs);
//                        logger.info("end：申请获取完毕");
//                    } catch (Throwable e) {
//                        XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
//                        xmlResultDataObjectDetailDO.setCode("");
//                        xmlResultDataObjectDetailDO.setId("");
//                        xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
//                        xmlResultDataObjectDetailDO.setMsg("编码申请失败:"+e.getMessage());
//                        resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
//                        e.printStackTrace();
//                    }finally {
//                        XMLResultClassfyVO resultClassfyVO = new XMLResultClassfyVO();
//                        resultClassfyVO.setClassCode(classVO.getClassCode());
//                        resultClassfyVO.setLibrary(classVO.getLibrary());
//                        resultClassfyVO.setFullclsfNamePath(classVO.getFullclsfNamePath());
//                        resultClassfyVO.setObjects(resultDataObjectDetailDOs);
//                        resultClassfyVOList.add(resultClassfyVO);
//                    }
//                });
//                XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
//                xmlResultSystemVO.setClassifys(resultClassfyVOList);
//                xmlResultSystemVO.setMsg(msg);
//                xmlResultSystemVO.setErrorid(errorid);
//                resultStr= transferResultXMl(xmlResultSystemVO,dataType);
//            }catch (Throwable e){
//                e.printStackTrace();;
//                msg="申请编码失败:"+e.getMessage();
//            }finally {
//                XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
//                xmlResultSystemVO.setClassifys(resultClassfyVOList);
//                xmlResultSystemVO.setMsg(msg);
//                xmlResultSystemVO.setErrorid(errorid);
//                resultStr= transferResultXMl(xmlResultSystemVO,dataType);
//                final boolean[] issucess = {true};
//                if(!errorid.equals("0")) {
//                    issucess[0] = false;
//                }else {
//                    if(!CollectionUtils.isEmpty(resultClassfyVOList)) {
//                        resultClassfyVOList.stream().forEach(xMLResultClassfyVO -> {
//                            xMLResultClassfyVO.getObjects().stream().forEach(objec -> {
//                                if (!(objec.getErrorid().equals("0") || objec.getErrorid().equals("204"))) {
//                                    issucess[0] = false;
//                                    msg=objec.getMsg();
//                                }
//                            });
//                        });
//                    }
//
//                }
//                try {
//                    //记录日志
//                    this.saveLogs(systemId, systemId, data, resultStr, issucess[0], msg, "applyCode");
//                }catch (Throwable e){
//                    e.printStackTrace();
//                }
//            }
//            logger.info("返回参数:"+resultStr);
            String resultStr = "";
            String errorid="0";
            msg="成功";
            objerrorCode="0";
            objerrorMsg="成功";
            logger.info("申请编码的数据参数:->"+data);
            logger.info("申请编码的数据类型:->"+dataType);
            String systemId="";
            List<XMLResultClassfyVO> resultClassfyVOList = new ArrayList<>();
            try {
                if(StringUtils.isBlank(data)) {
                    errorid="101";
                    throw new Throwable("接口参数：传递为空");
                }
                InterParameterVO interParameterVO  =new InterParameterVO();
                //如果dataType是xml则，通过xml序列化成对象形式，如果是json则通过json转换成对象格式
                try {
                    if ("xml".equals(dataType)) {
                        XStream xStream = new XStream(new DomDriver());
                        xStream.processAnnotations(RootDataVO.class);
                        xStream.autodetectAnnotations(true);
                        RootDataVO rootDataVO = (RootDataVO) xStream.fromXML(data);
                        interParameterVO.setData(rootDataVO);
                    } else {
                        interParameterVO = JSONObject.toJavaObject(JSONObject.parseObject(data), InterParameterVO.class);
                    }
                }catch (Throwable e){
                    errorid="101";
                    throw new Throwable("接口参数：传入数据参数解析失败");
                }
                ClassfysVO classfysVO = interParameterVO.getData().getClassifys();
                systemId = interParameterVO.getData().getSystemId();
                UserVO userVo = interParameterVO.getData().getUser();
                List<ClassfyVO> classVOList = classfysVO.getClassify();
                InterParameterVO finalInterParameterVO = interParameterVO;

            return "";
                //这是账号信息
                SessionInfo sessionInfo = new SessionInfo();
                sessionInfo.setUserId(userVo.getUserName());
                sessionInfo.setUserName(userVo.getTrueName());
                sessionInfo.setIp(userVo.getIp());
                VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);

                String finalSystemId = systemId;
                classVOList.stream().forEach(classVO -> {
                    logger.info("参数：分类COde:" + classVO.getClassCode());
                    LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
                    //获取分类信息
                    try {
                        String libray = classVO.getLibrary();
                        CodeClassifyVO codeClassifyVO = getClassfy(classVO);
                        logger.info("end：分类查询完毕");
                        //获取分类模板信息
                        if(codeClassifyVO==null || StringUtils.isBlank(codeClassifyVO.getOid())){
                            objerrorCode="100";
                            throw  new  Throwable ("根据传输的分类，未获取到分类信息");
                        }
                        CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
                        if(templateVO==null||StringUtils.isBlank(templateVO.getOid())){
                            objerrorCode="1";
                            throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应模板");
                        }
                        logger.info("end：模板查询完毕");
                        ApplyDatasVO applyDatasVO = classVO.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);
                        logger.info("end：数据组织完毕");
                        //规则的主键需要去获取
                        CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
                        if(classifyFullInfo==null ||classifyFullInfo.getCurrentClassifyVO()==null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())){
                            objerrorCode="1";
                            logger.info("classifyFullInfo:"+"根据传输的分类，未获取分类相关信息");
                            throw  new  Throwable ("根据传输的分类，未获取分类相关信息");
                        }
                        CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
                        if(ruleVO==null|| StringUtils.isBlank(ruleVO.getOid())){
                            objerrorCode="102";
                            throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应规则");
                        }
                        logger.info("end：规则获取完毕");
                        List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(classVO.getSections().getSection(), ruleVO);
                        logger.info("end：码段获取完毕");
                        CodeOrderDTO orderDTO = new CodeOrderDTO();
                        orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
                        orderDTO.setSecDTOList(codeOrderSecDTOList);//分类码段
                        //mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs);
                        logger.info("end：申请获取完毕");
                    } catch (Throwable e) {
                        XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                        xmlResultDataObjectDetailDO.setCode("");
                        xmlResultDataObjectDetailDO.setId("");
                        xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
                        xmlResultDataObjectDetailDO.setMsg("编码申请失败:"+e.getMessage());
                        resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
                        e.printStackTrace();
                    }finally {
                        XMLResultClassfyVO resultClassfyVO = new XMLResultClassfyVO();
                        resultClassfyVO.setClassCode(classVO.getClassCode());
                        resultClassfyVO.setLibrary(classVO.getLibrary());
                        resultClassfyVO.setFullclsfNamePath(classVO.getFullclsfNamePath());
                        resultClassfyVO.setObjects(resultDataObjectDetailDOs);
                        resultClassfyVOList.add(resultClassfyVO);
                    }
                });
                XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
                xmlResultSystemVO.setClassifys(resultClassfyVOList);
                xmlResultSystemVO.setMsg(msg);
                xmlResultSystemVO.setErrorid(errorid);
                resultStr= transferResultXMl(xmlResultSystemVO,dataType);
            }catch (Throwable e){
                e.printStackTrace();;
                msg="申请编码失败:"+e.getMessage();
            }finally {
                XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
                xmlResultSystemVO.setClassifys(resultClassfyVOList);
                xmlResultSystemVO.setMsg(msg);
                xmlResultSystemVO.setErrorid(errorid);
                resultStr= transferResultXMl(xmlResultSystemVO,dataType);
                final boolean[] issucess = {true};
                if(!errorid.equals("0")) {
                    issucess[0] = false;
                }else {
                    if(!CollectionUtils.isEmpty(resultClassfyVOList)) {
                        resultClassfyVOList.stream().forEach(xMLResultClassfyVO -> {
                            xMLResultClassfyVO.getObjects().stream().forEach(objec -> {
                                if (!(objec.getErrorid().equals("0") || objec.getErrorid().equals("204"))) {
                                    issucess[0] = false;
                                    msg=objec.getMsg();
                                }
                            });
                        });
                    }

                }
                try {
                    //记录日志
                    this.saveLogs(systemId, systemId, data, resultStr, issucess[0], msg, "applyCode");
                }catch (Throwable e){
                    e.printStackTrace();
                }
            }
            logger.info("返回参数:"+resultStr);

            return resultStr;
        }
    }

@@ -315,10 +312,10 @@
                    throw new  Throwable("根据分类代号未查询到相应的分类信息");
                }
            } else {
                //classifyVO = classifyService.getObjectByClsfNamePath(className.replace(separator, "/"));
                //if(StringUtils.isBlank(classifyVO.getOid())){
                //    throw new  Throwable("根据分类名称路径未查询到相应的分类信息");
                //}
                classifyVO = classifyService.getObjectByClsfNamePath(className.replace(separator, "/"));
                if(StringUtils.isBlank(classifyVO.getOid())){
                    throw new  Throwable("根据分类名称路径未查询到相应的分类信息");
                }
            }
        }catch (Throwable e){
            objerrorCode="100";

 Source/UBCS/ubcs-service/ubcs-code/src/main/resources/mapper/CodeCLassifyMapper.xml

@@ -144,6 +144,43 @@
        select oid,level from pl_code_classify start with oid= #{oid} connect by prior PARENTCODECLASSIFYOID = oid
    </select>

    <select id="selectByFieldNamePath"  resultMap="plCodeClassifyResultMap">
        select codeclassify0.OWNER                 as owner,
               codeclassify0.BTMTYPEID             as btmtypeid,
               codeclassify0.CREATOR               as creator,
               codeclassify0.CREATETIME            as createtime,
               codeclassify0.LASTMODIFIER          as lastmodifier,
               codeclassify0.DESCRIPTION           as description,
               codeclassify0.ORDERNUM              as ordernum,
               codeclassify0.CODERULEOID           as coderuleoid,
               codeclassify0.OID                   as oid,
               codeclassify0.BTMNAME               as btmname,
               codeclassify0.BTMTYPENAME           as btmtypename,
               codeclassify0.CODEKEYATTRREPEATOID  as codekeyattrrepeatoid,
               codeclassify0.PARENTCODECLASSIFYOID as parentcodeclassifyoid,
               codeclassify0.NAME                  as name,
               codeclassify0.LASTMODIFYTIME        as lastmodifytime,
               codeclassify0.ID                    as id,
               codeclassify0.CODERESEMBLERULEOID   as coderesembleruleoid,
               codeclassify0.LCSTATUS              as lcstatus,
               codeclassify0.TS                    as ts,
               codeclassify0.paths                 as paths
        from (select plcodeclassify.*,
                <choose>
                     <when test="fieldName=='name'.tostring()">
                        SYS_CONNECT_BY_PATH(name, '##') as paths
                     </when>
                    <otherwise>
                        SYS_CONNECT_BY_PATH(id, '##') as paths
                    </otherwise>
                </choose>

        from pl_code_classify  plcodeclassify
                  START WITH parentCodeClassifyOid is null
              CONNECT BY PRIOR OID = parentCodeClassifyOid) codeclassify0
        where codeclassify0.paths =#{fieldPath}
    </select>

    <select id="selectByFieldPath" resultType="java.util.HashMap">
        select *
        from (select oid, SYS_CONNECT_BY_PATH(id, '/') as paths