From be30e17e3c7685a54f761bf3a03487308c939270 Mon Sep 17 00:00:00 2001
From: 田源 <tianyuan@vci-tech.com>
Date: 星期三, 05 三月 2025 18:05:11 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'

---
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java | 1134 +++++++++++++++++++++++++++++++++++++++++++++++------------
 1 files changed, 901 insertions(+), 233 deletions(-)

diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java
index 56b35b8..3b4964e 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java
@@ -3,11 +3,15 @@
 
 import com.alibaba.cloud.commons.lang.StringUtils;
 import com.alibaba.fastjson.JSONObject;
+import com.alibaba.nacos.shaded.com.google.protobuf.ServiceException;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 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.constant.MdmDuckingConstant;
+import com.vci.ubcs.code.dto.CodeOrderDTO;
+import com.vci.ubcs.code.dto.CodeOrderSecDTO;
 import com.vci.ubcs.code.dto.datapush.classify.JsonRootDataDTO;
 import com.vci.ubcs.code.dto.datapush.classify.NodeClassifyDTO;
 import com.vci.ubcs.code.dto.datapush.classify.NodeDataDTO;
@@ -20,80 +24,171 @@
 import com.vci.ubcs.code.dto.datapush.result.ResultNodeDataDTO;
 import com.vci.ubcs.code.dto.datapush.result.ResultNodeObjectDTO;
 import com.vci.ubcs.code.entity.*;
+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.mapper.CommonsMapper;
 import com.vci.ubcs.code.service.*;
+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.ProppertyVO;
+import com.vci.ubcs.code.vo.webserviceModel.apply.SectionVO;
+import com.vci.ubcs.code.vo.webserviceModel.attrmap.*;
+import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
+import com.vci.ubcs.code.webService.config.AttributeMapConfig;
+import com.vci.ubcs.omd.cache.EnumCache;
+import com.vci.ubcs.omd.feign.IBtmTypeClient;
+import com.vci.ubcs.omd.vo.BtmTypeVO;
+import com.vci.ubcs.starter.exception.VciBaseException;
+import com.vci.ubcs.starter.revision.model.BaseModel;
+import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
 import com.vci.ubcs.starter.util.HttpUtils;
 import com.vci.ubcs.code.util.WsErpClientUtil;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
 import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
 import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
+import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
 import com.vci.ubcs.starter.web.util.VciBaseUtil;
 import com.vci.ubcs.starter.web.util.WebUtil;
 import lombok.extern.slf4j.Slf4j;
-import org.springblade.core.redis.cache.BladeRedis;
+import org.apache.commons.collections4.map.CaseInsensitiveMap;
+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.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
 
 import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 import static com.vci.ubcs.code.constant.MdmDuckingConstant.*;
