集成获取mdm分发通用数据格式接口集成

 Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/webserviceModel/mdm/MDMData.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
package com.vci.ubcs.code.vo.webserviceModel.mdm;

import lombok.Data;
import org.omg.CORBA.Object;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MDMData implements Serializable {
    private List<Map<String,String>> map= new ArrayList<>();

    public List<Map<String,String>> getMap() {
        return map;
    }

    public void setMap(List<Map<String,String>> map) {
        this.map = map;
    }
}

 Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/webserviceModel/mdm/MDMParamData.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,113 @@
package com.vci.ubcs.code.vo.webserviceModel.mdm;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class MDMParamData  implements Serializable {
    /**
     * æ•°æ®å®¡æ‰¹çŠ¶æ€0：审批正常，1：审批拒绝
     */
    private int code;

    /***
     * å®¡æ‰¹æ‹’绝时的详情信息
     */
    private String msg;

    /**
     * é›†æˆç³»ç»Ÿç¼–码
     */
    private String systemCode;

    /**
     * ä¸»æ•°æ®æ¨¡åž‹çš„编码
     */
    private  String mdType;

    /***
     * æ•°æ®åˆ†å‘所触发的类型 æ‰‹åŠ¨åˆ†å‘:distribute_manual,
     */
    private String action;

    /***
     * æ¶ˆè´¹ç³»ç»Ÿä¸­é…ç½®çš„分发令牌
     */
    private String distributeToken;


    /***
     * åˆ†å‘人员数据信息
     */
    private List<Map<String,String>> masterData=new ArrayList<>();

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getSystemCode() {
        return systemCode;
    }

    public void setSystemCode(String systemCode) {
        this.systemCode = systemCode;
    }

    public String getMdType() {
        return mdType;
    }

    public void setMdType(String mdType) {
        this.mdType = mdType;
    }

    public String getAction() {
        return action;
    }

    public void setAction(String action) {
        this.action = action;
    }

    public String getDistributeToken() {
        return distributeToken;
    }

    public void setDistributeToken(String distributeToken) {
        this.distributeToken = distributeToken;
    }

    public List<Map<String,String>> getMasterData() {
        return masterData;
    }

    public void setMasterData(List<Map<String,String>> masterData) {
        this.masterData = masterData;
    }

    @Override
    public String toString() {
        return "MDMParamData{" +
            "code=" + code +
            ", msg='" + msg + '\'' +
            ", systemCode='" + systemCode + '\'' +
            ", mdType='" + mdType + '\'' +
            ", action='" + action + '\'' +
            ", distributeToken='" + distributeToken + '\'' +
            ", masterData=" + masterData +
            '}';
    }
}

 Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/webserviceModel/mdm/MdmResultData.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
package com.vci.ubcs.code.vo.webserviceModel.mdm;

import com.vci.ubcs.code.vo.webserviceModel.person.ResultMdMapping;

import java.io.Serializable;
import java.util.List;

public class MdmResultData implements Serializable {

    /***
     * æ ‡è¯†å¤„理成功或失败
     */
    private boolean success;
    /***
     * æˆåŠŸæˆ–失败的信息
     */
    private String message;
    /**
     * åˆ†å‘的所有数据的信息
     */
    private List<ResultMdMapping> mdMappings;

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public List<ResultMdMapping> getMdMappings() {
        return mdMappings;
    }

    public void setMdMappings(List<ResultMdMapping> mdMappings) {
        this.mdMappings = mdMappings;
    }

    @Override
    public String toString() {
        return "MdmResultData{" +
            "success=" + success +
            ", message='" + message + '\'' +
            ", mdMappings=" + mdMappings +
            '}';
    }
}

 Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/webserviceModel/mdm/data.json

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,62 @@
{ "msg":"审批拒绝时的详情信息",
  "distributeToken": "2",
  "code":"0",
  "systemCode":"ERP",
  "mdType":"product_info",
  "action":"distribute_subseribe",
  "masterData": [
    {
      "id": "xj000001",
      "dr": "0",
      "mdm_code": "xj000001",
      "industry": "",
      "product_family": "",
      "product_line": "product_line",
      "product_manu_symbol": "product_manu_symbol",
      "product_manufacture_code": "manufacture_code",
      "product_manufacture_name": "name",
      "product_model": "product_model",
      "product_model_name": "product_model_name",
      "product_model_symbol": "product_model_symbol",
      "product_type": "product_type",
      "project_code": "project_code",
      "project_name": "project_name",
      "project_symbol": "project_symbol",
      "pk_mdm": "xj0001",
      "mdm_version": "V1",
      "mdm_duplicate": "0",
      "creator": "zhangsan",
      "createtime": "2024-10-23",
      "modifier": "zhangsan",
      "modifytime": "2024-10-23",
      "mdm_datastatus": "3",
      "mdm_cleanstatus": "TRANSFER"
    },{
      "id": "xj000002",
      "dr": "0",
      "mdm_code": "xj_00002",
      "industry": "",
      "product_family": "",
      "product_line": "product_line",
      "product_manu_symbol": "product_manu_symbol1",
      "product_manufacture_code": "product_manufacture_code1",
      "product_manufacture_name": "product_manufacture_name1",
      "product_model": "product_model1",
      "product_model_name": "product_model_name1",
      "product_model_symbol": "product_model_symbol1",
      "product_type": "type",
      "project_code": "project_code1",
      "project_name": "project_name1",
      "project_symbol": "symbol",
      "pk_mdm": "xj0002",
      "mdm_version": "V1",
      "mdm_duplicate": "0",
      "creator": "zhangsan",
      "createtime": "2024-10-23",
      "modifier": "zhangsan",
      "modifytime": "2024-10-23",
      "mdm_datastatus": "3",
      "mdm_cleanstatus": "TRANSFER"
    }
  ]
}

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

@@ -1,4 +1,4 @@
package  com.vci.ubcs.code.Scheduling;
package com.vci.ubcs.code.Scheduling;

import com.vci.ubcs.code.service.ICodeDuckingSyncService;
import com.vci.ubcs.starter.web.enumpck.BooleanEnum;

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

