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.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;
import com.vci.ubcs.code.dto.datapush.classify.NodeLibraryDTO;
import com.vci.ubcs.code.dto.datapush.data.NodeJosnDTO;
import com.vci.ubcs.code.dto.datapush.data.NodeObjectDTO;
import com.vci.ubcs.code.dto.datapush.data.NodeProDTO;
import com.vci.ubcs.code.dto.datapush.data.NodedataDTO;
import com.vci.ubcs.code.dto.datapush.result.ResultJsonDTO;
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.feign.MdmSearchItemCodeProvider;
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.applybz.ApplyBZDataVO;
import com.vci.ubcs.code.vo.webserviceModel.applybz.ApplyBZDatasVO;
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.feign.IBtmTypeClient;
import com.vci.ubcs.omd.vo.BtmTypeVO;
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.starter.web.enumpck.UserSecretEnum;
import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
import com.vci.ubcs.starter.web.util.BeanUtil;
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 com.vci.ubcs.system.user.entity.User;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.redis.cache.BladeRedis;
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.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionStatus;
import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

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.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.systemId:ERP}")
	public String systemId;

	/**
	 * 业务类型的服务
	 */
	@Autowired
	private IBtmTypeClient btmTypeClient;
	/**
	 * 通用查询
	 */
	@Resource
	private CommonsMapper commonsMapper;
	@Resource
	private  MdmEngineService  mdmEngineServiceI;
	/**
	 * 批量处理的服务
	 */
	@Resource
	private MdmIOService mdmIOService;
	@Resource
	private IPasswordFreeLoginService passwordFreeLoginService;
	@Resource
	private WebServiceContext webServiceContext;
	@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 IDockingSysIntParamService dockingSysIntParamService;
	@Resource
	private IDockingSysIntHeaderService dockingSysIntHeaderService;
	@Autowired(required = false)
	private MdmSearchItemCodeProvider mdmSearchItemCodeProvider;
	@Autowired
	HttpServletRequest request;

	@Override
	public void DockingDataSyncScheduing() {

		// insertCache2();
		initPushDataTaks(1);
		sendpushDataForService();

	}

	/***
	 *
	 */
	@Override
	public void DockingClassSyncScheduing() {
		initPushDataTaks(2);//分类推送
		sendpushClsfForService();
	}

	/***
	 * 手动同步
	 * @param oids
	 * @return
	 */
	@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<>();
				}
				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<>();
				}
				dockingTaskDOList.add(newDockingTaskDO);
				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))){
					this.sendpushClsfForService(DockingTaskList);
				}else{
					this.sendpushDataForService(DockingTaskList);
				}
			}
		});
		return  R.success("手动推送完成,请核对是否推送成功");
	}

	/***
	 * 同步型号代号
	 */
	@Override
	public void saveItemDataSyncScheduing(String btmName) {
		SearchItemParam searchItemParam=new SearchItemParam();
		searchItemParam.setSystag("VCI"); //调用系统标识
		Calendar calendar= Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY,0);
		calendar.set(Calendar.MINUTE,0);
		calendar.set(Calendar.SECOND,0);
		log.info("查询时间------->"+calendar.getTime());
		SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String lastchangedon= dft.format(calendar.getTime());
		searchItemParam.setLastchangedon(lastchangedon);
		searchItemParam.setStatus("1");//
		Map<String,String>searchDataMap=  VciBaseUtil.objectToMapString(searchItemParam);
		SearchItemVO searchItemVO= mdmSearchItemCodeProvider.getppModelByElem(searchDataMap);
		if(searchItemVO!=null) {
			try {
				//免密登录申请token，request中添加用户信息
				try {
					passwordFreeLoginService.pwdFreeLoginByBoolean(systemId.toLowerCase(Locale.ROOT), request);
				}catch (Throwable e){
					throw new Throwable("用户鉴权失败.");
				}
				final BladeUser user = AuthUtil.getUser();
				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 ("根据传输的分类，未获取MDM系统中对应模板");
				}
				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<SearchItemDataVO> dataList = searchItemVO.getData();
				Map<String, SearchItemDataVO> dataVOMap = new HashMap<>();
				List<String> itemCodeList = new ArrayList<>();
				if (!CollectionUtils.isEmpty(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(btmName);
					if (!r.isSuccess()) {
						throw new Throwable(r.getMsg());
					}
					BtmTypeVO btmTypeVO = r.getData();
					if (btmTypeVO == null) {
						throw new Throwable("根据业务类型未查询到业务类型对象！");
					}
					tableName = btmTypeVO.getTableName();
					if (com.alibaba.nacos.common.utils.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( VciBaseUtil.toInSql(attrKey,VciBaseUtil.array2String(itemCodeList.toArray(new String[]{}))));
					List<Map<String, String>> newDataList = commonsMapper.queryByOnlySqlForMap(sb.toString());
					//List<BaseModel> baseModelList=new ArrayList<>();
					Map<String,BaseModel> baseModelMap=new HashMap<>();
					newDataList.stream().forEach(dataMap->{
						BaseModel baseModel=new BaseModel();
						DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,baseModel,false,user);
						DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel,user);
						//baseModelList.add(baseModel);
						String attrKeyValue=dataMap.getOrDefault(attrKey,"");
						baseModelMap.put(attrKeyValue,baseModel);
					});
					ApplyDatasVO editDatasVO = new ApplyDatasVO();
					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(),user,"editstatus",editObjectList);
						}else{
							changeObjectToMap(value,"",user,"create",addObjectList);
						}
					});
					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 ("根据传输的分类，未获取MDM系统中对应规则");
						}
						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());//分类主键

						log.info("end：规则获取完毕");
						List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(null, ruleVO,classifyFullInfo);
						log.info("end：码段获取完毕");

						orderDTO.setSecDTOList(codeOrderSecDTOList);//分类码段
						mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs,false);
					}

					if(!CollectionUtils.isEmpty(editObjectList)){
						DataObjectVO dataObjectVO = new DataObjectVO();
						ApplyDatasVO applyDatasVO = new ApplyDatasVO();
						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);

					}
				}
			}
			catch (Throwable e){
				log.error("查询失败--->"+e);
			}
		}
	}
	/***
	 * 根据传入的参数信息校验码段规则
	 */
	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());
		});
		//Map<String,CodeClassifyVO> codeClassifyVOMap= classifyFullInfo.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getId(), t -> t,(o1, o2)->o2));
		List<CodeOrderSecDTO> codeOrderSecDTOList=new ArrayList<>();
		Map<String,String> errorMap=new HashMap<>();
		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)){
								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)){
						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("根据参数：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 {
					throw new Throwable("根据系统标识【" + systemId + "】找到对应的配置文件:【" + path + "】，但未获取到对应的库【" + libray + "】属性映射信息配置");
				}
			}else{
				throw new Throwable("根据系统标识【" + systemId + "】找到对应的配置文件:【" + path + "】，但未获取到对应的库【" + libray + "】属性映射信息配置");
			}
		}else{
			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){
			throw new   Throwable("组织数据映射值失败");
		}
	}
 private void changeObjectToMap(SearchItemDataVO 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);
	 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(text);
	  vo.setValue(value);
	  propList.add(vo);
  }
	/***
	 * 查询redis中数据，对比后插入dockingtask
	 * @param 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是代表数据推送

		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对象的oid
			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<>();
			//根据当前数据的id，查询获取哪些系统需要做集成
			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);//数据在分类id
				dockingTask.setClassifyOid(classifyoid);//数据所在分类oid
				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的oid
				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分解任务失败！dataoid:"+dataoid);
				continue;
			}
		}
	}

	/***
	 * 发送分类数据
	 */
	private void sendpushClsfForService(List<DockingTask> dockingTaskList){
		//每个task依次执行推送
		for (DockingTask dockingTask:dockingTaskList){
			//每个task一个事务，开启
			String paramString="";
			String sendString="";
			String backString="";
			//查询系统接口信息,ip method,dataType
			String systeminfooid = dockingTask.getSysInfoOid();//sysininfo 的oid
			try {
				//查询要推送的数据
				String btmoid = dockingTask.getBtmOid();//数据btmid
				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());//全路径
				nodeClassifyDTO.setLcStatus(codeClassify.getLcStatus());//状态
				//  CodeClassifyDO parentClassDo=codeClassifyDaoI.selectByPrimaryKey(codeClassifyDO.getParentCodeClassifyOid());
				nodeClassifyDTO.setPid(codeClassify.getParentCodeClassifyOid());//父id节点
				nodeClassifyDTO.setId(codeClassify.getOid());//分类oid
				nodeClassifyDTO.setName(codeClassify.getName());//分类名称
				nodeClassifyDTOList.add(nodeClassifyDTO);
				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.setLibrary(nodeLibraryDTO);
				jsonRootDataDTO.setData(nodeDataDTO);

				//查询推送接口参数
				DockingSystemConfig dockingSystemConfig = dockingSystemConfigService.getById(systeminfooid);
				String paramType = dockingSystemConfig.getParamType();//xml/json
				if(paramType.equals(DATATYPE_JSON)){
					Object object = JSONObject.toJSON(jsonRootDataDTO);
					sendString = object.toString();
				}else{
					//组织返回接口信息
					XStream xStream = new XStream(new DomDriver());
					xStream.processAnnotations(NodeDataDTO.class);
					xStream.autodetectAnnotations(true);
					sendString = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(nodeDataDTO);
				}
				//调用接口
				callInterface(sendString,dockingSystemConfig,dockingTask,"pushClassifyData");
			}catch (Throwable e){
				e.printStackTrace();
			}finally {
				//每一个task一个事物
			}
		}
	}
	/***
	 * 发送编码主数据
	 */
	private void sendpushDataForService (List<DockingTask> dockingTaskS){
		//每个task依次执行推送
		for (DockingTask dockingTask:dockingTaskS){
			//每个task一个事务，开启
			String paramString="";
			String sendString="";
			String backString="";
			try {
				//查询系统接口信息,ip method,dataType
				String systeminfooid = dockingTask.getSysInfoOid();//sysininfo 的oid
				String classifyoid = dockingTask.getClassifyOid();
				//查询要推送的数据
				String btmoid = dockingTask.getBtmOid();//数据btmid
				String code=dockingTask.getId();;
				//表示是主数据
				CodeClassifyTemplateVO codeClassifyTemplateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(classifyoid);
				R<List<Map<String, String>>> r = mdmEngineServiceI.getDataByOid(btmoid, codeClassifyTemplateVO.getOid());

				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;
				} 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))){
						String Value = finalData.get(field);
						newItemId.set(Value);
					}
					String outName = attrIdNameMap.get(field);
					if (finalData.containsKey(field)) {
						String Value = finalData.get(field);
						NodeProDTO nodeProDTO = new NodeProDTO();
						nodeProDTO.setFiledName(field);
						nodeProDTO.setOutname(outName);
						nodeProDTO.setFiledValue(Value);
						nodeProDTOS.add(nodeProDTO);
					}
				});
				//查询推送接口参数
				DockingSystemConfig dockingSystemConfig = dockingSystemConfigService.getById(systeminfooid);
				boolean isGroupCodeFlage=false;
				if(dockingSystemConfig!=null) {
					isGroupCodeFlage = StringUtils.isBlank(dockingSystemConfig.getIsGroupCodeFlag())?false: Boolean.getBoolean(dockingSystemConfig.getIsGroupCodeFlag());
				}
				if(isGroupCodeFlage){
					code=data.getOrDefault("groupcode","");
					if(StringUtils.isBlank(code)) {//如果是集团码，没有领取到集团码则任务不结束等待集团码申请后再通过定时器调用集团码段
						dockingTask.setDescription("等待集团申请集团码");
						dockingTask.setSendFlag(MdmDuckingConstant.SEND_FLAG_FALSE);
						dockingTask.setLastModifyTime(new Date());
						dockingTaskService.updateById(dockingTask);
						continue;
					}
				}
				String[] classCodeLeves = dockingTask.getClassifyId().split(",");
				NodeJosnDTO nodeJosnDTO = new NodeJosnDTO();
				NodedataDTO nodeDataDTO = new NodedataDTO();
				NodeObjectDTO nodeObjectDTO = new NodeObjectDTO();
				nodeObjectDTO.setCode(code);//设置编码
				nodeObjectDTO.setClassCode(classCodeLeves[0]);
				nodeObjectDTO.setStatus(data.get("lcstatus"));
				nodeObjectDTO.setItemid(newItemId.get());
				nodeObjectDTO.setLibrary(classCodeLeves[classCodeLeves.length - 1]);
				nodeObjectDTO.setPro(nodeProDTOS);
				List<NodeObjectDTO> nodeObjectDTOS = new ArrayList<>();
				nodeObjectDTOS.add(nodeObjectDTO);
				nodeDataDTO.setObject(nodeObjectDTOS);
				nodeJosnDTO.setData(nodeDataDTO);

				String paramType = dockingSystemConfig.getParamType();//xml/json
				if (paramType.equals(DATATYPE_JSON)) {
					Object object = JSONObject.toJSON(nodeJosnDTO);
					sendString = object.toString();
				} else {
					//组织返回接口信息
					XStream xStream = new XStream(new DomDriver());
					xStream.processAnnotations(NodedataDTO.class);
					xStream.autodetectAnnotations(true);
					sendString = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(nodeDataDTO);
				}
				//调用接口
				callInterface(sendString,dockingSystemConfig, dockingTask,"pushData");
			}catch (Throwable e){
				e.printStackTrace();
			}finally {
			}
		}
	}
	/***
	 * 调用接口
	 * @param sendString
	 * @param dockingSystemConfig
	 * @param dockingTask
	 * @throws Throwable
	 */
	private void callInterface(String  sendString , DockingSystemConfig dockingSystemConfig,DockingTask dockingTask,String operation) throws  Throwable{
		String paramString = "";

		String backString = "";
		String msg="";
		String url = dockingSystemConfig.getRequestUrl();//url
		List<ResultNodeObjectDTO> resultNodeObjectDTOS =new ArrayList<>();
		try {
			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 interfaceFunction = dockingSystemConfig.getInterfaceFunction();//主要是webservice的方法名
			String namespace = dockingSystemConfig.getNamespace();//namespace
			String soapaction = dockingSystemConfig.getSoapAction();//soapaction
			String targName = dockingSystemConfig.getTargetName();//targName
			String cxfaxis = dockingSystemConfig.getCxfAxis();//webservice是cxf/axis
			//查询param
			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)) {
				if (requestmethod.equals(URLTYPE_GET)) {//GET请求
					String sendurl = url + "?" + DATA_PARAM_NAME + "=" + sendString;
					//拼接param
					for (DockingSysIntParam dockingSysIntParam : dockingSysIntParamList) {
						sendurl = sendurl + "&" + dockingSysIntParam.getParamKey() + "=" + dockingSysIntParam.getParamValue();
					}
					paramString = sendurl;
					backString = HttpUtils.get(sendurl);
				} else if (requestmethod.equals(URLTYPE_POST)) {//POST请求
					MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
					for (DockingSysIntParam dockingSysIntParam : dockingSysIntParamList) {
						params.add(dockingSysIntParam.getParamKey(), dockingSysIntParam.getParamValue());
					}
					params.add(DATA_PARAM_NAME,sendString);
					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);
				}
				if(backString.startsWith("\"")){
					backString=backString.substring(backString.indexOf("\"")+1);
				}
				if(backString.endsWith("\"")){
					backString=backString.substring(0,backString.lastIndexOf("\""));
				}
				if(backString.contains("\n")){
					String res="\n";
					backString=  backString.replaceAll(res,"");
				}
				if(backString.contains("\\")){
					String res="\\\\\"";
					backString=  backString.replaceAll(res,"\"").trim();
				}
			}else if (type.equals(URLTYPE_WEBSERVICE)) {//webserver请求
				MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
				for (DockingSysIntParam dockingSysIntParam : dockingSysIntParamList) {
					params.add(dockingSysIntParam.getParamKey(), dockingSysIntParam.getParamValue());
				}

				paramString = sendString;
				MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
				for (DockingSysIntHeader dockingSysIntHeader : dockingSysIntHeaderList) {
					headers.add(dockingSysIntHeader.getHeaderKey(), dockingSysIntHeader.getHeaderValue());
				}
				backString = WsErpClientUtil.sendMsg(url, namespace, soapaction, interfaceFunction, targName, sendString, 10000);

			} else {//corba接口
				//paramString=sendString;
				//  backString = jacorbClient.getBOFactoryService().sendCode(sendString);
			}

			ResultJsonDTO resultJsonDTO = new ResultJsonDTO();
			if(returnType.equals(DATATYPE_JSON)){
				resultJsonDTO =JSONObject.toJavaObject(JSONObject.parseObject(backString), ResultJsonDTO.class);
			}else {
				//组织返回接口信息
				XStream xStream = new XStream(new DomDriver());
				xStream.processAnnotations(ResultNodeDataDTO.class);
				xStream.autodetectAnnotations(true);
				ResultNodeDataDTO resultNodeDataDTO = (ResultNodeDataDTO) xStream.fromXML(backString);
				resultJsonDTO.setData(resultNodeDataDTO);
			}
			ResultNodeDataDTO resultNodeDataDTO=resultJsonDTO.getData();
			resultNodeObjectDTOS=resultNodeDataDTO.getObject();
		}catch (Throwable e){
			msg="调用接口失败:"+e.getMessage();
			e.printStackTrace();
			log.error("调用接口失败:"+e);
			//   throw  new Throwable("调用接口失败:"+e);
			ResultNodeObjectDTO   resultNodeObjectDTO=new ResultNodeObjectDTO();
			resultNodeObjectDTO.setErroid("1");
			resultNodeObjectDTO.setMsg(msg);
			resultNodeObjectDTO.setCode(dockingSystemConfig.getPushType().equalsIgnoreCase("2")?dockingTask.getClassifyId():dockingTask.getId());
			resultNodeObjectDTO.setItemid(dockingTask.getBtmOid());
			resultNodeObjectDTOS.add(resultNodeObjectDTO);
		}finally {
			boolean isSend = false;
			for (ResultNodeObjectDTO resultNodeObjectDTO:resultNodeObjectDTOS){
				String erroid = resultNodeObjectDTO.getErroid();
				msg = resultNodeObjectDTO.getMsg();
				if("0".equals(erroid)){
					isSend = true;
				}else if("1".equals(erroid)){
					isSend=false;
				}else{
					isSend=false;
				}
				DockingLog dockingLogeDO = new DockingLog();
				String oid=VciBaseUtil.getPk();
				dockingLogeDO.setOid(oid);
				dockingLogeDO.setSystemCode(dockingTask.getSystemCode());
				dockingLogeDO.setSystemName(dockingTask.getSystemName());
				dockingLogeDO.setSystemOid(dockingTask.getSystemOid());
				dockingLogeDO.setClassifyOid(dockingTask.getClassifyOid());
				dockingLogeDO.setClassifyId(dockingTask.getClassifyId());
				dockingLogeDO.setClassifyName(dockingTask.getClassifyName());
				dockingLogeDO.setCreateTime(new Date());
				dockingLogeDO.setId(dockingTask.getId());
				dockingLogeDO.setUniqueCode(dockingTask.getUniqueCode());
				dockingLogeDO.setParamString(paramString);
				dockingLogeDO.setReturnString(backString);
				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);
				dockingLogeService.save(dockingLogeDO);
			}
			//全都接收成功的情况下,修改dockingtask sendflag为已发送
			if(isSend) {
				dockingTask.setSendFlag(MdmDuckingConstant.SEND_FLAG_TRUE);
				dockingTask.setLastModifyTime(new Date());
				dockingTaskService.updateById(dockingTask);
			}
		}
	}
	/***
	 * 查询需要集成的业务数据任务
	 */
	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)) + ")");

		//根据类型去查询需要集成的分类或者数据
		LambdaQueryWrapper<DockingTask> queryWrapper = Wrappers.<DockingTask>lambdaQuery();
		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);
	}

	/***
	 * 查询需要集成的父分类任务
	 */
	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));
		List<DockingTaskDO> dockingTaskDOS = dockingTaskDaoI.selectByWrapper(queryWrapper);*/

		//根据类型去查询需要集成的分类或者数据
		LambdaQueryWrapper<DockingTask> queryWrapper = Wrappers.<DockingTask>lambdaQuery();
		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(){
		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()+"");
		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){
			dockingData.setSendFlag(sendflag);
			u=	dockingDataService.updateById(dockingData);
		}
		return u;
	}
}