+import static com.vci.ubcs.code.constant.MdmEngineConstant.DEFAULT_SYNC_ATTR_LIST;
+import static com.vci.ubcs.code.enumpack.CodeSecTypeEnum.CODE_CLASSIFY_SEC;
 
 
 /*
  * 涓婚搴撻泦鎴愭湇鍔�
  * @author xiejun
  * @date 2023-06-19
-**/
+ **/
 
 @Service
 @Slf4j
 public class CodeDuckingSyncServiceImpl implements ICodeDuckingSyncService {
+
 	@Value("${dataSyncPush.dataParamName:xmlData}")
 	public String DATA_PARAM_NAME;
 	@Value("${dataSyncPush.dataId:itemid}")
 	private String itemId;
+	@Value("${erp.item.attrKey:xhdh}")
+	public String attrKey;
+	@Value("${erp.item.itemStatus:2}")
+	public String itemStatus;
+
+	@Value("${erp.item.systemId:ERP}")
+	public String systemId;
+	@Value("${erp.item.secName:鍥哄畾鐮佹}")
+	public String secName;
+	@Value("${erp.item.secValue:A}")
+	public String secValue;
+
+	@Value("${erp.item.btmName:XHDH}")
+	public String btmName;
+
+	@Value("${erp.item.bearer:bearer: Bearer 7fc32939-0a59-da71-a6e6-6b0d37b53e8a}")
+	private String ERPXHDHAUTH;
+
+	@Value("${erp.item.url:http://127.0.0.1/api/pp/pp/ext/extend/v1.0}")
+	private String ERPXHDHURL;
+
+	@Value("${erp.item.tenant:10000}")
+	private String ERPXHDHTENANT;
+
+	/**
+	 * 涓氬姟绫诲瀷鐨勬湇鍔�
+	 */
+	@Autowired
+	private IBtmTypeClient btmTypeClient;
+
+	/**
+	 * 閫氱敤鏌ヨ
+	 */
 	@Resource
-	private  MdmEngineService  mdmEngineServiceI;
+	private CommonsMapper commonsMapper;
+
+	@Resource
+	private MdmEngineService mdmEngineServiceI;
+
+	/**
+	 * 鎵归噺澶勭悊鐨勬湇鍔�
+	 */
+	@Resource
+	private MdmIOService mdmIOService;
+
+	@Resource
+	private IPasswordFreeLoginService passwordFreeLoginService;
 
 	@Resource
 	private IDockingLogeService dockingLogeService;
+
 	@Resource
 	private IDockingDataService dockingDataService;
+
 	@Resource
 	private IDockingTaskService dockingTaskService;
+
 	@Resource
 	private IDockingSystemConfigService dockingSystemConfigService;
+
 	@Resource
 	private ICodeClassifyService codeClassifyService;
+
+	@Autowired
+	private ICodeClassifyValueService codeClassifyValueService;
+
+	@Autowired(required = false)
+	private AttributeMapConfig attributeMapConfig;
+
 	/***
 	 * resdis缂撳瓨鏈嶅姟
 	 */
-	@Resource
-	private BladeRedis bladeRedis;
+	//@Resource
+	//private BladeRedis bladeRedis;
+
 	@Resource
 	private IDockingSysIntParamService dockingSysIntParamService;
+
 	@Resource
 	private IDockingSysIntHeaderService dockingSysIntHeaderService;
 
+	//@Autowired(required = false)
+	//private MdmSearchItemCodeProvider mdmSearchItemCodeProvider;
 
+	@Resource
+	private ICodeAllCodeService codeAllCodeService;
 
 	@Override
 	public void DockingDataSyncScheduing() {
-
 		// insertCache2();
 		initPushDataTaks(1);
 		sendpushDataForService();
-
 	}
 
 	/***
@@ -113,169 +208,704 @@
 	@Transactional(rollbackFor = Throwable.class)
 	@Override
 	public R sendData(String oids) {
-		VciBaseUtil.alertNotNull(oids,"绯荤粺闆嗘垚鍩虹淇℃伅鏁版嵁瀵硅薄",oids,"绯荤粺闆嗘垚鍩虹淇℃伅鐨勪富閿�");
-		List<String> dockingTaskOidList=new ArrayList<>();
-		dockingTaskOidList= VciBaseUtil.str2List(oids);
-		List<DockingTask> newDockingTasks= this.dockingTaskService.listByIds(dockingTaskOidList);
-		Map<String,List<DockingTask>> typeDockingTaskMap=new HashMap<>();
-		newDockingTasks.stream().forEach(newDockingTaskDO->{
-			String btmId=newDockingTaskDO.getBtmId();
-			if(btmId.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
-				List<DockingTask> dockingTaskList= typeDockingTaskMap.get(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
-				if(CollectionUtils.isEmpty(dockingTaskList)){
-					dockingTaskList=new ArrayList<>();
+		VciBaseUtil.alertNotNull(oids, "绯荤粺闆嗘垚鍩虹淇℃伅鏁版嵁瀵硅薄", oids, "绯荤粺闆嗘垚鍩虹淇℃伅鐨勪富閿�");
+		List<String> dockingTaskOidList = new ArrayList<>();
+		dockingTaskOidList = VciBaseUtil.str2List(oids);
+		List<DockingTask> newDockingTasks = this.dockingTaskService.listByIds(dockingTaskOidList);
+		Map<String, List<DockingTask>> typeDockingTaskMap = new HashMap<>();
+		newDockingTasks.stream().forEach(newDockingTaskDO -> {
+			String btmId = newDockingTaskDO.getBtmId();
+			if (btmId.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))) {
+				List<DockingTask> dockingTaskList = typeDockingTaskMap.get(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
+				if (CollectionUtils.isEmpty(dockingTaskList)) {
+					dockingTaskList = new ArrayList<>();
 				}
 				dockingTaskList.add(newDockingTaskDO);
-				typeDockingTaskMap.put(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT),dockingTaskList);
-			}else{
-				List<DockingTask> dockingTaskDOList= typeDockingTaskMap.get("data");
-				if(CollectionUtils.isEmpty(dockingTaskDOList)){
-					dockingTaskDOList=new ArrayList<>();
+				typeDockingTaskMap.put(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT), dockingTaskList);
+			} else {
+				List<DockingTask> dockingTaskDOList = typeDockingTaskMap.get("data");
+				if (CollectionUtils.isEmpty(dockingTaskDOList)) {
+					dockingTaskDOList = new ArrayList<>();
 				}
 				dockingTaskDOList.add(newDockingTaskDO);
-				typeDockingTaskMap.put("data",dockingTaskDOList);
+				typeDockingTaskMap.put("data", dockingTaskDOList);
 			}
 		});
-		typeDockingTaskMap.keySet().forEach(type->{
-			List<DockingTask> DockingTaskList=typeDockingTaskMap.get(type);
-			if(!CollectionUtils.isEmpty(DockingTaskList)){
-				if(type.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
+		typeDockingTaskMap.keySet().forEach(type -> {
+			List<DockingTask> DockingTaskList = typeDockingTaskMap.get(type);
+			if (!CollectionUtils.isEmpty(DockingTaskList)) {
+				if (type.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))) {
 					this.sendpushClsfForService(DockingTaskList);
-				}else{
+				} else {
 					this.sendpushDataForService(DockingTaskList);
 				}
 			}
 		});
-		return  R.success("鎵嬪姩鎺ㄩ�佸畬鎴�,璇锋牳瀵规槸鍚︽帹閫佹垚鍔�");
+		return R.success("鎵嬪姩鎺ㄩ�佸畬鎴�,璇锋牳瀵规槸鍚︽帹閫佹垚鍔�");
 	}
 
+	private SearchItemDataVO initData(String status, String itemCode, String mmCode) {
+		SearchItemDataVO searchItemDataVO = new SearchItemDataVO();
+		searchItemDataVO.setLastchangedon(new Date());
+		searchItemDataVO.setLastchangedby("19831133");
+		searchItemDataVO.setCreatby("19831133");
+		searchItemDataVO.setCreatedon(new Date());
+		searchItemDataVO.setIsenabled(status);
+		searchItemDataVO.setMaterialcode("XMDH0001");
+		searchItemDataVO.setStatus("1");
+		searchItemDataVO.setProjectcode("3333");
+		searchItemDataVO.setProjectitem(itemCode);
+		searchItemDataVO.setMmodelcode(mmCode);
+
+		return searchItemDataVO;
+	}
+
+	public HttpServletRequest getRequest() {
+		HttpServletRequest request = null;
+		RequestAttributes requestAttributes = null;
+		try {
+			requestAttributes = RequestContextHolder.currentRequestAttributes();
+		} catch (IllegalStateException e) {
+			//requestAttributes = new NonWebRequestAttributes();
+			//RequestContextHolder.setRequestAttributes(requestAttributes, true);
+			request = new MockHttpServletRequest();
+			RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request), true);
+		} finally {
+			if (requestAttributes instanceof ServletRequestAttributes) {
+				ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
+				request = servletRequestAttributes.getRequest();
+			}
+			org.springblade.core.tool.utils.WebUtil.setRequest(new ServletRequestAttributes(request));
+		}
+		return request;
+	}
+
+	/***
+	 * 鍚屾鍨嬪彿浠ｅ彿
+	 */
+	@Override
+	public void saveItemDataSyncScheduing(String endDate) throws ServiceException {
+		String paramString = "";
+		String backString = "鎴愬姛";
+		String msg = "鎴愬姛";
+		boolean success = true;
+		SearchItemParam searchItemParam = new SearchItemParam();
+		searchItemParam.setSystag("VCI"); //璋冪敤绯荤粺鏍囪瘑
+		SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+		String lastchangedon = "";
+		if (StringUtils.isBlank(endDate)) {
+			Calendar calendar = Calendar.getInstance();
+			calendar.set(Calendar.HOUR_OF_DAY, 0);
+			calendar.set(Calendar.MINUTE, 0);
+			calendar.set(Calendar.SECOND, 0);
+			log.info("鏌ヨ鏃堕棿------->" + dft.format(new Date()));
+			lastchangedon = dft.format(calendar.getTime());
+		} else {
+			lastchangedon = endDate;
+		}
+		searchItemParam.setLastchangedon(lastchangedon);
+		searchItemParam.setIsenabled("");
+		searchItemParam.setStatus(itemStatus);
+		//Map<String,String> searchDataMap = VciBaseUtil.objectToMapString(searchItemParam);
+		try {
+			String sendParamString = JSONObject.toJSON(searchItemParam).toString();
+			// TODO: 鏀逛负浣跨敤HttpUtils鏂瑰紡杩涜鐢宠锛屽洜涓虹幇鍦ㄧ敵璇风敤涔嬪墠鐨勬柟寮忎細鎶ラ敊
+			LinkedMultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
+			headers.add("Authorization", ERPXHDHAUTH);
+			headers.add("X-ECC-Current-Tenant", ERPXHDHTENANT);
+			headers.add("Accept-Language", "zh-CHS");
+			headers.add("Content-Type", MediaType.APPLICATION_JSON.toString());
+			String res = HttpUtils.request(ERPXHDHURL + "/getppModelByElemNew", sendParamString, headers, HttpMethod.POST, MediaType.APPLICATION_JSON);
+			// String res= mdmSearchItemCodeProvider.getppModelByElem(searchItemParam);
+			SearchItemVO searchItemVO = JSONObject.toJavaObject(JSONObject.parseObject(res), SearchItemVO.class);
+			if (searchItemVO != null) {
+				if (!"200".equals(searchItemVO.getStatus())) {
+					throw new ServiceException(String.format("鎺ュ彛杩斿洖鐘舵�佺爜涓猴細%s锛屽師鍥狅細%s", searchItemVO.getStatus(), searchItemVO.getMessage()));
+				}
+				BladeUser finalUser;
+				paramString = JSONObject.toJSON(searchItemVO).toString();
+				log.info("鍨嬪彿浠ｅ彿鏁版嵁鍊�-------銆�" + paramString);
+				HttpServletRequest request = getRequest();
+				try {
+					//鍏嶅瘑鐧诲綍鐢宠token锛宺equest涓坊鍔犵敤鎴蜂俊鎭�
+					try {
+						passwordFreeLoginService.pwdFreeLoginByBoolean(systemId.toLowerCase(Locale.ROOT), request);
+						BladeUser user = AuthUtil.getUser();
+						if (Func.isEmpty(user)) {
+							user = request.getAttribute("_BLADE_USER_REQUEST_ATTR_") == null ? null : (BladeUser) request.getAttribute("_BLADE_USER_REQUEST_ATTR_");
+						}
+						finalUser = user;
+					} catch (Throwable e) {
+						throw new Throwable("鐢ㄦ埛閴存潈澶辫触.");
+					}
+					List<CodeClassify> codeClassifyList = codeClassifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().in(CodeClassify::getId, btmName));
+					if (CollectionUtils.isEmpty(codeClassifyList)) {
+						throw new Throwable("鍒嗙被鏈煡璇㈠埌");
+					}
+					CodeClassify codeClassify = codeClassifyList.get(0);
+					CodeClassifyTemplateVO templateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(codeClassify.getOid());
+					if (templateVO == null || StringUtils.isBlank(templateVO.getOid())) {
+						throw new Throwable("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙朚DM绯荤粺涓搴旀ā鏉�");
+					}
+					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());
+					List<SearchItemUpperCaseDataVO> dataList = searchItemVO.getData();
+					Map<String, SearchItemUpperCaseDataVO> dataVOMap = new HashMap<>();
+					List<String> itemCodeList = new ArrayList<>();
+					ApplyDatasVO allDatasVO = new ApplyDatasVO();
+					List<ApplyDataVO> allObjectList = new ArrayList<>();
+					if (Func.isNotEmpty(dataList)) {
+						dataList.stream().forEach(searchItemDataVO -> {
+							String itemCode = StringUtils.isNotBlank(searchItemDataVO.getPROJECTITEM()) ? searchItemDataVO.getPROJECTITEM() : searchItemDataVO.getMMODELCODE();//椤圭洰浠ｅ彿
+							dataVOMap.put(itemCode, searchItemDataVO);
+							itemCodeList.add(itemCode);
+						});
+						String tableName = "";
+						R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(codeClassify.getBtmTypeId());
+						if (!r.isSuccess()) {
+							throw new Throwable(r.getMsg());
+						}
+						BtmTypeVO btmTypeVO = r.getData();
+						if (btmTypeVO == null) {
+							throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷瀵硅薄锛�");
+						}
+						tableName = btmTypeVO.getTableName();
+						if (StringUtils.isBlank(tableName)) {
+							throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷鐩稿叧鑱旂殑琛�");
+						}
+						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 codeclsfid = '" + codeClassify.getOid() + "' ");
+						sb.append(" and " + VciBaseUtil.toInSql(attrKey, itemCodeList.toArray(new String[]{})));
+						List<Map<String, String>> newDataList = commonsMapper.queryByOnlySqlForMap(sb.toString());
+
+						//List<BaseModel> baseModelList=new ArrayList<>();
+						Map<String, BaseModel> baseModelMap = new HashMap<>();
+						if (!CollectionUtils.isEmpty(newDataList)) {
+							newDataList.stream().forEach(dataMap -> {
+								BaseModel baseModel = new BaseModel();
+								Map<String, String> newDateMap = new CaseInsensitiveMap<>(dataMap);
+								DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(newDateMap, baseModel, true, finalUser);
+								DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel, finalUser);
+								//baseModelList.add(baseModel);
+								String attrKeyValue = newDateMap.getOrDefault(attrKey, "");
+								if (StringUtils.isBlank(attrKeyValue)) {
+									log.info(baseModel.getId());
+								}
+								baseModelMap.put(attrKeyValue, baseModel);
+							});
+						}
+						List<ApplyDataVO> addObjectList = new ArrayList<>();
+						List<ApplyDataVO> editObjectList = new ArrayList<>();
+
+						dataVOMap.forEach((key, value) -> {
+							if (baseModelMap.containsKey(key)) {
+								BaseModel baseModel = baseModelMap.get(key);
+								changeObjectToMap(value, baseModel.getId(), finalUser, "editstatus", editObjectList);
+							} else {
+								changeObjectToMap(value, "", finalUser, "create", addObjectList);
+							}
+						});
+						allObjectList.addAll(addObjectList);
+						allObjectList.addAll(editObjectList);
+						allDatasVO.setObject(allObjectList);
+						LinkedList<XMLResultDataObjectDetailDO> allResultDataObjectDetailDOS = new LinkedList<>();
+						if (!CollectionUtils.isEmpty(addObjectList)) {
+							//瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
+							CodeClassifyFullInfoBO classifyFullInfo = codeClassifyService.getClassifyFullInfo(codeClassify.getOid());
+							if (classifyFullInfo == null || classifyFullInfo.getCurrentClassifyVO() == null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())) {
+								log.info("classifyFullInfo:" + "鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙栧垎绫荤浉鍏充俊鎭�");
+								throw new Throwable("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙栧垎绫荤浉鍏充俊鎭�");
+							}
+							CodeRuleVO ruleVO = mdmEngineServiceI.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+							if (ruleVO == null || StringUtils.isBlank(ruleVO.getOid())) {
+								throw new Throwable("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙朚DM绯荤粺涓搴旇鍒�");
+							}
+							DataObjectVO dataObjectVO = new DataObjectVO();
+							ApplyDatasVO applyDatasVO = new ApplyDatasVO();
+							applyDatasVO.setObject(addObjectList);
+							LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
+							this.getConfigDatas(systemId, btmName, applyDatasVO, attrVOS, dataObjectVO);
+							CodeOrderDTO orderDTO = new CodeOrderDTO();
+							orderDTO.setCodeClassifyOid(codeClassify.getOid());//鍒嗙被涓婚敭
+							//鐮佹璁剧疆
+							List<SectionVO> section = new ArrayList<>();
+							SectionVO sectionVO = new SectionVO();
+							sectionVO.setValue(secValue);
+							sectionVO.setName(secName);
+							section.add(sectionVO);
+							log.info("end锛氳鍒欒幏鍙栧畬姣�");
+							List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(section, ruleVO, classifyFullInfo);
+							log.info("end锛氱爜娈佃幏鍙栧畬姣�");
+							orderDTO.setSecDTOList(codeOrderSecDTOList);//鍒嗙被鐮佹
+							mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs, false);
+							allResultDataObjectDetailDOS.addAll(resultDataObjectDetailDOs);
+						}
+						//鏇存柊鏁版嵁锛堟洿鏂扮姸鎬侊級
+						if (!CollectionUtils.isEmpty(editObjectList)) {
+							DataObjectVO dataObjectVO = new DataObjectVO();
+							ApplyDatasVO applyDatasVO = new ApplyDatasVO();
+							applyDatasVO.setObject(editObjectList);
+							LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
+							CodeClassifyVO codeClassifyVO = new CodeClassifyVO();
+							BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassify, codeClassifyVO);
+							this.getConfigDatas(systemId, btmName, applyDatasVO, attrVOS, dataObjectVO);
+							mdmIOService.batchSyncEditDatas(codeClassifyVO, dataObjectVO, resultDataObjectDetailDOs, false);
+							allResultDataObjectDetailDOS.addAll(resultDataObjectDetailDOs);
+						}
+						Object paramObject = JSONObject.toJSON(allDatasVO);
+						paramString = Func.isEmpty(paramObject) ? "" : paramObject.toString();
+						Object backObject = JSONObject.toJSON(allResultDataObjectDetailDOS);
+						backString = Func.isEmpty(backObject) ? "" : backObject.toString();
+					}
+				} catch (Throwable e) {
+					e.printStackTrace();
+					log.error("鏌ヨ澶辫触--->" + e);
+					success = false;
+					backString = "鏌ヨ澶辫触--->" + e;
+					msg = "鏌ヨ澶辫触--->" + e;
+					throw new VciBaseException(e.getMessage());
+				} finally {
+					try {
+						//璁板綍鏃ュ織
+						this.saveLogs(systemId, systemId, paramString, backString, success, msg, "queryData");
+					} catch (Throwable e) {
+						e.printStackTrace();
+						log.error(e.getMessage());
+						throw new VciBaseException(e.getMessage());
+					}
+				}
+			} else {
+				throw new Throwable("鎺ュ彛鏈繑鍥炰俊鎭�");
+			}
+		} catch (Throwable e1) {
+			e1.printStackTrace();
+			log.error("鏌ヨ澶辫触--->" + e1);
+			//paramString="";
+			success = false;
+			backString = "鏌ヨ澶辫触--->" + e1;
+			msg = "鏌ヨ澶辫触--->" + e1;
+			try {
+				//璁板綍鏃ュ織
+				this.saveLogs(systemId, systemId, paramString, backString, success, msg, "queryData");
+			} catch (Throwable e) {
+				e.printStackTrace();
+				log.error(e.getMessage());
+				throw new ServiceException(e.getMessage());
+			}
+			throw new ServiceException(e1.getMessage());
+		}
+	}
+
+	/***
+	 * 璁板綍鏃ュ織淇℃伅
+	 * @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);
+	}
+
+	/***
+	 * 鏍规嵁浼犲叆鐨勫弬鏁颁俊鎭牎楠岀爜娈佃鍒�
+	 */
+	private List<CodeOrderSecDTO> getRuleCodeOrderSecDTOs(List<SectionVO> SectionVOList, CodeRuleVO ruleVO, CodeClassifyFullInfoBO classifyFullInfo) throws Throwable {
+		List<CodeBasicSecVO> codeBasicSecVOS = ruleVO.getSecVOList();
+		Map<String, String> sectionVOMap = new HashMap<>();
+		SectionVOList.stream().forEach(SectionVO -> {
+			sectionVOMap.put(SectionVO.getName(), SectionVO.getValue());
+		});
+		List<CodeOrderSecDTO> codeOrderSecDTOList = new ArrayList<>();
+		Map<String, String> errorMap = new HashMap<>();
+		String nullSymbol = EnumCache.getValue("nullSymbol", "NULL");
+		nullSymbol = Func.isBlank(nullSymbol) ? "#NaN?":nullSymbol;
+		for (CodeBasicSecVO codeBasicSecVO : codeBasicSecVOS) {
+			String sectype = codeBasicSecVO.getSecType();
+			String newSecName = codeBasicSecVO.getName();
+			String classifySecOid = codeBasicSecVO.getOid();
+			String message = "";
+			if (!sectype.equals(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue())) {
+				String name = codeBasicSecVO.getName();
+				String sectypeText = codeBasicSecVO.getSecTypeText();
+				log.info("鐮佹鍚嶇О:" + name);
+				log.info("鎻忚堪:" + sectypeText);
+				CodeOrderSecDTO CodeOrderSecDTO = new CodeOrderSecDTO();
+				if (sectionVOMap.containsKey(name)) {
+					CodeOrderSecDTO.setSecOid(codeBasicSecVO.getOid());
+					String sectypeValue = sectionVOMap.get(name);
+					log.info("鐮佹鍊�:" + sectypeValue);
+					CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(sectype);
+					if (CODE_CLASSIFY_SEC.equals(secType)) {//濡傛灉鏄垎绫荤殑璇濓紝鍒欓渶瑕佸尮閰嶄紶杩囨潵鐨勫垎绫讳唬鍙蜂笌
+						//鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+						List<CodeClassifyValue> codeClassifyValueDOList = codeClassifyValueService.list(Wrappers.<CodeClassifyValue>query().lambda().eq(CodeClassifyValue::getCodeClassifySecOid, classifySecOid));
+
+						if (!CollectionUtils.isEmpty(codeClassifyValueDOList)) {
+							Map<String, CodeClassifyValue> codeClassifyValueDOMap = codeClassifyValueDOList.stream().collect(Collectors.toMap(s -> s.getId(), t -> t, (o1, o2) -> o2));
+							if (codeClassifyValueDOMap.containsKey(sectypeValue) || nullSymbol.equals(sectypeValue)) {
+								CodeClassifyValue codeClassifyValue = codeClassifyValueDOMap.get(sectypeValue);
+								sectypeValue = codeClassifyValue.getOid();
+							} else {
+								//throw new Throwable("浼犲叆鐨勫垎绫荤爜娈碉細銆�" + name + " 鍊硷細" + sectypeValue + "銆戯紝涓嶇鍚堝綋鍓嶅垎绫诲眰绾т唬鍙�");
+								message = "浼犲叆鐨勫垎绫荤爜娈碉細銆�" + name + " 鍊硷細" + sectypeValue + "銆戯紝涓嶇鍚堝綋鍓嶅垎绫诲眰绾т唬鍙�";
+								errorMap.put("error", errorMap.getOrDefault("error", "") + ";" + message);
+							}
+						}
+					}
+					if (StringUtils.isBlank(sectypeValue)&&!name.equals(secName)) {
+						message = "浼犲叆鐨勫垎绫荤爜娈碉細銆�" + name + " 銆戠殑鍊间笉鍏佽涓虹┖";
+						errorMap.put("error", errorMap.getOrDefault("error", "") + ";" + message);
+					}
+					CodeOrderSecDTO.setSecValue(sectypeValue);
+					codeOrderSecDTOList.add(CodeOrderSecDTO);
+				} else {
+					message = "浼犲叆鐨勭爜娈佃鍒欑己灏�" + name;
+					errorMap.put("error", errorMap.getOrDefault("error", "") + ";" + message);
+				}
+			}
+		}
+		if (errorMap.size() > 0) {
+			throw new Throwable(errorMap.getOrDefault("error", ""));
+		}
+		return codeOrderSecDTOList;
+	}
+
+	/***
+	 * 璇诲彇灞炴�ф槧灏勯厤缃俊鎭�
+	 * @param systemId
+	 * @param libray
+	 * @param applyDatasVO
+	 * @param codeClassifyTemplateAttrVOList
+	 * @param dataObjectVO
+	 * @throws Throwable
+	 */
+	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());
+		//stringStringMap.put("RLM","D:\\RLM.xml");
+		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) {
+				e.printStackTrace();
+				throw new Throwable("闆嗘垚绯荤粺鏍囪瘑涓猴細銆�" + systemId + "銆戯紝鍒嗙被搴撲负:銆�" + libray + "銆戠殑闆嗘垚灞炴�ч厤缃枃浠惰鍙栧け璐�");
+			}
+			String path = stringStringMap.get(systemId);
+			if (!CollectionUtils.isEmpty(libraryClsfDOList)) {
+				Map<String, List<ClsfAttrMappingDO>> libPropMaps = libraryClsfDOList.stream().collect(Collectors.toMap(LibraryClsfDO::getLibrary, LibraryClsfDO::getProp, (key1, key2) -> key2));
+				log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + libray + "浠庨厤缃枃浠朵腑鎵惧搴斿睘鎬ф槧灏勯厤缃�");
+				if (libPropMaps.containsKey(libray.toUpperCase(Locale.ROOT))) {
+					log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + 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("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + libray + "鍖归厤鍒扮浉搴旂殑灞炴�ф槧灏勪俊鎭�,灞炴�ф槧灏勬潯鐩暟+" + clsfAttrMappingDOList.size());
+				} else {
+					throw new Throwable("鏍规嵁绯荤粺鏍囪瘑銆�" + systemId + "銆戞壘鍒板搴旂殑閰嶇疆鏂囦欢:銆�" + path + "銆戯紝浣嗘湭鑾峰彇鍒板搴旂殑搴撱��" + libray + "銆戝睘鎬ф槧灏勪俊鎭厤缃�");
+				}
+			} else {
+				throw new Throwable("鏍规嵁绯荤粺鏍囪瘑銆�" + systemId + "銆戞壘鍒板搴旂殑閰嶇疆鏂囦欢:銆�" + path + "銆戯紝浣嗘湭鑾峰彇鍒板搴旂殑搴撱��" + libray + "銆戝睘鎬ф槧灏勪俊鎭厤缃�");
+			}
+		} else {
+			throw new Throwable("鏈幏鍙栧埌闆嗘垚灞炴�ф槧灏勭郴缁熼厤缃俊鎭�");
+		}
+		log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + 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) {
+			throw new Throwable("缁勭粐鏁版嵁鏄犲皠鍊煎け璐�");
+		}
+	}
+
+	private void changeObjectToMap(SearchItemUpperCaseDataVO searchItemDataVO, String code, BladeUser user, String operation, List<ApplyDataVO> object) {
+		ApplyDataVO applyDataVO = new ApplyDataVO();
+		List<ProppertyVO> propList = new ArrayList<>();
+		//String status= searchItemDataVO.getStatus();//鏁版嵁鐘舵�� 瀛楃鍨嬶紝鏋氫妇鍊硷紱鍒跺崟锛�0锛涘鎵逛腑锛�1锛涢�氳繃锛�2锛涢┏鍥烇細3锛�
+
+		String mmodelCode = searchItemDataVO.getMMODELCODE();//鍒堕�犲瀷鍙蜂唬鍙�
+		initProperty("mmodelcode", "", mmodelCode, propList);
+		String projectCode = searchItemDataVO.getPROJECTCODE();//椤圭洰缂栫爜
+		initProperty("projectcode", "", projectCode, propList);
+		String projectItem = searchItemDataVO.getPROJECTITEM();//椤圭洰浠ｅ彿
+		initProperty("projectitem", "", projectItem, propList);
+		String materialCode = searchItemDataVO.getMATERIALCODE();//浜у搧缂栫爜
+		initProperty("materialcode", "", materialCode, propList);
+
+		Date cretaeDon = searchItemDataVO.getCREATEDON();//鍒涘缓鏃ユ湡 鏃ユ湡鍨嬶紝濡傦細2023-09-08 19:24:11
+		initProperty("cretaedon", "", Func.formatDateTime(cretaeDon), propList);
+		Date lastchangeDon = searchItemDataVO.getLASTCHANGEDON();//鏇存敼鏃堕棿 鏃ユ湡鍨嬶紝濡傦細2023-09-08 19:24:11
+		initProperty("lastchangedon", "", Func.formatDateTime(lastchangeDon), propList);
+		//缁勫悎灞炴�х殑澶勭悊
+		initProperty(attrKey, "", StringUtils.isNotBlank(projectItem) ? projectItem : mmodelCode, propList);
+		String creatBy = searchItemDataVO.getCREATBY();//鍒涘缓鑰�
+		//Date cretaeDon = searchItemDataVO.getCREATEDON();//鍒涘缓鏃ユ湡 鏃ユ湡鍨嬶紝濡傦細2023-09-08 19:24:11
+		String lastchangeBy = searchItemDataVO.getLASTCHANGEDBY();//鏇存敼鑰�
+		//Date lastchangeDon = searchItemDataVO.getLASTCHANGEDON();//鏇存敼鏃堕棿 鏃ユ湡鍨嬶紝濡傦細2023-09-08 19:24:11
+		String isenabled = searchItemDataVO.getISENABLED();//瀛楃鍨嬶紝鏋氫妇鍊硷紱鍋滅敤锛�0锛涘惎鐢細1锛�
+		applyDataVO.setOperate(operation);
+		applyDataVO.setCode(code);
+		if (isenabled.equals("0")) {
+			applyDataVO.setStatus(CodeDefaultLC.DISABLE.getValue());
+		} else {
+			applyDataVO.setStatus(CodeDefaultLC.RELEASED.getValue());
+		}
+		applyDataVO.setId(VciBaseUtil.getPk());
+		applyDataVO.setEditor(lastchangeBy);
+		applyDataVO.setCreator(creatBy);
+		applyDataVO.setProp(propList);
+		object.add(applyDataVO);
+	}
+
+	private void initProperty(String key, String text, String value, List<ProppertyVO> propList) {
+		ProppertyVO vo = new ProppertyVO();
+		vo.setKey(key);
+		vo.setText(StringUtils.isBlank(text) ? "" : text);
+		vo.setValue(StringUtils.isBlank(value) ? "" : value);
+		propList.add(vo);
+	}
 
 	/***
 	 * 鏌ヨredis涓暟鎹紝瀵规瘮鍚庢彃鍏ockingtask
 	 * @param type
 	 */