@@ -1,6 +1,10 @@
package com.vci.ubcs.code.controller;

import com.vci.ubcs.code.service.CodeMdmInfaceI;
import com.vci.ubcs.code.service.UniversalInterfaceI;
import com.vci.ubcs.code.vo.webserviceModel.mdm.MDMData;
import com.vci.ubcs.code.vo.webserviceModel.mdm.MDMParamData;
import com.vci.ubcs.code.vo.webserviceModel.mdm.MdmResultData;
import com.vci.ubcs.code.vo.webserviceModel.person.PersonData;
import com.vci.ubcs.code.vo.webserviceModel.person.ResultOrgData;
import org.apache.tools.ant.taskdefs.condition.Http;
@@ -35,6 +39,12 @@
     */
    @Autowired
    private UniversalInterfaceI universalInterfaceI;

    /**
     * æŽ¥å£é›†æˆæœåŠ¡
     */
    @Autowired
    private CodeMdmInfaceI codeMdmInfaceI;

    /****
     * ç”³è¯·æŽ¥å£
@@ -177,6 +187,29 @@
    }

    /**
     * æŽ¥å—MDM产品分发数据
     * @param mdmParamData
     * @param request
     * @return
     */
    @PostMapping("/syncDataForProduct")
    public MdmResultData syncDataForProduct(@RequestBody MDMParamData mdmParamData,HttpServletRequest request){

        //this.setHttpToThreadLocal(request);
        ThreadLocal<HttpServletRequest> threadLocal = new ThreadLocal<>();
        threadLocal.set(request);
        codeMdmInfaceI.setThreadLocal(threadLocal);
        MdmResultData result = new MdmResultData();
        try {
            result= codeMdmInfaceI.syncDataForMDM(mdmParamData,"CPXH","CPXH");
        }catch (Throwable e){
            e.printStackTrace();
            logger.error("ResultOrgData->"+e.getMessage());
        }
        return result;
    }

    /**
     * è®¾ç½®request，到ThreadLocal中
     * @param request
     */
@@ -184,18 +217,20 @@
        ThreadLocal<HttpServletRequest> threadLocal = new ThreadLocal<>();
        threadLocal.set(request);
        universalInterfaceI.setThreadLocal(threadLocal);
        //codeMdmInfaceI.setThreadLocal(threadLocal);
    }



    /***
     *
     * @param dataString
     * @param dataType
     * @param mdmData
     * @param request
     * @return
     */
    @PostMapping("/test")
    public String test(@RequestParam("dataString")String dataString, @RequestParam("dataType")String dataType,HttpServletRequest request){
        String result="{\"data\": {\"object\": {\"code\": \"0201040133\",\"oid\": \"0000001\",\"erroid\": \"0\",\"msg\": \"测试成功\"}}}";
        return result;
    public String test(@RequestBody MDMData mdmData, HttpServletRequest request){
        System.out.println("");
        return "";
    }
}

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
package com.vci.ubcs.code.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import org.springframework.web.servlet.view.RedirectView;

@RestController
@RequestMapping("/redirectController")
public class RedirectViewController {
    @GetMapping("/redirectWithUsingRedirectView")
    public RedirectView redirectWithUsingRedirectView(RedirectAttributes redirectAttributes){
        redirectAttributes.addAttribute("flashAttribute","redirectWithUsingRedirectView");
        redirectAttributes.addAttribute("attribute","redirectWithUsingRedirectView");
        return new RedirectView("redirectedUrl");
    }
}

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
package com.vci.ubcs.code.service;

import com.vci.ubcs.code.vo.webserviceModel.mdm.MDMParamData;
import com.vci.ubcs.code.vo.webserviceModel.mdm.MdmResultData;

import javax.servlet.http.HttpServletRequest;

public interface CodeMdmInfaceI {

    public void setThreadLocal(ThreadLocal<HttpServletRequest> threadLocal);
    /**
     * ä¸Žmdm集成通用接口
     * @param mdmParamData
     * @param classifyCode
     * @return
     */
    public MdmResultData syncDataForMDM(MDMParamData mdmParamData, String library,String classifyCode) ;
}

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,808 @@
package com.vci.ubcs.code.service.impl;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.constant.MdmDuckingConstant;
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
import com.vci.ubcs.code.entity.CodeClassify;
import com.vci.ubcs.code.entity.DockingLog;
import com.vci.ubcs.code.entity.DockingSystemConfig;
import com.vci.ubcs.code.enumpack.CodeDefaultLC;
import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
import com.vci.ubcs.code.enumpack.SysIntegrationDataFlowTypeEnum;
import com.vci.ubcs.code.enumpack.sysIntegrationPushTypeEnum;
import com.vci.ubcs.code.mapper.CommonsMapper;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.util.ClientBusinessObject;
import com.vci.ubcs.code.util.gennerAttrMapUtil;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.code.vo.webserviceModel.apply.ApplyDataVO;
import com.vci.ubcs.code.vo.webserviceModel.apply.ApplyDatasVO;
import com.vci.ubcs.code.vo.webserviceModel.apply.ClassfyVO;
import com.vci.ubcs.code.vo.webserviceModel.apply.ProppertyVO;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.*;
import com.vci.ubcs.code.vo.webserviceModel.mdm.MDMParamData;
import com.vci.ubcs.code.vo.webserviceModel.mdm.MdmResultData;
import com.vci.ubcs.code.vo.webserviceModel.person.EnumerableData;
import com.vci.ubcs.code.vo.webserviceModel.person.ResultMdMapping;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
import com.vci.ubcs.code.webService.config.AttributeMapConfig;
import com.vci.ubcs.code.webService.config.ClassifyConfig;
import com.vci.ubcs.code.webService.config.MDMInterFaceConfig;
import com.vci.ubcs.omd.feign.IBtmTypeClient;
import com.vci.ubcs.omd.vo.BtmTypeVO;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.Func;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import javax.jws.WebMethod;
import javax.servlet.http.HttpServletRequest;
import javax.xml.ws.WebServiceContext;
import javax.xml.ws.handler.MessageContext;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.MdmEngineConstant.CODE_SEC_LENGTH_FIELD;
import static com.vci.ubcs.code.constant.MdmEngineConstant.DEFAULT_SYNC_ATTR_LIST;
import static com.vci.ubcs.code.enumpack.CodeSecTypeEnum.CODE_SERIAL_SEC;

