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

@@ -1,18 +1,52 @@
package com.vci.ubcs.code.service.impl;


import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vci.ubcs.code.entity.DockingSystem;
import com.vci.ubcs.code.service.ICodeDuckingSyncService;
import com.vci.ubcs.code.service.IDockingSystemService;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.vci.ubcs.code.constant.MdmDuckingConstant;
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.SysIntegrationDataFlowTypeEnum;
import com.vci.ubcs.code.service.*;
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.VciBaseUtil;
import com.vci.ubcs.starter.web.util.WebUtil;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Value;
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 javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.MdmDuckingConstant.*;


/*
@@ -24,28 +58,95 @@
@Service
@Slf4j
public class CodeDuckingSyncServiceImpl implements ICodeDuckingSyncService {
   @Value("${dataSyncPush.dataParamName:xmlData}")
   public String DATA_PARAM_NAME;
   @Value("${dataSyncPush.dataId:itemid}")
   private String itemId;
   @Resource
   private  MdmEngineService  mdmEngineServiceI;

   @Resource
   private  IDockingSystemService dockingSystemService;
   private IDockingLogeService dockingLogeService;
   @Resource
   private IDockingDataService dockingDataService;
   @Resource
   private IDockingTaskService dockingTaskService;
   @Resource
   private IDockingSystemConfigService dockingSystemConfigService;
   @Resource
   private ICodeClassifyService codeClassifyService;
   /***
    * resdis缓存服务
    */
   @Resource
   private BladeRedis bladeRedis;
   @Resource
   private IDockingSysIntParamService dockingSysIntParamService;
   @Resource
   private IDockingSysIntHeaderService dockingSysIntHeaderService;



   @Override
   public void DockingDataSyncScheduing() {

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

   }

   /***
    *
    */
   @Override
   public void DockingClassSyncScheduing() {

      initPushDataTaks(2);//分类推送
      sendpushClsfForService();
   }

   /***
    * 手动同步
    * @param oids
    * @return
    */
   @Transactional(rollbackFor = Throwable.class)
   @Override
   public R sendData(String oids) {
      return null;
      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("手动推送完成,请核对是否推送成功");
   }


@@ -54,115 +155,475 @@
    * @param type
    */
   private void initPushDataTaks(int type){
//      //initSysadmin();
//      //sysintinfo查询要推送的主题库和相关系统信息
//      Map<String, String> conditionMap = new HashMap<>();
//      conditionMap.put("usedflag","true");
//      conditionMap.put("pushType",type==2?"2":"1") ;//2是代表分类推送，1是代表数据推送
//
//      Wrappers wrappers=new Wrappers();
//
//      List<DockingSystem> sysIntInfoVOList = dockingSystemService.list(Wrappers.query().lambda().eq());
//      if(CollectionUtils.isEmpty(sysIntInfoVOList)){
//         String title=type==2?"分类推送":"数据推送";
//         log.info("info->所有集成系统，未查询到相关的【"+title+"】的接口配置信息，配置");
//         return;
//      }
//      Map<String ,List<DockingSystem>> sysIntInfoDOMap = new HashMap<String ,List<DockingSystem>>();//key=classifyoid,value=list<map>
//      for (SysIntInfoDO sysIntInfoVOi:sysIntInfoVOList){
//         List<SysIntInfoDO> SysIntInfoVOListi = sysIntInfoDOMap.get(sysIntInfoVOi.getClassifyoid());
//         if(SysIntInfoVOListi==null){
//            SysIntInfoVOListi = new ArrayList<SysIntInfoDO>();
//         }
//         SysIntInfoVOListi.add(sysIntInfoVOi);
//         sysIntInfoDOMap.put(sysIntInfoVOi.getClassifyoid(),SysIntInfoVOListi);
//      }
//      //根据类型去查询需要集成的分类或者数据
//      VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(DockingDataDO.class);
//      queryWrapperForDO.addQueryMap("sendflag","false");
//      if(type==2){
//         queryWrapperForDO.addQueryMap("btmTypeId",DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
//      }else {
//         queryWrapperForDO.addQueryMap("btmTypeId", QueryOptionConstant.NOTIN + "(" + VciBaseUtil.toInSql(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT)) + ")");
//      }
//      List<DockingDataDO> dataList = dockingDataDaoI.selectByWrapper(queryWrapperForDO);
//
//      for (DockingDataDO mapi:dataList){
//         WebUtil.setPersistence(false);
//         BatchCBO batchCBO = new BatchCBO();
//         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<SysIntInfoDO> effectiveSysIntInfoVOs=new ArrayList<>();
//         //根据当前数据的id，查询获取哪些系统需要做集成
//         List<CodeClassifyDO> parentLeveDO= codeClassifyDaoI.selectAllLevelParentByOid(curentClassOid);
//         if(CollectionUtils.isEmpty(parentLeveDO)){
//            continue;//说明这个分类被删掉了，不做处理
//         }
//         Map<String, CodeClassifyDO> 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<SysIntInfoDO> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
//               effectiveSysIntInfoVOs.addAll(sysIntInfoDOS);
//            }
//         });
//         //如果校验的系统接口信息不存在，则数据不不往信息里推送
//         if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
//            continue;
//         }
//         List<DockingTaskDO> dockingTaskDO_insert = new ArrayList<DockingTaskDO>();
//         for (SysIntInfoDO sysIntInfoVOi:effectiveSysIntInfoVOs){
//            DockingTaskDO dockingTaskDO = new DockingTaskDO();
//            dockingTaskDO.setOid(redisService.getUUIDEveryDay());
//            dockingTaskDO.setSendflag(SEND_FLAG_FALSE);
//            dockingTaskDO.setId(id);//编码
//            dockingTaskDO.setUniquecode(uniquecode);
//            dockingTaskDO.setBtmoid(btmoid);//数据oid
//            dockingTaskDO.setBtmid(btmid);//数据业务类型id
//            dockingTaskDO.setClassifyid(classifyid);//数据在分类id
//            dockingTaskDO.setClassifyoid(classifyoid);//数据所在分类oid
//            dockingTaskDO.setClassifyname(classifyname);//数据所在分类名称
//            dockingTaskDO.setSendtype(sendtype);//数据推送类型
//            dockingTaskDO.setDataoid(dataoid);
//
//            //intinfo
//            dockingTaskDO.setSysinfooid(sysIntInfoVOi.getOid());//intinfo的oid
//            dockingTaskDO.setSystemoid(sysIntInfoVOi.getSysbaseoid());//系统oid
//            dockingTaskDO.setSystemcode(sysIntInfoVOi.getSysbaseid());//系统编码
//            dockingTaskDO.setSystemname(sysIntInfoVOi.getSysbasename());//系统name
//            dockingTaskDO_insert.add(dockingTaskDO);
//         }
//
//         BatchCBO bi = null;
//         if(dockingTaskDO_insert.size()!=0) {
//            bi = dockingTaskDaoI.batchInsert(dockingTaskDO_insert);
//            batchCBO.copyFromOther(bi);
//         }
//         WebUtil.setPersistence(true);
//         boService.persistenceBatch(batchCBO);
//         //dockingTaskDaoI.updateByPrimaryKey方法报错了，所以手写了这个
//         boolean u = updateDockingDatasSendFlag(dataoid,SEND_FLAG_TRUE);
//         if(!u){
//            log.error("集成data分解任务失败！dataoid:"+dataoid);
//            continue;
//         }
//
//      }
      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;
   }
}