-	private void initPushDataTaks(int type){
+	private void initPushDataTaks(int type) {
 		initSysadmin();
 		List<DockingSystemConfig> dockingSystemConfigList = dockingSystemConfigService.list(
-			Wrappers.<DockingSystemConfig>query().lambda().eq(DockingSystemConfig::getUsedFlag,"true")
-				.eq(DockingSystemConfig::getPushType,type==2?"2":"1").eq(DockingSystemConfig::getDataFlowType, SysIntegrationDataFlowTypeEnum.PUSH.getValue()));//2鏄唬琛ㄥ垎绫绘帹閫侊紝1鏄唬琛ㄦ暟鎹帹閫�
+			Wrappers.<DockingSystemConfig>query().lambda().eq(DockingSystemConfig::getUsedFlag, "true")
+				.eq(DockingSystemConfig::getPushType, type == 2 ? "2" : "1").eq(DockingSystemConfig::getDataFlowType, SysIntegrationDataFlowTypeEnum.PUSH.getValue()));//2鏄唬琛ㄥ垎绫绘帹閫侊紝1鏄唬琛ㄦ暟鎹帹閫�
 
-		if(CollectionUtils.isEmpty(dockingSystemConfigList)){
-			String title=type==2?"鍒嗙被鎺ㄩ��":"鏁版嵁鎺ㄩ��";
-			log.info("info->鎵�鏈夐泦鎴愮郴缁燂紝鏈煡璇㈠埌鐩稿叧鐨勩��"+title+"銆戠殑鎺ュ彛閰嶇疆淇℃伅锛岄厤缃�");
+		if (CollectionUtils.isEmpty(dockingSystemConfigList)) {
+			String title = type == 2 ? "鍒嗙被鎺ㄩ��" : "鏁版嵁鎺ㄩ��";
+			log.info("info->鎵�鏈夐泦鎴愮郴缁燂紝鏈煡璇㈠埌鐩稿叧鐨勩��" + title + "銆戠殑鎺ュ彛閰嶇疆淇℃伅锛岄厤缃�");
 			return;
 		}
-		Map<String ,List<DockingSystemConfig>> sysIntInfoDOMap = new HashMap<>();//key=classifyoid,value=list<map>
-		for (DockingSystemConfig dockingSystemConfig:dockingSystemConfigList){
-			List<DockingSystemConfig> dockingSystemList = sysIntInfoDOMap.get(dockingSystemConfig.getClassifyOid());
-			if(dockingSystemList==null){
-				dockingSystemList = new ArrayList<>();
-			}
-			dockingSystemList.add(dockingSystemConfig);
-			sysIntInfoDOMap.put(dockingSystemConfig.getClassifyOid(),dockingSystemList);
-		}
-		//鏍规嵁绫诲瀷鍘绘煡璇㈤渶瑕侀泦鎴愮殑鍒嗙被鎴栬�呮暟鎹�
-		LambdaQueryWrapper<DockingData> queryWrapper = Wrappers.<DockingData>lambdaQuery();
-		queryWrapper.eq(DockingData::getSendFlag,"false");
-		if(type==2){
-			queryWrapper.eq(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
-		}else {
-			queryWrapper.notIn(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
-		}
-		List<DockingData> dataList = dockingDataService.list(queryWrapper);
-
-		for (DockingData mapi:dataList){
-			WebUtil.setPersistence(false);
-			String dataoid = mapi.getOid();//data瀵硅薄鐨刼id
-			String classifyoid = mapi.getClassifyOid();
-			String id = mapi.getId();
-			String uniquecode = mapi.getUniqueCode();
-			String btmid = mapi.getBtmId();
-			String btmoid = mapi.getBtmOid();
-			String sendtype = mapi.getSendType();
-			String classifyid = mapi.getClassifyId();
-			String classifyname = mapi.getClassifyName();
-			String curentClassOid=null;
-			if(type==2){
-				curentClassOid=btmoid;
-			}else{
-				curentClassOid=classifyoid;
-			}
-			List<DockingSystemConfig> effectiveSysIntInfoVOs=new ArrayList<>();
-			//鏍规嵁褰撳墠鏁版嵁鐨刬d锛屾煡璇㈣幏鍙栧摢浜涚郴缁熼渶瑕佸仛闆嗘垚
-			List<CodeClassify> parentLeveDO= codeClassifyService.selectAllLevelParentByOid(curentClassOid);
-			if(CollectionUtils.isEmpty(parentLeveDO)){
-				continue;//璇存槑杩欎釜鍒嗙被琚垹鎺変簡锛屼笉鍋氬鐞�
-			}
-			Map<String, CodeClassify> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
-
-			oidCodeclassifyDOMap.keySet().forEach(oid->{
-				if(sysIntInfoDOMap.containsKey(oid)){
-					List<DockingSystemConfig> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
-					effectiveSysIntInfoVOs.addAll(sysIntInfoDOS);
+		Map<String, List<DockingSystemConfig>> sysIntInfoDOMap = new HashMap<>();//key=classifyoid,value=list<map>
+		for (DockingSystemConfig dockingSystemConfig : dockingSystemConfigList) {
+			String classifyOid = dockingSystemConfig.getClassifyOid();
+			String codeclassifOid = codeClassifyService.selectLeafByPid(classifyOid);
+			List<String> codeList = VciBaseUtil.str2List(codeclassifOid);
+			codeList.stream().forEach(oid -> {
+				List<DockingSystemConfig> dockingSystemList = sysIntInfoDOMap.get(oid);
+				if (Func.isEmpty(dockingSystemList)) {
+					dockingSystemList = new ArrayList<>();
 				}
+				dockingSystemList.add(dockingSystemConfig);
+				sysIntInfoDOMap.put(oid, dockingSystemList);
 			});
-			//濡傛灉鏍￠獙鐨勭郴缁熸帴鍙ｄ俊鎭笉瀛樺湪锛屽垯鏁版嵁涓嶄笉寰�淇℃伅閲屾帹閫�
-			if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
-				continue;
-			}
-			List<DockingTask> dockingTask_insert = new ArrayList<>();
-			for (DockingSystemConfig sysIntInfoVOi:effectiveSysIntInfoVOs){
-				DockingTask dockingTask = new DockingTask();
-				dockingTask.setOid(VciBaseUtil.getPk());
-				dockingTask.setSendFlag(SEND_FLAG_FALSE);
-				dockingTask.setId(id);//缂栫爜
-				dockingTask.setUniqueCode(uniquecode);
-				dockingTask.setBtmOid(btmoid);//鏁版嵁oid
-				dockingTask.setBtmId(btmid);//鏁版嵁涓氬姟绫诲瀷id
-				dockingTask.setClassifyId(classifyid);//鏁版嵁鍦ㄥ垎绫籭d
-				dockingTask.setClassifyOid(classifyoid);//鏁版嵁鎵�鍦ㄥ垎绫籵id
-				dockingTask.setClassifyName(classifyname);//鏁版嵁鎵�鍦ㄥ垎绫诲悕绉�
-				dockingTask.setSendType(sendtype);//鏁版嵁鎺ㄩ�佺被鍨�
-				dockingTask.setDataOid(dataoid);
-				dockingTask.setCreateTime(new Date());
-				dockingTask.setLastModifyTime(new Date());
-				dockingTask.setCreator("sysAdmin");
-				dockingTask.setLastModifier("sysAdmin");
-				//intinfo
-				dockingTask.setSysInfoOid(sysIntInfoVOi.getOid());//intinfo鐨刼id
-				dockingTask.setSystemOid(sysIntInfoVOi.getSysBaseOid());//绯荤粺oid
-				dockingTask.setSystemCode(sysIntInfoVOi.getSysBaseId());//绯荤粺缂栫爜
-				dockingTask.setSystemName(sysIntInfoVOi.getSysBaseName());//绯荤粺name
-				dockingTask_insert.add(dockingTask);
-			}
-
-			if(dockingTask_insert.size()!=0) {
-				dockingTaskService.saveBatch(dockingTask_insert);
-			}
-			//dockingTaskDaoI.updateByPrimaryKey鏂规硶鎶ラ敊浜嗭紝鎵�浠ユ墜鍐欎簡杩欎釜
-			boolean u = updateDockingDatasSendFlag(dataoid,SEND_FLAG_TRUE);
-			if(!u){
-				log.error("闆嗘垚data鍒嗚В浠诲姟澶辫触锛乨ataoid:"+dataoid);
-				continue;
-			}
 		}
+		sysIntInfoDOMap.forEach((classifyOid, effectiveSysIntInfoVOs) -> {
+			//鏍规嵁绫诲瀷鍘绘煡璇㈤渶瑕侀泦鎴愮殑鍒嗙被鎴栬�呮暟鎹�
+			LambdaQueryWrapper<DockingData> queryWrapper = Wrappers.<DockingData>lambdaQuery();
+			queryWrapper.eq(DockingData::getSendFlag, "false");
+			if (type == 2) {
+				queryWrapper.eq(DockingData::getBtmId, DOCKING_DEFAULT_CLASSIFY);
+			} else {
+				queryWrapper.ne(DockingData::getBtmId, DOCKING_DEFAULT_CLASSIFY);
+				queryWrapper.eq(DockingData::getClassifyOid, classifyOid);
+			}
+			List<DockingData> dataList = dockingDataService.list(queryWrapper);
+			for (DockingData mapi : dataList) {
+				WebUtil.setPersistence(false);
+				String dataoid = mapi.getOid();//data瀵硅薄鐨刼id
+				String dataClassifyOid = mapi.getClassifyOid();
+				String id = mapi.getId();
+				String uniquecode = mapi.getUniqueCode();
+				String btmid = mapi.getBtmId();
+				String btmoid = mapi.getBtmOid();
+				String sendtype = mapi.getSendType();
+				String classifyid = mapi.getClassifyId();
+				String classifyname = mapi.getClassifyName();
+				String curentClassOid = null;
+				if (!dataClassifyOid.equals(classifyOid)) {
+					continue;
+				}
+				/*if(type==2){
+					curentClassOid=btmoid;
+				}else{
+					curentClassOid=classifyoid;
+				}*/
+				/*//鏍规嵁褰撳墠鏁版嵁鐨刬d锛屾煡璇㈣幏鍙栧摢浜涚郴缁熼渶瑕佸仛闆嗘垚
+				List<CodeClassify> parentLeveDO= codeClassifyService.selectAllLevelParentByOid(curentClassOid);
+				if(CollectionUtils.isEmpty(parentLeveDO)){
+					continue;//璇存槑杩欎釜鍒嗙被琚垹鎺変簡锛屼笉鍋氬鐞�
+				}
+				Map<String, CodeClassify> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+
+				oidCodeclassifyDOMap.keySet().forEach(oid->{
+					if(sysIntInfoDOMap.containsKey(oid)){
+						List<DockingSystemConfig> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
+						effectiveSysIntInfoVOs.addAll(sysIntInfoDOS);
+					}
+				});
+				//濡傛灉鏍￠獙鐨勭郴缁熸帴鍙ｄ俊鎭笉瀛樺湪锛屽垯鏁版嵁涓嶄笉寰�淇℃伅閲屾帹閫�
+				if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
+					continue;
+				}*/
+				List<DockingTask> dockingTask_insert = new ArrayList<>();
+				for (DockingSystemConfig sysIntInfoVOi : effectiveSysIntInfoVOs) {
+					DockingTask dockingTask = new DockingTask();
+					dockingTask.setOid(VciBaseUtil.getPk());
+					dockingTask.setSendFlag(SEND_FLAG_FALSE);
+					dockingTask.setId(id);//缂栫爜
+					dockingTask.setUniqueCode(uniquecode);
+					dockingTask.setBtmOid(btmoid);//鏁版嵁oid
+					dockingTask.setBtmId(btmid);//鏁版嵁涓氬姟绫诲瀷id
+					dockingTask.setClassifyId(classifyid);//鏁版嵁鍦ㄥ垎绫籭d
+					dockingTask.setClassifyOid(dataClassifyOid);//鏁版嵁鎵�鍦ㄥ垎绫籵id
+					dockingTask.setClassifyName(classifyname);//鏁版嵁鎵�鍦ㄥ垎绫诲悕绉�
+					dockingTask.setSendType(sendtype);//鏁版嵁鎺ㄩ�佺被鍨�
+					dockingTask.setDataOid(dataoid);
+					dockingTask.setCreateTime(new Date());
+					dockingTask.setLastModifyTime(new Date());
+					dockingTask.setCreator("sysAdmin");
+					dockingTask.setLastModifier("sysAdmin");
+					//intinfo
+					dockingTask.setSysInfoOid(sysIntInfoVOi.getOid());//intinfo鐨刼id
+					dockingTask.setSystemOid(sysIntInfoVOi.getSysBaseOid());//绯荤粺oid
+					dockingTask.setSystemCode(sysIntInfoVOi.getSysBaseId());//绯荤粺缂栫爜
+					dockingTask.setSystemName(sysIntInfoVOi.getSysBaseName());//绯荤粺name
+					dockingTask_insert.add(dockingTask);
+				}
+
+				if (dockingTask_insert.size() != 0) {
+					dockingTaskService.saveBatch(dockingTask_insert);
+				}
+				//dockingTaskDaoI.updateByPrimaryKey鏂规硶鎶ラ敊浜嗭紝鎵�浠ユ墜鍐欎簡杩欎釜
+				boolean u = updateDockingDatasSendFlag(dataoid, SEND_FLAG_TRUE);
+				if (!u) {
+					log.error("闆嗘垚data鍒嗚В浠诲姟澶辫触锛乨ataoid:" + dataoid);
+					continue;
+				}
+			}
+		});
+
 	}
 
 	/***
 	 * 鍙戦�佸垎绫绘暟鎹�
 	 */
-	private void sendpushClsfForService(List<DockingTask> dockingTaskList){
+	private void sendpushClsfForService(List<DockingTask> dockingTaskList) {
 		//姣忎釜task渚濇鎵ц鎺ㄩ��
-		for (DockingTask dockingTask:dockingTaskList){
+		for (DockingTask dockingTask : dockingTaskList) {
 			//姣忎釜task涓�涓簨鍔★紝寮�鍚�
-			String paramString="";
-			String sendString="";
-			String backString="";
+			String paramString = "";
+			Object sendString = "";
+			String backString = "";
 			//鏌ヨ绯荤粺鎺ュ彛淇℃伅,ip method,dataType
 			String systeminfooid = dockingTask.getSysInfoOid();//sysininfo 鐨刼id
 			try {
 				//鏌ヨ瑕佹帹閫佺殑鏁版嵁
 				String btmoid = dockingTask.getBtmOid();//鏁版嵁btmid
-				JsonRootDataDTO jsonRootDataDTO=new JsonRootDataDTO();
-				CodeClassify codeClassify=codeClassifyService.getById(btmoid);
-				List<NodeClassifyDTO>nodeClassifyDTOList=new ArrayList<>();
-				NodeClassifyDTO nodeClassifyDTO=new NodeClassifyDTO();
+				JsonRootDataDTO jsonRootDataDTO = new JsonRootDataDTO();
+				CodeClassify codeClassify = codeClassifyService.getById(btmoid);
+				List<NodeClassifyDTO> nodeClassifyDTOList = new ArrayList<>();
+				NodeClassifyDTO nodeClassifyDTO = new NodeClassifyDTO();
 				nodeClassifyDTO.setClassCode(codeClassify.getId());//鍒嗙被浠ｅ彿
 				nodeClassifyDTO.setDescription(codeClassify.getDescription());//鍒嗙被鎻忚堪
 				nodeClassifyDTO.setFullPathName(codeClassify.getPath());//鍏ㄨ矾寰�
@@ -285,23 +915,23 @@
 				nodeClassifyDTO.setId(codeClassify.getOid());//鍒嗙被oid
 				nodeClassifyDTO.setName(codeClassify.getName());//鍒嗙被鍚嶇О
 				nodeClassifyDTOList.add(nodeClassifyDTO);
-				NodeLibraryDTO nodeLibraryDTO=new NodeLibraryDTO();
-				CodeClassifyVO rootClassify=codeClassifyService.getTopClassifyVO(btmoid);
+				NodeLibraryDTO nodeLibraryDTO = new NodeLibraryDTO();
+				CodeClassifyVO rootClassify = codeClassifyService.getTopClassifyVO(btmoid);
 				nodeLibraryDTO.setClassify(nodeClassifyDTOList);
 				nodeLibraryDTO.setId(rootClassify.getOid());
 				nodeLibraryDTO.setName(rootClassify.getName());
 				nodeLibraryDTO.setClassCode(rootClassify.getId());
-				NodeDataDTO nodeDataDTO=new NodeDataDTO();
+				NodeDataDTO nodeDataDTO = new NodeDataDTO();
 				nodeDataDTO.setLibrary(nodeLibraryDTO);
 				jsonRootDataDTO.setData(nodeDataDTO);
 
 				//鏌ヨ鎺ㄩ�佹帴鍙ｅ弬鏁�
 				DockingSystemConfig dockingSystemConfig = dockingSystemConfigService.getById(systeminfooid);
 				String paramType = dockingSystemConfig.getParamType();//xml/json
-				if(paramType.equals(DATATYPE_JSON)){
+				if (paramType.equals(DATATYPE_JSON)) {
 					Object object = JSONObject.toJSON(jsonRootDataDTO);
-					sendString = object.toString();
-				}else{
+					sendString = object;
+				} else {
 					//缁勭粐杩斿洖鎺ュ彛淇℃伅
 					XStream xStream = new XStream(new DomDriver());
 					xStream.processAnnotations(NodeDataDTO.class);
@@ -309,51 +939,72 @@
 					sendString = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(nodeDataDTO);
 				}
 				//璋冪敤鎺ュ彛
-				callInterface(sendString,dockingSystemConfig,dockingTask,"pushClassifyData");
-			}catch (Throwable e){
+				callInterface(sendString, dockingSystemConfig, dockingTask, "pushClassifyData");
+			} catch (Throwable e) {
 				e.printStackTrace();
-			}finally {
+			} finally {
 				//姣忎竴涓猼ask涓�涓簨鐗�
 			}
 		}
 	}
+
 	/***
 	 * 鍙戦�佺紪鐮佷富鏁版嵁
 	 */
-	private void sendpushDataForService (List<DockingTask> dockingTaskS){
+	private void sendpushDataForService(List<DockingTask> dockingTaskS) {
 		//姣忎釜task渚濇鎵ц鎺ㄩ��
-		for (DockingTask dockingTask:dockingTaskS){
+		for (DockingTask dockingTask : dockingTaskS) {
 			//姣忎釜task涓�涓簨鍔★紝寮�鍚�
-			String paramString="";
-			String sendString="";
-			String backString="";
+			String paramString = "";
+			Object sendString = "";
+			String backString = "";
 			try {
 				//鏌ヨ绯荤粺鎺ュ彛淇℃伅,ip method,dataType
 				String systeminfooid = dockingTask.getSysInfoOid();//sysininfo 鐨刼id
 				String classifyoid = dockingTask.getClassifyOid();
 				//鏌ヨ瑕佹帹閫佺殑鏁版嵁
 				String btmoid = dockingTask.getBtmOid();//鏁版嵁btmid
-				String code=dockingTask.getId();;
+				String code = dockingTask.getId();
+				;
 				//琛ㄧず鏄富鏁版嵁
 				CodeClassifyTemplateVO codeClassifyTemplateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(classifyoid);
 				R<List<Map<String, String>>> r = mdmEngineServiceI.getDataByOid(btmoid, codeClassifyTemplateVO.getOid());
-
+				log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒版煡璇富鏁版嵁鍜屾ā鏉垮睘鎬ч樁娈碉紒锛�");
 				List<CodeClassifyTemplateAttrVO> attrVOS = codeClassifyTemplateVO.getAttributes();
 				Map<String/**鑻辨枃鍚嶇О**/, String/**涓枃鍚嶇О**/> attrIdNameMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t.getName(), (o1, o2) -> o2));
 				Map<String, String> data = new HashMap<>();
-				if (r == null) {
-					JSONObject josni = bladeRedis.get(DOCKING_CACHE2_DELETE + btmoid);
-					data = (Map) josni;
+				// TODO: 鍥炴敹缂栫爜鐨勬儏鍐碉紝浼氬嚭鐜版暟鎹凡缁忓洖鏀讹紝浣嗘槸浜嬪姟杩樻湭鎵ц鐨勬儏鍐碉紝
+				//  瀵艰嚧鍙栦笉鍒扮爜鍊硷紝鎵�浠ヨ繖鍎块�氳繃鏌ヨ鐮佸�艰〃涓瓨鍌ㄧ殑宸插洖鏀剁殑涓氬姟鏁版嵁淇℃伅锛岃В鏋愬嚭鏉�
+				if (!r.isSuccess() || Func.isEmpty(r.getData())) {
+					List<CodeAllCode> codeAllCodes = codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getId, dockingTask.getId()));
+					CodeAllCode codeAllCode = codeAllCodes.get(0);
+					BaseModel baseModel = JSONObject.parseObject(codeAllCode.getBusinessData(), BaseModel.class);
+					Map<String, Object> objectMap = VciBaseUtil.objectToMap(baseModel);
+					for (Map.Entry<String, Object> entry : objectMap.entrySet()) {
+						if (entry.getKey().equals("data") && Func.isNotEmpty(entry.getValue())) {
+							Map<String, Object> dataMap = (Map<String, Object>) ((JSONObject) entry.getValue());
+							for (Map.Entry<String, Object> dataEntry : dataMap.entrySet()) {
+								String v = String.valueOf(dataEntry.getValue());
+								data.put(dataEntry.getKey().toLowerCase(Locale.ROOT), v == null ? "" : v);
+							}
+						} else {
+							String key = entry.getKey().toLowerCase(Locale.ROOT);
+							String value = String.valueOf(entry.getValue());
+							data.put(key, value == null ? "" : value);
+						}
+					}
+					/*JSONObject josni = bladeRedis.get(DOCKING_CACHE2_DELETE + btmoid);
+					data = (Map) josni;*/
 				} else {
 					data = r.getData().get(0);
 				}
 				List<NodeProDTO> nodeProDTOS = new ArrayList<>();
-				Map<String, String> finalData = data;
-				AtomicReference<String> newItemId= new AtomicReference<>("");
-				attrIdNameMap.keySet().forEach(field -> {
-					if(field.toLowerCase(Locale.ROOT).equals(itemId.toLowerCase(Locale.ROOT))){
+				final Map<String, String> finalData = data;
+				List<String> newItemId = new ArrayList<>();
+				finalData.keySet().forEach(field -> {
+					if (field.toLowerCase(Locale.ROOT).equals(itemId.toLowerCase(Locale.ROOT))) {
 						String Value = finalData.get(field);
-						newItemId.set(Value);
+						newItemId.add(Value);
 					}
 					String outName = attrIdNameMap.get(field);
 					if (finalData.containsKey(field)) {
@@ -367,14 +1018,16 @@
 				});
 				//鏌ヨ鎺ㄩ�佹帴鍙ｅ弬鏁�
 				DockingSystemConfig dockingSystemConfig = dockingSystemConfigService.getById(systeminfooid);
-				boolean isGroupCodeFlage=false;
-				if(dockingSystemConfig!=null) {
-					isGroupCodeFlage = StringUtils.isBlank(dockingSystemConfig.getIsGroupCodeFlag())?false: Boolean.getBoolean(dockingSystemConfig.getIsGroupCodeFlag());
+				boolean isGroupCodeFlage = false;
+				if (dockingSystemConfig != null) {
+					isGroupCodeFlage = StringUtils.isBlank(dockingSystemConfig.getIsGroupCodeFlag()) ? false : Boolean.parseBoolean(dockingSystemConfig.getIsGroupCodeFlag());
 				}
-				if(isGroupCodeFlage){
-					code=data.getOrDefault("groupcode","");
-					if(StringUtils.isBlank(code)) {//濡傛灉鏄泦鍥㈢爜锛屾病鏈夐鍙栧埌闆嗗洟鐮佸垯浠诲姟涓嶇粨鏉熺瓑寰呴泦鍥㈢爜鐢宠鍚庡啀閫氳繃瀹氭椂鍣ㄨ皟鐢ㄩ泦鍥㈢爜娈�
+				if (isGroupCodeFlage) {
+					code = data.getOrDefault("groupcode", "");
+					if (StringUtils.isBlank(code)) {
+						//濡傛灉鏄帹閫侀泦鍥㈢爜锛屾病鏈夐鍙栧埌闆嗗洟鐮佸垯浠诲姟涓嶇粨鏉熺瓑寰呴泦鍥㈢爜鐢宠鍚庡啀閫氳繃瀹氭椂鍣ㄨ皟鐢ㄩ泦鍥㈢爜娈�
 						dockingTask.setDescription("绛夊緟闆嗗洟鐢宠闆嗗洟鐮�");
+						// TODO锛氬彲鑳戒細鍑虹幇鏈幏鍙栧埌闆嗗洟鐮侊紝浣嗘槸鍙堢珛椹墽琛屼簡鍥炴敹锛屾鏃惰繖鏉′换鍔″氨姘歌繙鏃犳硶缁撴潫,鎵�浠ヨ繖鍎垮垽鏂彧瑕佹槸闆嗗洟鐮佷负绌猴紝骞朵笖鏄洖鏀剁殑灏卞叧闂帹閫佽繖鏉′换鍔�
 						dockingTask.setSendFlag(MdmDuckingConstant.SEND_FLAG_FALSE);
 						dockingTask.setLastModifyTime(new Date());
 						dockingTaskService.updateById(dockingTask);
@@ -388,7 +1041,7 @@
 				nodeObjectDTO.setCode(code);//璁剧疆缂栫爜
 				nodeObjectDTO.setClassCode(classCodeLeves[0]);
 				nodeObjectDTO.setStatus(data.get("lcstatus"));
-				nodeObjectDTO.setItemid(newItemId.get());
+				nodeObjectDTO.setItemid(newItemId.get(0));
 				nodeObjectDTO.setLibrary(classCodeLeves[classCodeLeves.length - 1]);
 				nodeObjectDTO.setPro(nodeProDTOS);
 				List<NodeObjectDTO> nodeObjectDTOS = new ArrayList<>();
@@ -399,7 +1052,8 @@
 				String paramType = dockingSystemConfig.getParamType();//xml/json
 				if (paramType.equals(DATATYPE_JSON)) {
 					Object object = JSONObject.toJSON(nodeJosnDTO);
-					sendString = object.toString();
+					//sendString = object.toString();
+					sendString = object;
 				} else {
 					//缁勭粐杩斿洖鎺ュ彛淇℃伅
 					XStream xStream = new XStream(new DomDriver());
@@ -407,47 +1061,49 @@
 					xStream.autodetectAnnotations(true);
 					sendString = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(nodeDataDTO);
 				}
+				log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒拌皟鐢℉R鎺ュ彛浜嗭紒锛�");
 				//璋冪敤鎺ュ彛
-				callInterface(sendString,dockingSystemConfig, dockingTask,"pushData");
-			}catch (Throwable e){
+				callInterface(sendString, dockingSystemConfig, dockingTask, "pushData");
+			} catch (Throwable e) {
 				e.printStackTrace();
-			}finally {
+			} finally {
 			}
 		}
 	}
+
 	/***
-	 * 璋冪敤鎺ュ彛
-	 * @param sendString
+	 * 璋冪敤鎺ュ彛锛屼紶鍙備负JSON鏃朵紶object绫诲瀷,Content-Type鏀逛负鐣岄潰閰嶇疆鐨�
+	 * @param sendObject
 	 * @param dockingSystemConfig
 	 * @param dockingTask
 	 * @throws Throwable
 	 */
-	private void callInterface(String  sendString , DockingSystemConfig dockingSystemConfig,DockingTask dockingTask,String operation) throws  Throwable{
+	private void callInterface(Object sendObject, DockingSystemConfig dockingSystemConfig, DockingTask dockingTask, String operation) throws Throwable {
 		String paramString = "";
-
 		String backString = "";
-		String msg="";
+		String sendString = sendObject.toString();
+		String msg = "";
 		String url = dockingSystemConfig.getRequestUrl();//url
-		List<ResultNodeObjectDTO> resultNodeObjectDTOS =new ArrayList<>();
+		List<ResultNodeObjectDTO> resultNodeObjectDTOS = new ArrayList<>();
 		try {
-			boolean usedFlag= dockingSystemConfig.getUsedFlag().equals("true")?true:false;
-			if(!usedFlag){
-				throw  new Throwable("鎺ュ彛宸茬粡鍋滅敤锛�");
+			boolean usedFlag = dockingSystemConfig.getUsedFlag().equals("true") ? true : false;
+			if (!usedFlag) {
+				throw new Throwable("鎺ュ彛宸茬粡鍋滅敤锛�");
 			}
 			String type = dockingSystemConfig.getInterfaceType().toLowerCase(Locale.ROOT);//get/post/webserver/corba
 			String paramType = dockingSystemConfig.getParamType();//xml/json
 			String returnType = dockingSystemConfig.getReturnType();//xml/json
-			String requestmethod= dockingSystemConfig.getRequestMethod();
+			String requestmethod = dockingSystemConfig.getRequestMethod();
 			String interfaceFunction = dockingSystemConfig.getInterfaceFunction();//涓昏鏄痺ebservice鐨勬柟娉曞悕
 			String namespace = dockingSystemConfig.getNamespace();//namespace
 			String soapaction = dockingSystemConfig.getSoapAction();//soapaction
 			String targName = dockingSystemConfig.getTargetName();//targName
 			String cxfaxis = dockingSystemConfig.getCxfAxis();//webservice鏄痗xf/axis
 			//鏌ヨparam
-			List<DockingSysIntParam> dockingSysIntParamList = dockingSysIntParamService.list(Wrappers.<DockingSysIntParam>query().lambda().eq(DockingSysIntParam::getInfoOid,dockingSystemConfig.getOid()));
+			List<DockingSysIntParam> dockingSysIntParamList = dockingSysIntParamService.list(Wrappers.<DockingSysIntParam>query().lambda().eq(DockingSysIntParam::getInfoOid, dockingSystemConfig.getOid()));
 			//鏌ヨheader
-			List<DockingSysIntHeader> dockingSysIntHeaderList = dockingSysIntHeaderService.list(Wrappers.<DockingSysIntHeader>query().lambda().eq(DockingSysIntHeader::getInfoOid,dockingSystemConfig.getOid()));
-			if(type.equals(URLTYPE_HTTP)) {
+			List<DockingSysIntHeader> dockingSysIntHeaderList = dockingSysIntHeaderService.list(Wrappers.<DockingSysIntHeader>query().lambda().eq(DockingSysIntHeader::getInfoOid, dockingSystemConfig.getOid()));
+			if (type.equals(URLTYPE_HTTP)) {
 				if (requestmethod.equals(URLTYPE_GET)) {//GET璇锋眰
 					String sendurl = url + "?" + DATA_PARAM_NAME + "=" + sendString;
 					//鎷兼帴param
@@ -457,33 +1113,39 @@
 					paramString = sendurl;
 					backString = HttpUtils.get(sendurl);
 				} else if (requestmethod.equals(URLTYPE_POST)) {//POST璇锋眰
-					MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+					MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
 					for (DockingSysIntParam dockingSysIntParam : dockingSysIntParamList) {
 						params.add(dockingSysIntParam.getParamKey(), dockingSysIntParam.getParamValue());
 					}
-					params.add(DATA_PARAM_NAME,sendString);
+					params.add(DATA_PARAM_NAME, sendObject);
 					paramString = params.toString();
 					MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
 					for (DockingSysIntHeader dockingSysIntHeader : dockingSysIntHeaderList) {
 						headers.add(dockingSysIntHeader.getHeaderKey(), dockingSysIntHeader.getHeaderValue());
 					}
-					backString = HttpUtils.post(url, params, headers);
+					log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒拌皟鐢ㄦ帴鍙ｄ簡锛屽湴鍧�锛�" + url);
+					backString = HttpUtils.postByMediaType(
+						url,
+						params,
+						headers,
+						Func.isNotBlank(dockingSystemConfig.getContentType()) ? MediaType.valueOf(dockingSystemConfig.getContentType()) : MediaType.APPLICATION_FORM_URLENCODED
+					);
 				}
-				if(backString.startsWith("\"")){
-					backString=backString.substring(backString.indexOf("\"")+1);
+				if (backString.startsWith("\"")) {
+					backString = backString.substring(backString.indexOf("\"") + 1);
 				}
-				if(backString.endsWith("\"")){
-					backString=backString.substring(0,backString.lastIndexOf("\""));
+				if (backString.endsWith("\"")) {
+					backString = backString.substring(0, backString.lastIndexOf("\""));
 				}
-				if(backString.contains("\n")){
-					String res="\n";
-					backString=  backString.replaceAll(res,"");
+				if (backString.contains("\n")) {
+					String res = "\n";
+					backString = backString.replaceAll(res, "");
 				}
-				if(backString.contains("\\")){
-					String res="\\\\\"";
-					backString=  backString.replaceAll(res,"\"").trim();
+				if (backString.contains("\\")) {
+					String res = "\\\\\"";
+					backString = backString.replaceAll(res, "\"").trim();
 				}
-			}else if (type.equals(URLTYPE_WEBSERVICE)) {//webserver璇锋眰
+			} else if (type.equals(URLTYPE_WEBSERVICE)) {//webserver璇锋眰
 				MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 				for (DockingSysIntParam dockingSysIntParam : dockingSysIntParamList) {
 					params.add(dockingSysIntParam.getParamKey(), dockingSysIntParam.getParamValue());
@@ -502,9 +1164,9 @@
 			}
 
 			ResultJsonDTO resultJsonDTO = new ResultJsonDTO();
-			if(returnType.equals(DATATYPE_JSON)){
-				resultJsonDTO =JSONObject.toJavaObject(JSONObject.parseObject(backString), ResultJsonDTO.class);
-			}else {
+			if (returnType.equals(DATATYPE_JSON)) {
+				resultJsonDTO = JSONObject.toJavaObject(JSONObject.parseObject(backString), ResultJsonDTO.class);
+			} else {
 				//缁勭粐杩斿洖鎺ュ彛淇℃伅
 				XStream xStream = new XStream(new DomDriver());
 				xStream.processAnnotations(ResultNodeDataDTO.class);
@@ -512,33 +1174,34 @@
 				ResultNodeDataDTO resultNodeDataDTO = (ResultNodeDataDTO) xStream.fromXML(backString);
 				resultJsonDTO.setData(resultNodeDataDTO);
 			}
-			ResultNodeDataDTO resultNodeDataDTO=resultJsonDTO.getData();
-			resultNodeObjectDTOS=resultNodeDataDTO.getObject();
-		}catch (Throwable e){
-			msg="璋冪敤鎺ュ彛澶辫触:"+e.getMessage();
+			ResultNodeDataDTO resultNodeDataDTO = resultJsonDTO.getData();
+			resultNodeObjectDTOS = resultNodeDataDTO.getObject();
+		} catch (Throwable e) {
+			msg = "璋冪敤鎺ュ彛澶辫触:" + e.getMessage();
 			e.printStackTrace();
-			log.error("璋冪敤鎺ュ彛澶辫触:"+e);
+			log.error("璋冪敤鎺ュ彛澶辫触:" + e);
 			//   throw  new Throwable("璋冪敤鎺ュ彛澶辫触:"+e);
-			ResultNodeObjectDTO   resultNodeObjectDTO=new ResultNodeObjectDTO();
+			ResultNodeObjectDTO resultNodeObjectDTO = new ResultNodeObjectDTO();
 			resultNodeObjectDTO.setErroid("1");
 			resultNodeObjectDTO.setMsg(msg);
-			resultNodeObjectDTO.setCode(dockingSystemConfig.getPushType().equalsIgnoreCase("2")?dockingTask.getClassifyId():dockingTask.getId());
+			resultNodeObjectDTO.setCode(dockingSystemConfig.getPushType().equalsIgnoreCase("2") ? dockingTask.getClassifyId() : dockingTask.getId());
 			resultNodeObjectDTO.setItemid(dockingTask.getBtmOid());
 			resultNodeObjectDTOS.add(resultNodeObjectDTO);
-		}finally {
+		} finally {
 			boolean isSend = false;
-			for (ResultNodeObjectDTO resultNodeObjectDTO:resultNodeObjectDTOS){
+			log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒癴inal闃舵浜�");
+			for (ResultNodeObjectDTO resultNodeObjectDTO : resultNodeObjectDTOS) {
 				String erroid = resultNodeObjectDTO.getErroid();
 				msg = resultNodeObjectDTO.getMsg();
-				if("0".equals(erroid)){
+				if ("0".equals(erroid)) {
 					isSend = true;
-				}else if("1".equals(erroid)){
-					isSend=false;
-				}else{
-					isSend=false;
+				} else if ("1".equals(erroid)) {
+					isSend = false;
+				} else {
+					isSend = false;
 				}
 				DockingLog dockingLogeDO = new DockingLog();
-				String oid=VciBaseUtil.getPk();
+				String oid = VciBaseUtil.getPk();
 				dockingLogeDO.setOid(oid);
 				dockingLogeDO.setSystemCode(dockingTask.getSystemCode());
 				dockingLogeDO.setSystemName(dockingTask.getSystemName());
@@ -551,34 +1214,35 @@
 				dockingLogeDO.setUniqueCode(dockingTask.getUniqueCode());
 				dockingLogeDO.setParamString(paramString);
 				dockingLogeDO.setReturnString(backString);
-				dockingLogeDO.setInterfaceStatus(isSend?"true":"false");
+				dockingLogeDO.setInterfaceStatus(isSend ? "true" : "false");
 				dockingLogeDO.setType(operation);
 				dockingLogeDO.setMsg(msg);
-				log.error("闆嗘垚鎺ㄩ�佹暟鎹�,systemcode:"+dockingTask.getSystemCode()+",systemname:"+dockingTask.getSystemName()+",url:"+url+",param:"+paramString+",e:"+msg);
+				log.error("闆嗘垚鎺ㄩ�佹暟鎹�,systemcode:" + dockingTask.getSystemCode() + ",systemname:" + dockingTask.getSystemName() + ",url:" + url + ",param:" + paramString + ",e:" + msg);
 				dockingLogeService.save(dockingLogeDO);
 			}
 			//鍏ㄩ兘鎺ユ敹鎴愬姛鐨勬儏鍐典笅,淇敼dockingtask sendflag涓哄凡鍙戦��
-			if(isSend) {
+			if (isSend) {
 				dockingTask.setSendFlag(MdmDuckingConstant.SEND_FLAG_TRUE);
 				dockingTask.setLastModifyTime(new Date());
 				dockingTaskService.updateById(dockingTask);
 			}
 		}
 	}
+
 	/***
 	 * 鏌ヨ闇�瑕侀泦鎴愮殑涓氬姟鏁版嵁浠诲姟
 	 */
-	private void sendpushDataForService (){
+	private void sendpushDataForService() {
 		initSysadmin();
 		//鏌ヨ鍝簺浠诲姟杩樻病鏈夋墽琛屽畬鎴�
 		//VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(DockingTaskDO.class);
 		//queryWrapper.addQueryMap("sendFlag",MdmDuckingConstant.SEND_FLAG_FALSE);
-	//	queryWrapper.addQueryMap("btmId", QueryOptionConstant.NOTIN + "(" + VciBaseUtil.toInSql(DOCKING_DEFAULT_CLASSIFY.toUpperCase(Locale.ROOT)) + ")");
+		//	queryWrapper.addQueryMap("btmId", QueryOptionConstant.NOTIN + "(" + VciBaseUtil.toInSql(DOCKING_DEFAULT_CLASSIFY.toUpperCase(Locale.ROOT)) + ")");
 
 		//鏍规嵁绫诲瀷鍘绘煡璇㈤渶瑕侀泦鎴愮殑鍒嗙被鎴栬�呮暟鎹�
 		LambdaQueryWrapper<DockingTask> queryWrapper = Wrappers.<DockingTask>lambdaQuery();
-		queryWrapper.eq(DockingTask::getSendFlag,MdmDuckingConstant.SEND_FLAG_FALSE);
-		queryWrapper.notIn(DockingTask::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
+		queryWrapper.eq(DockingTask::getSendFlag, MdmDuckingConstant.SEND_FLAG_FALSE);
+		queryWrapper.notIn(DockingTask::getBtmId, DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
 		List<DockingTask> dockingTaskDOS = dockingTaskService.list(queryWrapper);
 		sendpushDataForService(dockingTaskDOS);
 	}
@@ -586,9 +1250,9 @@
 	/***
 	 * 鏌ヨ闇�瑕侀泦鎴愮殑鐖跺垎绫讳换鍔�
 	 */
-	private void sendpushClsfForService(){
+	private void sendpushClsfForService() {
 		initSysadmin();
-	/*	//鏌ヨ鍝簺浠诲姟杩樻病鏈夋墽琛屽畬鎴�
+		/*	//鏌ヨ鍝簺浠诲姟杩樻病鏈夋墽琛屽畬鎴�
 		VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(DockingTaskDO.class);
 		queryWrapper.addQueryMap("sendFlag",MdmDuckingConstant.SEND_FLAG_FALSE);
 		queryWrapper.addQueryMap("btmId",DOCKING_DEFAULT_CLASSIFY.toUpperCase(Locale.ROOT));
@@ -596,34 +1260,38 @@
 
 		//鏍规嵁绫诲瀷鍘绘煡璇㈤渶瑕侀泦鎴愮殑鍒嗙被鎴栬�呮暟鎹�
 		LambdaQueryWrapper<DockingTask> queryWrapper = Wrappers.<DockingTask>lambdaQuery();
-		queryWrapper.eq(DockingTask::getSendFlag,MdmDuckingConstant.SEND_FLAG_FALSE);
-		queryWrapper.eq(DockingTask::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
+		queryWrapper.eq(DockingTask::getSendFlag, MdmDuckingConstant.SEND_FLAG_FALSE);
+		queryWrapper.eq(DockingTask::getBtmId, DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
 		List<DockingTask> dockingTaskDOS = dockingTaskService.list(queryWrapper);
 		sendpushClsfForService(dockingTaskDOS);
 	}
-	public void initSysadmin(){
+
+	public void initSysadmin() {
 		SessionInfo sessionInfo = new SessionInfo();
 		sessionInfo.setUserId("sysAdmin");
 		sessionInfo.setUserName("绯荤粺绠＄悊鍛�");
 		sessionInfo.setIp(WebUtil.getLocalIp());
 		sessionInfo.setUserOid("193C026F-7DB8-27B4-F383-4E8BE083FB07");
-		sessionInfo.setUserSecret(UserSecretEnum.PRIVACY.getValue()+"");
+		sessionInfo.setUserSecret(UserSecretEnum.PRIVACY.getValue() + "");
 		WebUtil.setSessionInfo(sessionInfo);
 	}
+
 	/**
 	 * dockingdata鏍规嵁oid淇敼sendflag
+	 *
 	 * @param oid
 	 * @param sendflag
 	 * @return
 	 */
-	public boolean updateDockingDatasSendFlag(String oid,String sendflag){
-		boolean u=false;
-		DockingData dockingData=dockingDataService.getById(oid);
-		if(dockingData!=null){
+	public boolean updateDockingDatasSendFlag(String oid, String sendflag) {
+		boolean u = false;
+		DockingData dockingData = dockingDataService.getById(oid);
+		if (dockingData != null) {
 			dockingData.setSendFlag(sendflag);
-			u=	dockingDataService.updateById(dockingData);
+			u = dockingDataService.updateById(dockingData);
 		}
 		return u;
 	}
+
 }
 

--
Gitblit v1.9.3