/***
 * ç»Ÿä¸€æŽ¥å£
 */
@Service
@Slf4j
public class CodeMdmInfaceImpl implements CodeMdmInfaceI {


    @Autowired(required = false)
    private AttributeMapConfig attributeMapConfig;

    /****
     * å…³äºŽè·ŸMDM集成配置
     */
    @Autowired(required = false)
    private MDMInterFaceConfig mdmInterFaceConfig;
    /**
     * ä¸»é¢˜åº“分类的服务
     */
    @Autowired(required = false)
    private ICodeClassifyService classifyService;
    /**
     * ä¸šåŠ¡ç±»åž‹çš„服务
     */
    @Autowired
    private IBtmTypeClient btmTypeClient;
    /**
     * é€šç”¨æŸ¥è¯¢
     */
    @Resource
    private CommonsMapper commonsMapper;

    /**
     * ä¸»æ•°æ®å¼•æ“Žçš„服务
     */
    @Resource
    private MdmEngineService engineService;

    /**
     * å¯†çº§çš„服务
     */
    @Resource
    private MdmIOService mdmIOService;

    @Resource
    private IDockingSystemConfigService dockingSystemConfigService;


    /***
     * é›†æˆæŽ¥å£æ—¥å¿—服务的配置
     */
    @Resource
    private IDockingLogeService dockingLogeService;

    @Resource
    private IPasswordFreeLoginService passwordFreeLoginService;
    /***
     * æ˜¯å¦æ ¡éªŒæŽ¥å£ç®¡ç†
     */
    @Value("${code.universalinterface.checkSystemConfig:true}")
    public boolean CODE_CHECKCONFIG;

    /**
     * è‡ªå®šä¹‰å¹¶å‘ForkJoinPool
     */
    private static final ForkJoinPool customForkJoinPool = new ForkJoinPool(Runtime.getRuntime().availableProcessors() - 1);

    private  static String separator="##VCI##";
    private  String errorid="0";
    private String msg="成功";
    private  String objerrorCode="0";
    private String objerrorMsg="成功";

    private final ThreadLocal<HttpServletRequest> threadLocal = new ThreadLocal<>();

    @Resource
    private WebServiceContext webServiceContext;
    @Override
    public void setThreadLocal(ThreadLocal<HttpServletRequest> requestThreadLocal){
        this.threadLocal.set(requestThreadLocal.get());
        requestThreadLocal.remove();
    }
    @WebMethod
    private HttpServletRequest getRequest() {
        //rest请求方式获取request
        HttpServletRequest request = this.threadLocal.get();
        if(Func.isEmpty(request)){
            try {
                // webservice请求方式获取HttpServletRequest对象
                request = (HttpServletRequest)webServiceContext.getMessageContext().get(MessageContext.SERVLET_REQUEST);
            }catch (Exception e){
                throw new ServiceException("获取httpServletRequest失败，原因:"+e.getMessage());
            }
        }else {
            this.threadLocal.remove();
        }
        return request;
    }
    @Override
    public MdmResultData syncDataForMDM(MDMParamData mdmParamData,String library,String classifyCode) {
        boolean isCodeOrGroupCode=false;
        MdmResultData mdmResultData=new MdmResultData();
        String systemCode=mdmParamData.getSystemCode();
        List<ResultMdMapping> resultMdMappingList=new ArrayList<>();
        String message="";
        AtomicBoolean success = new AtomicBoolean(true);
        List<Map<String,String>> masterDataList = new ArrayList<>();
        AtomicReference<ClassifyConfig> currentClassifyConfig = new AtomicReference<>(new ClassifyConfig());
        try {
            if (mdmParamData == null) {
                throw new Throwable("传入参数为null");
            }
            try {
                passwordFreeLoginService.pwdFreeLoginByBoolean(systemCode.toLowerCase(), this.getRequest());
            } catch (Throwable e) {
                throw new Throwable("用户鉴权失败");
            }
            List<ClassifyConfig> classifyConfigList=mdmInterFaceConfig.getClassifyconfigs();
            if(StringUtils.isNotBlank(library)&&StringUtils.isNotBlank(classifyCode)){
                String finalLibrary = library;
                classifyConfigList.stream().forEach(classifyConfig -> {
                    String  currentClassifyCode=classifyConfig.getClassCode();
                    String currentLibrary=classifyConfig.getLibrary();
                    if(finalLibrary.equals(currentLibrary)&&classifyCode.equals(currentClassifyCode)){
                        currentClassifyConfig.set(classifyConfig);
                    }
                });
            }else{
                Map<String,List<ClassifyConfig>> fieldClassifyConfigMap=new HashMap<>();
                classifyConfigList.stream().forEach(classifyConfig -> {
                    String sourceKey=classifyConfig.getSourceKey();//分类标识字段
                    //String sourceClassifyCode=classifyConfig.getSourceClassifyCode();//分类标识
                    List<ClassifyConfig> classifyConfigs = new ArrayList<>();
                    if(fieldClassifyConfigMap.containsKey(sourceKey)) {
                        List<ClassifyConfig> oldClassifyConfigs=    fieldClassifyConfigMap.get(sourceKey);
                        classifyConfigs.addAll(oldClassifyConfigs);
                    }
                    classifyConfigs.add(classifyConfig);
                    fieldClassifyConfigMap.put(sourceKey,classifyConfigs);
                });
                masterDataList.stream().forEach(masterData -> {
                        masterData.forEach((field, vaule) -> {
                            if (fieldClassifyConfigMap.containsKey(field)) {
                                vaule=StringUtils.isBlank(vaule) ? "" : vaule;
                                List<ClassifyConfig> classifyConfigs = fieldClassifyConfigMap.get(field);
                                Map<String, ClassifyConfig> classifyConfigMap = classifyConfigs.stream().filter(classify -> classify != null && StringUtils.isNotBlank(classify.getSourceClassifyCode())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getSourceClassifyCode(), t -> t));
                                if (classifyConfigMap.containsKey(vaule)) {
                                    currentClassifyConfig.set(classifyConfigMap.get(vaule));
                                }
                            }
                        });
                });
            }
            library= currentClassifyConfig.get().getLibrary();
            if (StringUtils.isBlank(library)) {
                success.set(false);
                log.info("与MDM集成配置缺少库节点信息,library->" + library);
                throw new Throwable("与MDM集成配置缺少库节点信息,library->" + library);
            }
            String classCode= currentClassifyConfig.get().getClassCode();
            ClassfyVO classfyVO = new ClassfyVO();
            classfyVO.setLibrary(library);
            classfyVO.setClassCode(classCode);
            CodeClassifyVO codeClassifyVO = this.getClassfy(classfyVO, library);
            log.info("end：分类查询完毕");
            //获取分类模板信息
            if (codeClassifyVO == null || StringUtils.isBlank(codeClassifyVO.getOid())) {
                success.set(false);
                throw new Throwable("根据配置分类的分类编号，未获取到分类信息");
            }
            CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
            if (templateVO == null || StringUtils.isBlank(templateVO.getOid())) {
                success.set(false);
                throw new Throwable("根据传输的分类，未获取MDM系统中对应模板");
            }
            if(CODE_CHECKCONFIG) {
                //校验是否配置
                DockingSystemConfig dockingSystemConfig=null;
                dockingSystemConfig=checkIspass(systemCode, SysIntegrationDataFlowTypeEnum.ACCEPT.getValue(), sysIntegrationPushTypeEnum.ACCPET_APPCODE.getValue(),codeClassifyVO.getOid());
                if(dockingSystemConfig==null||StringUtils.isBlank(dockingSystemConfig.getOid())){
                    throw new Throwable("系统标识为【"+ systemCode +"】，集成分类为【"+codeClassifyVO.getName()+"】以上分类，"+sysIntegrationPushTypeEnum.ACCPET_APPCODE.getText()+"接口配置已停用或者未配置，请联系编码管理员！");
                }
                isCodeOrGroupCode="true".equals(dockingSystemConfig.getIsGroupCodeFlag())?true:false;
            }
            List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) &&
                ((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
            ).collect(Collectors.toList());
            R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
            if (!r.isSuccess()) {
                throw new Throwable(r.getMsg());
            }
            BtmTypeVO btmTypeVO = r.getData();
            if (btmTypeVO == null) {
                throw new Throwable("根据业务类型未查询到业务类型对象！");
            }
            String tableName = btmTypeVO.getTableName();
            if (com.alibaba.nacos.common.utils.StringUtils.isBlank(tableName)) {
                throw new Throwable("根据业务类型未查询到业务类型相关联的表");
            }
            masterDataList = mdmParamData.getMasterData();
            List<String> codeList = new ArrayList<>();
            List<ApplyDataVO> applyDataVOList = new ArrayList<>();
            List<ApplyDataVO> deleteDataVOList = new ArrayList<>();
            List<String> fields = Func.toStrList(currentClassifyConfig.get().getEnumFields());
            masterDataList.stream().forEach(masterData -> {
                ApplyDataVO object = new ApplyDataVO();
                List<ProppertyVO> proppertyVOList = new ArrayList<>();
                masterData.forEach((field, vaule) -> {
                    /***
                     * æ ¹æ®é…ç½®æ–‡ä»¶èŽ·å–枚举值
                     */
                    if(fields.contains(field)){//如果是枚举，则需要转换枚举值
                        String enumFiled = masterData.get(field);
                        EnumerableData enumerableData = JSONObject.toJavaObject(JSONObject.parseObject(enumFiled), EnumerableData.class);
                        String enumCode = enumerableData.getCode();
                        //String enumCodeValue=enumerableData.getName();
                        ProppertyVO proppertyVO = new ProppertyVO();
                        proppertyVO.setKey(field);
                        proppertyVO.setValue(enumCode);
                        proppertyVOList.add(proppertyVO);
                    }else {
                        ProppertyVO proppertyVO = new ProppertyVO();
                        proppertyVO.setKey(field);
                        proppertyVO.setValue(vaule);
                        proppertyVOList.add(proppertyVO);
                    }

                });

                Map<String,String> fixedFieldMap = currentClassifyConfig.get().getFixedFieldMap();
                if(fixedFieldMap.containsKey("creator")){
                    String fixedField=fixedFieldMap.getOrDefault("creator","");
                    object.setCreator(masterData.getOrDefault(fixedField,"").toString());//创建者
                }
                if(fixedFieldMap.containsKey("modifier")) {
                    String fixedField=fixedFieldMap.getOrDefault("modifier","");
                    object.setEditor(masterData.getOrDefault(fixedField, "").toString());//修改者
                }
                if(fixedFieldMap.containsKey("id")) {
                    String fixedField=fixedFieldMap.getOrDefault("id","");
                    object.setId(masterData.getOrDefault(fixedField, "").toString());//主键
                }
                object.setStatus(CodeDefaultLC.RELEASED.getValue());//状态则需要判断
                String dr="0";
                if(fixedFieldMap.containsKey("dr")) {
                    String fixedField=fixedFieldMap.getOrDefault("dr","");
                    dr = masterData.getOrDefault(fixedField, "").toString();
                }
                object.setCode(masterData.getOrDefault(currentClassifyConfig.get().getSourceCodeKey(),"").toString());//编码
                object.setProp(proppertyVOList);

                if (dr.equals(1)) {
                    //操作类型
                    object.setOperate("delete");
                    deleteDataVOList.add(object);
                } else {
                    //String worker_category=personMasterData.getWorker_category();
                    object.setOperate("create");
                    applyDataVOList.add(object);
                }
                codeList.add(object.getCode());

            });
            String targetCodeKey=currentClassifyConfig.get().getTargetCodeKey();
            StringBuffer sb = new StringBuffer();
            sb.append(" select * from ");
            sb.append(tableName);
            sb.append(" where 1=1 ");
            sb.append(" and lastr=1 and lastv=1");
            sb.append(" and "+targetCodeKey+" in (");
            sb.append(VciBaseUtil.toInSql(codeList.toArray(new String[0])));
            sb.append(")");
            List<Map<String, String>> dataMapList = commonsMapper.queryByOnlySqlForMap(sb.toString());
            DefaultAttrAssimtUtil.mapToLowerCase(dataMapList, true);
            List<ClientBusinessObject> cboList = ChangeMapTOClientBusinessObjects(dataMapList);
            ApplyDatasVO applyDatasVO = new ApplyDatasVO();
            ApplyDatasVO editDatasVO = new ApplyDatasVO();
            if (!CollectionUtils.isEmpty(cboList)) {
                //根据MDM编码去判断数据是否重复.
                Map<String, ClientBusinessObject> oldpplyDataVOMap = cboList.stream().filter(data -> data != null && StringUtils.isNotBlank(data.getAttributeValue(targetCodeKey))).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue(targetCodeKey).toLowerCase(Locale.ROOT), t -> t));
                //数据库不存在的
                List<ApplyDataVO> applyApplyDataVOList = applyDataVOList.stream().filter(cbo -> {
                    String code = cbo.getCode();
                    return !oldpplyDataVOMap.containsKey(code);
                }).collect(Collectors.toList());
                applyDatasVO.setObject(applyApplyDataVOList);
                //数据库存在的
                List<ApplyDataVO> editApplyDataVOList = applyDataVOList.stream().filter(cbo -> {
                    String code = cbo.getCode();
                    if (oldpplyDataVOMap.containsKey(code)) {
                        cbo.setOperate("update");
                    }
                    return oldpplyDataVOMap.containsKey(code);
                }).collect(Collectors.toList());
                editApplyDataVOList.addAll(deleteDataVOList);
                editDatasVO.setObject(editApplyDataVOList);
            } else {
                applyDatasVO.setObject(applyDataVOList);
            }

            LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
            if (editDatasVO.getObject() != null && editDatasVO.getObject().size() > 0) {
                DataObjectVO dataObjectVO = new DataObjectVO();
                this.getConfigDatas(systemCode, library, editDatasVO, attrVOS, dataObjectVO);
                log.info("start：修改数据执行完毕");
                //boolean personApplyGroupCode = personAndDeptConfig.isPersonApplyGroupCode();
                mdmIOService.batchSyncEditDatas(codeClassifyVO, dataObjectVO, resultDataObjectDetailDOs, isCodeOrGroupCode);
                log.info("end：修改数据执行完毕");
            }
            if (applyDatasVO.getObject() != null && applyDatasVO.getObject().size() > 0) {
                DataObjectVO dataObjectVO = new DataObjectVO();
                this.getConfigDatas(systemCode, library, applyDatasVO, attrVOS, dataObjectVO);

                CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
                CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
                if (ruleVO == null || "".equals(ruleVO.getOid())) {
                    throw new Throwable("编码规则");
                }
                List<XMLResultDataObjectDetailDO> xDOs = new CopyOnWriteArrayList<>();
                final List<RowDatas> rowDatas = dataObjectVO.getRowData();
                boolean finalIsCodeOrGroupCode = isCodeOrGroupCode;
                rowDatas.parallelStream().forEach(rowData -> {
                    String mesg = "";
                    try {
                        CodeOrderDTO orderDTO = new CodeOrderDTO();
                        List<CodeOrderSecDTO> codeOrderSecDTOList = new ArrayList<>();
                        orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
                        orderDTO.setTemplateOid(templateVO.getOid());
                        orderDTO.setCreator(rowData.getCreator());
                        orderDTO.setLastModifier(rowData.getEditor());
                        orderDTO.setLcStatus(rowData.getStatus());
                        if (!CollectionUtils.isEmpty(ruleVO.getSecVOList())) {//算规则
                            boolean usedFlag=currentClassifyConfig.get().isUsedFlag();//是否依据编码规则
                            String codeFilter=currentClassifyConfig.get().getCodeFilter();//根据编码值截取
                            if(usedFlag){//如果依据MDM编码为编码系统编码的话，则根据认为是可变码段
                                if(ruleVO.getSecVOList().size()==1) {
                                    ruleVO.getSecVOList().stream().forEach(codeBasicSecVO -> {
                                        if (codeBasicSecVO.getSecType().equals("codevariablesec")) {//规则之定义为可变码段存储主数据传递过来的数据
                                            CodeOrderSecDTO CodeOrderSecDTO = new CodeOrderSecDTO();
                                            CodeOrderSecDTO.setSecOid(codeBasicSecVO.getOid());
                                            CodeOrderSecDTO.setSecValue(rowData.getCode());
                                            codeOrderSecDTOList.add(CodeOrderSecDTO);
                                        }
                                    });
                                }else{
                                    mesg="根据配置编码依据集成系统:["+systemCode+"]的数据编码为依据，编码规则应为可变码段";
                                    new Throwable("根据配置编码依据集成系统:["+systemCode+"]的数据编码为依据，编码规则应为可变码段");
                                }
                            }else {//如果不依据MDM编码为编码系统编码的话，则根据配置生成编码规则
                                String[] secValues = currentClassifyConfig.get().getSecValueFilter().split("#");
                                final int[] index = {0};
                                try {
                                    ruleVO.getSecVOList().stream().forEach(codeBasicSecVO -> {
                                        if (!CODE_SERIAL_SEC.getValue().equals(codeBasicSecVO.getSecType())) {
                                            CodeOrderSecDTO CodeOrderSecDTO = new CodeOrderSecDTO();
                                            CodeOrderSecDTO.setSecOid(codeBasicSecVO.getOid());
                                            CodeOrderSecDTO.setSecValue(secValues[index[0]]);
                                            codeOrderSecDTOList.add(CodeOrderSecDTO);
                                            index[0]++;
                                        }
                                    });
                                }catch (Throwable e){
                                    mesg="计算码段码值出现异常:"+e.getMessage();
                                    new Throwable("计算码段码值出现异常:"+e.getMessage());
                                }
                            }

                        }
                        if(CollectionUtils.isEmpty(codeOrderSecDTOList)){
                            throw  new Exception(mesg);
                        }
                        orderDTO.setCodeRuleOid(ruleVO.getOid());
                        orderDTO.setSecDTOList(codeOrderSecDTOList);//存储编码
                        orderDTO.setData(rowData.getFiledValue());
                        String code = engineService.addSaveCodeNotauthUser(orderDTO, false);
                        if (StringUtils.isNotBlank(code)) {
                            StringBuffer sqlsb = new StringBuffer();
                            sqlsb.append(" select * from ");
                            sqlsb.append(tableName);
                            sqlsb.append(" where 1=1 ");
                            sqlsb.append(" and lastr=1 and lastv=1");
                            sqlsb.append(" and id in (");
                            sqlsb.append(VciBaseUtil.toInSql(code));
                            sqlsb.append(")");
                            List<Map<String, String>> newDataMapList = commonsMapper.queryByOnlySqlForMap(sqlsb.toString());
                            if (!CollectionUtils.isEmpty(newDataMapList)) {
                                String oid = StringUtils.isBlank(newDataMapList.get(0).get("OID")) ? "" : newDataMapList.get(0).get("OID");
                                List<String> oidList = new ArrayList<>();
                                oidList.add(oid);
                                //如果有申请就去调用申请集团码
                                if (finalIsCodeOrGroupCode) {
                                    mdmIOService.sendApplyGroupcode(oidList, templateVO.getBtmTypeId(), sysIntegrationPushTypeEnum.ACCPET_APPCODE.getValue());
                                    success.set(true);
                                    mesg = "数据保存成功，等待申请集团码";
                                }
                            }
                        }
                    } catch (Exception e) {
                        mesg="集成系统：【"+systemCode+"】申请编码失败:" + e.getMessage();
                        mesg = e.getMessage();
                        e.printStackTrace();
                        throw new ServiceException(e.getMessage());
                    } finally {
                        XMLResultDataObjectDetailDO x = new XMLResultDataObjectDetailDO();
                        x.setId(rowData.getOid());
                        x.setCode(rowData.getCode());
                        x.setMsg(mesg);
                        x.setErrorid("1");
                        xDOs.add(x);
                    }
                });
                resultDataObjectDetailDOs.addAll(xDOs);
                boolean finalSuccess1 = success.get();
                String finalMessage1 = message;
                // é™åˆ¶çº¿ç¨‹å¹¶è¡Œæ•°é‡
                customForkJoinPool.submit(() -> {
                    resultDataObjectDetailDOs.stream().forEach(resultDataObjectDetailDO -> {
                        ResultMdMapping resultMdMapping = new ResultMdMapping();
                        resultMdMapping.setBusiDataId(resultDataObjectDetailDO.getId());
                        resultMdMapping.setSuccess(finalSuccess1);
                        resultMdMapping.setEntityCode(" ");
                        resultMdMapping.setMdmCode(resultDataObjectDetailDO.getCode());
                        resultMdMapping.setMessage(finalMessage1);
                        resultMdMapping.setSubMdMappings(null);
                        resultMdMappingList.add(resultMdMapping);
                    });
                }).join();
                log.info("end：申请获取完毕");
            }
        } catch (Throwable e) {
            success.set(false);
            message = "集成系统：【"+systemCode+"】执行集成失败:" + e.getMessage();
            msg ="集成系统：【"+systemCode+"】执行集成失败" + e.getMessage();
            //组织返回结果
            boolean finalSuccess = success.get();
            String finalMessage = message;
            masterDataList.stream().forEach(masterData -> {
                Map<String, String> dataMap = VciBaseUtil.objectToMapString(masterData);
                ResultMdMapping resultMdMapping = new ResultMdMapping();
                resultMdMapping.setBusiDataId(dataMap.getOrDefault("id",""));
                resultMdMapping.setSuccess(finalSuccess);
                resultMdMapping.setEntityCode(" ");
                resultMdMapping.setMdmCode(dataMap.getOrDefault(currentClassifyConfig.get(),""));
                resultMdMapping.setMessage(finalMessage);
                resultMdMapping.setSubMdMappings(null);
            });
        } finally {
            mdmResultData.setMessage(message);
            mdmResultData.setSuccess(success.get());
            mdmResultData.setMdMappings(resultMdMappingList);
            //Object object = JSONObject.toJSON(resultOrgData);
        }
        String resultStr = JSONObject.toJSONString(mdmResultData);
        String data = JSONObject.toJSONString(mdmParamData);
        try {
            //记录日志
            this.saveLogs(systemCode, systemCode, data, resultStr, success.get(), msg, "syncDataForMDM");
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return mdmResultData;
    }
    private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
        List<ClientBusinessObject> clientBusinessObjectList=new ArrayList<>();
        DefaultAttrAssimtUtil.mapToLowerCase(oldDataMap,true);
        final BladeUser user = AuthUtil.getUser();
        oldDataMap.stream().forEach(dataMap->{
            ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
            DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject,false,user);
            for (String key:dataMap.keySet()){
                Object value= dataMap.getOrDefault(key,"");
                clientBusinessObject.setAttributeValue(key.toLowerCase(Locale.ROOT),value==null?"":value.toString());
            }
            clientBusinessObjectList.add(clientBusinessObject);
        });
        return clientBusinessObjectList;
    }
    /***
     * æŸ¥è¯¢æ ¡éªŒåˆ†ç±»ä¿¡æ¯
     * @param classfyVO
     */
    private  CodeClassifyVO getClassfy(ClassfyVO classfyVO,String libray) throws Throwable{
        CodeClassifyVO classifyVO = new CodeClassifyVO();
        try {
            String classCode = classfyVO.getClassCode();
            String className = classfyVO.getFullclsfNamePath();
            //根据分类代号查询分类信息
            if (StringUtils.isNotBlank(classfyVO.getClassCode())) {
                Map<String, String> conditionMap = new HashMap<>();
                List<CodeClassify> codeClassifyList = classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getId, classCode));
                final CodeClassify[] newCodeClassify = {new CodeClassify()};
                if (!CollectionUtils.isEmpty(codeClassifyList)) {
                    codeClassifyList.stream().forEach(codeClassify -> {
                        CodeClassifyVO codeClassifyVO=  classifyService.getTopClassifyVO(codeClassify.getOid());
                        if(codeClassifyVO.getId().toUpperCase(Locale.ROOT).equals(libray.toUpperCase(Locale.ROOT))){
                            newCodeClassify[0] =codeClassify;
                        }
                    });
                    classifyVO = new CodeClassifyVO();
                    BeanUtilForVCI.copyPropertiesIgnoreCase(newCodeClassify[0], classifyVO);
                    //将DTO转换为DO
                    if(StringUtils.isBlank(classifyVO.getOid())){
                        throw new  Throwable("申请编码的分类：【"+classCode+"】不属于库节点【"+libray+"】，请检查参数分类节点/库节点信息是否匹配");
                    }
                }else{
                    throw new  Throwable("根据分类代号未查询到相应的分类信息");
                }
            } else {
                classifyVO = classifyService.getObjectByClsfNamePath(className.replace(separator, "/"));
                if(StringUtils.isBlank(classifyVO.getOid())){
                    throw new  Throwable("根据分类名称路径未查询到相应的分类信息");
                }
            }
        }catch (Throwable e){
            objerrorCode="100";
            throw     new  Throwable("获取分类信息失败:"+e.getMessage());
        }
        return classifyVO;
    }
    public void getConfigDatas(String systemId,String libray, ApplyDatasVO 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<>();
        log.info("开始读取系统配置文件 start");
        Map<String, String> stringStringMap=attributeMapConfig.getSystem_attrmap();
        log.info("集成系统属性映射配置文件条目数-》"+stringStringMap.size());
        if(!CollectionUtils.isEmpty(stringStringMap)) {
            List<LibraryClsfDO> libraryClsfDOList=new ArrayList<>();
            try {
                log.info("info：需要读取配置文件");
                LibraryDO libraryDO = gennerAttrMapUtil.getNewInstance().gennerAttrMapBySystem(systemId, stringStringMap);
                libraryClsfDOList = libraryDO.getClsf();
            } catch (Throwable e) {
                objerrorCode = "1";
                e.printStackTrace();
                throw new Throwable("集成系统标识为：【" + systemId + "】，分类库为:【" + libray + "】的集成属性配置文件读取失败");
            }
            // String path = stringStringMap.get(systemId);
            // å¿½ç•¥key大小写，获取配置的映射文件路径
            String path = VciBaseUtil.getMapStrValueIgnoreCase(stringStringMap,systemId);
            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 + "从配置文件中找对应属性映射配置");
                if (libPropMaps.containsKey(libray.toUpperCase(Locale.ROOT))) {
                    log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息");
                    List<ClsfAttrMappingDO> clsfAttrMappingDOList = libPropMaps.get(libray.toUpperCase(Locale.ROOT));
                    propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2));
                    log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息,属性映射条目数+" + clsfAttrMappingDOList.size());
                } else {
                    objerrorCode = "1";
                    throw new Throwable("根据系统标识【" + systemId + "】找到对应的配置文件:【" + path + "】，但未获取到对应的库【" + libray + "】属性映射信息配置");
                }
            }else{
                objerrorCode = "1";
                throw new Throwable("根据系统标识【" + systemId + "】找到对应的配置文件:【" + path + "】，但未获取到对应的库【" + libray + "】属性映射信息配置");
            }
        }else{
            objerrorCode = "1";
            throw new Throwable("未获取到集成属性映射系统配置信息");
        }
        log.info("根据参数：libray：-》"+libray+"从配置文件中找对应属性映射配置 end ");
        LinkedList<String> rowNameList=new LinkedList<>();
        LinkedHashMap<String,Integer> filedIndexMap=new LinkedHashMap<>();
        //根据分类模板组织数据
        final int[] index = {0};
        try {
            //除去默认的属性.还有只有具有分类注入的才过滤出来
            codeClassifyTemplateAttrVOList = codeClassifyTemplateAttrVOList.stream().filter(
                s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) &&
                    ((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
            ).collect(Collectors.toList());
            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<ApplyDataVO> applyDataVOList=new ArrayList<>();

            if(!CollectionUtils.isEmpty(applyDatasVO.getObject())){
                applyDataVOList=applyDatasVO.getObject();
            }
            //Map<String, List<ProppertyVO>> dataPropMap = applyDataVOList.stream().collect(Collectors.toMap(ApplyDataVO::getId, ApplyDataVO::getProp, (key1, key2) -> key2));
            final int[] rowIndex = {0};
            applyDataVOList.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(applyDataVO.getOperate());
                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("组织数据映射值失败");
        }
    }
    /*private void codeValueList(List<CodeBasicSecVO> secVOList,String codeseclengthfield ){
        if(StringUtils.isNotBlank(codeseclengthfield)) {

            String[] secLengths = codeseclengthfield.split("#");
            for (int i = 0; i < secLengths.length; i++) {
                CodeBasicSecVO secVO = secVOList.get(i);
                String thisSecValue = "";
                    *//*if(i == 0){
                        thisSecValue = seclenghStr.contains("#")?code.substring(0,VciBaseUtil.getInt(secLengths[i])):code;
                    } else if(i == secLengths.length-1){
                        //最后
                        thisSecValue =  seclenghStr.contains("#")?code.substring(VciBaseUtil.getInt(secLengths[i-1]),code.length()):code;
                    }else {*//*
                int start = 0;
                for (int j = 0; j < i; j++) {
                    start += VciBaseUtil.getInt(secLengths[j]);
                }
                thisSecValue = code.substring(start, start + VciBaseUtil.getInt(secLengths[i]));
                //    }
                if (VciBaseUtil.getBoolean(secVO.getSerialDependFlag())) {
                    serialUnitList.add(thisSecValue);
                    serialSecOidIndexMap.put(secVO.getOid(), i);
                }
                if (CODE_SERIAL_SEC.getValue().equalsIgnoreCase(secVO.getSecType())) {
                    serialValueMap.put(secVO.getOid(), thisSecValue);
                }
                codeValueList.add(thisSecValue);
            }
        }else{

        }
    }*/
    /***
     * æ ¡éªŒæ˜¯å¦åšäº†é…ç½®
     * @param systemId,系统标识
     * @param type:接口类型
     * @param operationType:接口操作类型
     * @return
     */
    private DockingSystemConfig  checkIspass(String systemId,String type,String operationType,String classOid){
        log.info("systemId："+systemId+",type:"+SysIntegrationDataFlowTypeEnum.getTextByValue(type)+",operationType:"+sysIntegrationPushTypeEnum.getTextByValue(operationType)+",classOid:"+classOid);
        //CodeClassifyVO codeClassifyVO= classifyService.getObjectByOid(classOid);
        List<CodeClassify> codeClassifyList=  classifyService.selectAllLevelParentByOid(classOid);
        List<String> classifyOids=new ArrayList<>();
        if(!CollectionUtils.isEmpty(codeClassifyList)) {
            classifyOids = codeClassifyList.stream().map(CodeClassify::getOid).collect(Collectors.toList());
        }else{
            return null;
        }
        //classOid=codeClassifyVO.getOid();
        //根据类型去查询需要集成的分类或者数据
        LambdaQueryWrapper<DockingSystemConfig> queryWrapper = Wrappers.<DockingSystemConfig>lambdaQuery();
        queryWrapper.eq(DockingSystemConfig::getUsedFlag, MdmDuckingConstant.SEND_FLAG_TRUE);
        queryWrapper.eq(DockingSystemConfig::getSysBaseId,systemId);
        queryWrapper.eq(DockingSystemConfig::getDataFlowType,type);
        queryWrapper.eq(DockingSystemConfig::getPushType,operationType);
        if(StringUtils.isNotBlank(classOid)){
            queryWrapper.in(DockingSystemConfig::getClassifyOid,classifyOids);
        }
        List<DockingSystemConfig> dockingSystemConfigList=new ArrayList<>();
        dockingSystemConfigList=    dockingSystemConfigList=dockingSystemConfigService.list(queryWrapper);
        if(!CollectionUtils.isEmpty(dockingSystemConfigList)){
            return    dockingSystemConfigList.get(0);
        }else{
            return null;
        }
    }
    /***
     * è®°å½•æ—¥å¿—信息
     * @param systemId
     * @param parmaData
     * @param result
     * @return
     */
    private  void saveLogs(String systemId,String systemName,String parmaData, String result,boolean isSucess,String msg,String operation){
        //记录日志信息
        DockingLog dockingLoge=new DockingLog();
        //String oid=redisService.getUUIDEveryDay();
        dockingLoge.setSystemCode(StringUtils.isBlank(systemId)?"-":systemId);//设置系统标识
        dockingLoge.setSystemName(StringUtils.isBlank(systemName)?"-":systemName);
        dockingLoge.setMsg(msg);//日志消息
        dockingLoge.setClassifyId("-");//分类编号
        dockingLoge.setClassifyName("-");//分类名称
        dockingLoge.setClassifyOid("-");//分类主键
        dockingLoge.setUniqueCode("-");//唯一标识
        dockingLoge.setSystemOid("-");//系统标识
//        dockingLogeDO.setName(operation);
        //dockingLogeDO.setOid(oid);//日志主键
        dockingLoge.setParamString(parmaData);//参数信息
        dockingLoge.setReturnString(result);//返回信息
        dockingLoge.setType(operation);//日志操作类型
        dockingLoge.setCreateTime(new Date());
        if(isSucess) {
            dockingLoge.setInterfaceStatus("true");//接口集成状态
        }else{
            dockingLoge.setInterfaceStatus("false");//接口集成状态
        }
        dockingLogeService.save(dockingLoge);
        log.info("集成推送数据,systemId:"+systemId+",systemname:"+systemName+",operation:"+operation+",param:"+parmaData);
    }
}

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

@@ -1214,7 +1214,7 @@
        log.info("查询分类的数据类型:->"+dataType);
        ResultClassifyVO resultClassifyVO =new ResultClassifyVO();
        List<ClassifyVO> classifyVOList=new ArrayList<>();
        com.vci.ubcs.code.vo.webserviceModel.classify.ResultData resultData=new com.vci.ubcs.code.vo.webserviceModel.classify.ResultData();
        ResultData resultData=new ResultData();
        try {
            if (StringUtils.isBlank(data)) {
                errorid = "101";

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/webService/config/ClassifyConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,65 @@
package com.vci.ubcs.code.webService.config;

import lombok.Data;
import java.util.Map;
/***
 * åˆ†ç±»å¯¹è±¡
 */
@Data
public class ClassifyConfig {
    /***
     * ç æ®µç å€¼
     */
    private String secValueFilter;
    /***
     * ç¼–码截取依据
     */
    private String codeFilter;
    /***
     * mdm分类标识字段
     */
    private String sourceKey;
    /***
     * mdm编码标识字段
     */
    private String sourceCodeKey;
    /**
     * å­˜å‚¨MDM编码的字段
     */
    private String targetCodeKey;
    /***
     * åº“节点
     */
    private String library;
    /**
     * MDM接口分类传递的标识
     */
    private String sourceClassifyCode;
    /**
     * ç¼–码应该存入的地方编号
     */
    private String classCode;
    /**
     * åˆ†ç±»è·¯å¾„.
     */
    private String classNamePath;
    /***
     * ä¸šåŠ¡ç±»åž‹åç§°
     */
    private String btmName;

    /**
     * å›ºå®šå­—段
     */
    private Map<String,String> fixedFieldMap;

    /***
     * æ˜¯å¦ç”¨äºŽMDM传递过来的编码
     */
    private boolean usedFlag;

    /***
     * æŽ¥å£æžšä¸¾å€¼å­—段
     */
    private String enumFields;
}

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/webService/config/MDMInterFaceConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@
package com.vci.ubcs.code.webService.config;


import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/***
 * ä¸ŽMDM系统分发集成配置
 */
@ConfigurationProperties(prefix="mdm.config")
@Component
@Data
public class MDMInterFaceConfig {
    /***
     * ç³»ç»Ÿåˆ†ç±»ç¼–号对称
     */
    private List<ClassifyConfig> classifyconfigs=new ArrayList<>();

}