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

@@ -1,23 +1,702 @@
package com.vci.ubcs.code.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.entity.DockingSystemConfig;
import com.vci.ubcs.code.mapper.DockingSystemConfigMapper;
import com.vci.ubcs.code.service.IDockingSystemConfigService;
import org.springframework.stereotype.Service;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
import com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant;

import java.util.Collection;
import java.util.Map;
import java.util.function.Function;
import com.vci.ubcs.code.dto.DockingSysIntHeaderDTO;
import com.vci.ubcs.code.dto.DockingSystemConfigDTO;
import com.vci.ubcs.code.dto.DockingSysIntParamDTO;
import com.vci.ubcs.code.dto.UpdateSysInfoStatusDTO;
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.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.*;
import com.vci.ubcs.code.mapper.*;
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.*;
import com.vci.ubcs.code.wrapper.DockingSysIntHeaderWrapper;
import com.vci.ubcs.code.wrapper.DockingSysIntParamWrapper;
import com.vci.ubcs.code.wrapper.DockingSystemConfigWrapper;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.starter.util.UBCSSqlKeyword;
import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import com.vci.ubcs.starter.web.util.VciDateUtil;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
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.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.MdmDuckingConstant.*;
import static com.vci.ubcs.starter.util.MdmBtmTypeConstant.CODE_CLASSIFY_OID_FIELD;

/***
 * 系统接口管理-接口配置服务
 * @author xiejun
 * @date 2023-06-01
 */
@Slf4j
@Service
public class DockingSystemConfigServiceImpl extends ServiceImpl<DockingSystemConfigMapper, DockingSystemConfig> implements IDockingSystemConfigService{

   @Value("${dataSyncPush.dataParamName:xmlData}")
   public String DATA_PARAM_NAME;
   /***
    * 集成系统管理服务
    */
   @Autowired(required = false)
   private DockingSystemConfigMapper dockingSystemConfigMapper;

   /***
    * 集成接口-集成接口管理参数服务
    */
   @Autowired(required = false)
   private IDockingSysIntParamService dockingSysIntParamService;

   /***
    * 集成接口-集成接口管理参数服务
    */
   @Autowired(required = false)
   private IDockingSysIntHeaderService dockingSysIntHeaderService;




   /***
    * 集成接口-集成系统服务
    */
   @Autowired(required = false)
   private DockingSystemMapper dockingSystemMapper;
//   /***
//    * 任务生成服务
//    */
//   @Resource
//   private IDockingTaskService dockingTaskService;


   /**
    * 主数据引擎的服务
    */
   @Resource
   private MdmEngineService engineService;


   /**
    * 主题库分类的服务
    */
   @Resource
   private ICodeClassifyService classifyService;
   /**
    * 对象的操作
    */
   @Autowired
   private RevisionModelUtil revisionModelUtil;

   /**
    * 通用查询
    */
   @Resource
   private CommonsMapper commonsMapper;


   /**
    * 日志文件服务
    */
   @Resource
   private IDockingLogeService dockingLogeService;

   @Override
   public IPage<DockingSystemConfigVO> page(Map<String,String>codtionMap, Query query) {

      IPage<DockingSystemConfig> pages = page(Condition.getPage(query), UBCSSqlKeyword.buildConditionByMapString(codtionMap));
      List<DockingSystemConfig>  dockingSystemConfigList= pages.getRecords();
      dockingSystemConfigList.stream().forEach(dockingSystemConfig -> {
         dockingSystemConfig.setDataFlowTypeText(SysIntegrationDataFlowTypeEnum.getTextByValue(dockingSystemConfig.getDataFlowType()));
         dockingSystemConfig.setAuthorityTypeText(SysIntegrationAuthorityTypeEnum.getTextByValue(dockingSystemConfig.getAuthorityType()));
         dockingSystemConfig.setParamTypeText(SysIntegrationParamAndReturnTypeEnum.getTextByValue(dockingSystemConfig.getParamType()));
         dockingSystemConfig.setReturnTypeText(SysIntegrationParamAndReturnTypeEnum.getTextByValue(dockingSystemConfig.getReturnType()));
         dockingSystemConfig.setInterfaceTypeText(SysIntegrationRequestTypeEnum.getValueByText(dockingSystemConfig.getInterfaceType()));
         dockingSystemConfig.setPushTypeText(sysIntegrationPushTypeEnum.getTextByValue(dockingSystemConfig.getPushType()));
         dockingSystemConfig.setRequestMethodText(SysIntegrationRequestMethodEnum.getTextByValue(dockingSystemConfig.getRequestMethod()));
         //dockingSystemConfig.setSysBaseName("");
      //   dockingSystemConfig.setSourceSysName("");
         //dockingSystemConfig.setTargetSysName("");
      });
      return  DockingSystemConfigWrapper.build().pageVO(pages);
   }

   /**
    * 增加系统集成的接口管理信息
    * @param dockingSystemConfigDTO 系统集成的系统信息数据传输对象
    * @return 执行结果，success为true表示成功，msg是失败的提示信息，obj是添加完成后的显示对象
    */
   @Transactional(rollbackFor = Exception.class)
   @Override
   public boolean addSave(DockingSystemConfigDTO dockingSystemConfigDTO) throws Throwable {
      log.info(" 增加系统集成的接口管理信息:"+dockingSystemConfigDTO.toString());
      VciBaseUtil.alertNotNull(dockingSystemConfigDTO, "需要添加的数据对象");
      checkColumnNotNull(dockingSystemConfigDTO);
      String systemOid ="";
      if(dockingSystemConfigDTO.getDataFlowType().equals(SysIntegrationDataFlowTypeEnum.PUSH.getValue())) {
         systemOid = dockingSystemConfigDTO.getTargetSystemOid();
      }else{
         systemOid = dockingSystemConfigDTO.getSourceSystemOid();
      }
      DockingSystem dockingSystem = dockingSystemMapper.selectById(systemOid);
      if(dockingSystem!=null) {
         dockingSystemConfigDTO.setSysBaseOid(systemOid);
         dockingSystemConfigDTO.setSysBaseId(dockingSystem.getId());
         dockingSystemConfigDTO.setSysBaseName(dockingSystem.getName());
         dockingSystemConfigDTO.setUsedFlag("true");//设置默认启用状态

         //将DTO转换为DO
         DockingSystemConfig dockingSystemConfig = new DockingSystemConfig();
         revisionModelUtil.copyFromDTOIgnore(dockingSystemConfigDTO,dockingSystemConfig);


         List<DockingSysIntParamDTO> sysIntParamDTOList=  dockingSystemConfigDTO.getSysIntParamDTOS();
         List<DockingSysIntParam> sysIntParamList=new ArrayList<>();
         if(!CollectionUtils.isEmpty(sysIntParamDTOList)) {
            sysIntParamDTOList.stream().forEach(sysIntParamDTO -> {
               DockingSysIntParam sysIntParamDO = new DockingSysIntParam();
               sysIntParamDTO.setInfoOid(dockingSystemConfigDTO.getOid());
               BeanUtilForVCI.copyPropertiesIgnoreCase(sysIntParamDTO, sysIntParamDO);
               DefaultAttrAssimtUtil.addDefaultAttrAssimt(sysIntParamDO, MdmBtmTypeConstant.SYS_INT_PARAMTERY);
               sysIntParamList.add(sysIntParamDO);
            });
         }
         List<DockingSysIntHeaderDTO> sysIntHeaderDTOs= dockingSystemConfigDTO.getSysIntHeaderDTOS();
         List<DockingSysIntHeader> sysIntHeaderList = new ArrayList<>();
         if(!CollectionUtils.isEmpty(sysIntHeaderDTOs)) {
            sysIntHeaderDTOs.stream().forEach(sysIntHeaderDTO -> {
               DockingSysIntHeader dockingSysIntHeader = new DockingSysIntHeader();
               sysIntHeaderDTO.setInfoOid(dockingSystemConfigDTO.getOid());
               BeanUtilForVCI.copyPropertiesIgnoreCase(sysIntHeaderDTO, dockingSysIntHeader);
               DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingSysIntHeader,MdmBtmTypeConstant.SYS_INT_HEADER);
               sysIntHeaderList.add(dockingSysIntHeader);
            });
         }
         dockingSysIntParamService.saveBatch(sysIntParamList);
         dockingSysIntHeaderService.saveBatch(sysIntHeaderList);
         DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingSystemConfig,MdmBtmTypeConstant.SYS_INT_INFO);
         dockingSystemConfigMapper.insert(dockingSystemConfig);
      }else{
         throw new Throwable("根据选择的集成系统未校验到系统中存在此集成系统，请核对！");
      }
      return true;
   }

   /**
    * 修改 系统集成的接口管理信息
    * @param dockingSystemConfigDTO 系统集成的系统信息数据传输对象
    * @return 执行结果，success为true表示成功，msg是失败的提示信息，obj是添加完成后的显示对象
    */
   @Transactional(rollbackFor = Exception.class)
   @Override
   public boolean editSave(DockingSystemConfigDTO dockingSystemConfigDTO) throws Throwable {
      VciBaseUtil.alertNotNull(dockingSystemConfigDTO,"数据对象",dockingSystemConfigDTO.getOid(),"系统集成基础信息主键");
      String systemOid ="";
      if(dockingSystemConfigDTO.getDataFlowType().equals(SysIntegrationDataFlowTypeEnum.PUSH.getValue())) {
         systemOid = dockingSystemConfigDTO.getTargetSystemOid();
      }else{
         systemOid = dockingSystemConfigDTO.getSourceSystemOid();
      }
      DockingSystem dockingSystem = dockingSystemMapper.selectById(systemOid);
      if(dockingSystem!=null) {
         dockingSystemConfigDTO.setSysBaseOid(dockingSystem.getOid());
         dockingSystemConfigDTO.setSysBaseId(dockingSystem.getId());
         dockingSystemConfigDTO.setSysBaseName(dockingSystem.getName());
         //将DTO转换为DO
         DockingSystemConfig dockingSystemConfig = dockingSystemConfigMapper.selectById(dockingSystemConfigDTO.getOid());
         revisionModelUtil.copyFromDTOIgnore(dockingSystemConfigDTO, dockingSystemConfig);
         String sysInfoOid = dockingSystemConfigDTO.getOid();
         List<DockingSysIntParamDTO> dockingSysIntParamDTOS = dockingSystemConfigDTO.getSysIntParamDTOS();
         List<DockingSysIntParam> dockingSysIntParamList = new ArrayList<>();
         if (!CollectionUtils.isEmpty(dockingSysIntParamDTOS)) {
            dockingSysIntParamDTOS.stream().forEach(dockingSysIntParamDTO -> {
               DockingSysIntParam dockingSysIntParam = new DockingSysIntParam();
               BeanUtilForVCI.copyPropertiesIgnoreCase(dockingSysIntParamDTO, dockingSysIntParam);
               dockingSysIntParamList.add(dockingSysIntParam);
            });
         }
         List<DockingSysIntHeaderDTO> dockingSysIntHeaderDTOS = dockingSystemConfigDTO.getSysIntHeaderDTOS();
         List<DockingSysIntHeader> dockingSysIntHeaderList = new ArrayList<>();
         if (!CollectionUtils.isEmpty(dockingSysIntHeaderDTOS)) {
            dockingSysIntHeaderDTOS.stream().forEach(dockingSysIntHeaderDTO -> {
               DockingSysIntHeader dockingSysIntHeader = new DockingSysIntHeader();
               BeanUtilForVCI.copyPropertiesIgnoreCase(dockingSysIntHeaderDTO, dockingSysIntHeader);
               dockingSysIntHeaderList.add(dockingSysIntHeader);
            });
         }

         //批量处理保存header对象
         if (!CollectionUtils.isEmpty(dockingSysIntHeaderList)) {
            List<String> idList = new ArrayList<>();
            List<DockingSysIntHeader> headers_old = this.dockingSysIntHeaderService.list(Wrappers.<DockingSysIntHeader>query().lambda().eq(DockingSysIntHeader::getInfoOid, sysInfoOid));
            ;
            for (DockingSysIntHeader sysIntHeader : headers_old) {
               sysIntHeader.setUsedFlag(FLAG_FAIL);
               idList.add(sysIntHeader.getOid());
            }
            if (idList.size() != 0) {
               boolean res = dockingSysIntHeaderService.removeBatchByIds(idList);
            }
            //再新增headers
            for (DockingSysIntHeader sysIntHeader : dockingSysIntHeaderList) {
               sysIntHeader.setUsedFlag(FLAG_TRUE);
               sysIntHeader.setInfoOid(dockingSystemConfig.getOid());

            }
            boolean res = dockingSysIntHeaderService.saveBatch(dockingSysIntHeaderList);
         }
         //批量处理保存Param对象
         if (!CollectionUtils.isEmpty(dockingSysIntParamList)) {
            //先删除params_old
            List<String> idList = new ArrayList<>();
            List<DockingSysIntParam> params_old = this.dockingSysIntParamService.list(Wrappers.<DockingSysIntParam>query().lambda().eq(DockingSysIntParam::getInfoOid, sysInfoOid));
            for (DockingSysIntParam sysIntParamDO : params_old) {
               sysIntParamDO.setUsedFlag(FLAG_FAIL);
               idList.add(sysIntParamDO.getOid());
            }
            if (idList.size() != 0) {
               boolean res = dockingSysIntParamService.removeBatchByIds(idList);
            }
            //再新增params
            for (DockingSysIntParam sysIntParamDOi : dockingSysIntParamList) {
               sysIntParamDOi.setUsedFlag(FLAG_TRUE);
               sysIntParamDOi.setInfoOid(dockingSystemConfig.getOid());
            }
            dockingSysIntParamService.saveBatch(dockingSysIntParamList);
         }
         this.dockingSystemConfigMapper.updateById(dockingSystemConfig);
      }else{
         throw new Throwable("根据选择的集成系统未校验到系统中存在此集成系统，请核对！");
      }
      return true;
   }
   /***
    * 更新接口配置信息状态
    * @param sysInfoStatusDTO
    * @return
    */
   @Override
   public R updateStatus(UpdateSysInfoStatusDTO sysInfoStatusDTO) {
      VciBaseUtil.alertNotNull(sysInfoStatusDTO.getOid(),"数据对象",sysInfoStatusDTO.getOid(),"系统集成基础信息主键");
      DockingSystemConfig dockingSystemConfig = this.dockingSystemConfigMapper.selectById(sysInfoStatusDTO.getOid());
      try {
         dockingSystemConfig.setTs(VciDateUtil.str2Date(sysInfoStatusDTO.getTs(), VciDateUtil.DateTimeFormat));
      } catch (Exception e) {
         e.printStackTrace();
      }
      if(sysInfoStatusDTO.getUpdate().equals("disable")) {
         dockingSystemConfig.setUsedFlag("false");
      }else{
         dockingSystemConfig.setUsedFlag("true");
      }
      dockingSystemConfigMapper.updateById(dockingSystemConfig);
      return R.status(true);
   }

   /***
    * 手动同步接口，只有推送的才会
    * @param dockingSystemConfigDTO
    * @return
    * @throws VciBaseException
    */
   @Transactional(rollbackFor = Exception.class)
   @Override
   public R pushData(DockingSystemConfigDTO dockingSystemConfigDTO) throws VciBaseException {
      VciBaseUtil.alertNotNull(dockingSystemConfigDTO.getOid(),"数据对象",dockingSystemConfigDTO.getOid(),"系统集成配置信息主键");
      if(dockingSystemConfigDTO.getDataFlowType().equals(SysIntegrationDataFlowTypeEnum.ACCEPT.getValue())){
         throw new VciBaseException("你所选择集成配置信息不属于推送类型的接口配置！");
      }
      boolean issuccess=false;
      String type="数据推送";
      if(dockingSystemConfigDTO.getPushType().equalsIgnoreCase("1")){//推送数据
         pushDockingTasks(dockingSystemConfigDTO);
      }else if(dockingSystemConfigDTO.getPushType().equalsIgnoreCase("2")){//推送分类
         issuccess= pushClsfDatas(dockingSystemConfigDTO);
         type="分类推送";
      }
      return issuccess?R.success(type+"成功！"):R.fail(type+"失败！");
   }

   /**
    *
    * @param dockingSystemConfig
    * @param dockingSysIntHeaderList
    * @param dockingSysIntParamList
    * @return
    */
   private DockingSystemConfigVO changeoDckingSystemEntityVOs(DockingSystemConfig dockingSystemConfig , List<DockingSysIntHeader> dockingSysIntHeaderList , List<DockingSysIntParam> dockingSysIntParamList) {
      DockingSystemConfigVO vo = new DockingSystemConfigVO();
      if(dockingSystemConfig != null){
         BeanUtilForVCI.copyPropertiesIgnoreCase(dockingSystemConfig,vo);
         //如果有lcstatus的类的话
         if(!CollectionUtils.isEmpty(dockingSysIntParamList)) {
            List<DockingSysIntParamVO> dockingSysIntParamVOList = DockingSysIntParamWrapper.build().entityVOs(dockingSysIntParamList);
            vo.setSysIntParamVOs(dockingSysIntParamVOList);
         }
         if(!CollectionUtils.isEmpty(dockingSysIntHeaderList)){
            List<DockingSysIntHeaderVO> dockingSysIntHeaderVOList=   DockingSysIntHeaderWrapper.build().entityVOs(dockingSysIntHeaderList);
            vo.setSysIntHeaderVOs(dockingSysIntHeaderVOList);
         }
      }
      return vo;
   }

   @Override
   public boolean deleteDataById(String oids) {
      VciBaseUtil.alertNotNull(oids, "数据主键为空");
      List<String> oidList=VciBaseUtil.str2List(oids);
      int i=dockingSystemConfigMapper.deleteBatchIds(oidList);
      return i>0?true:false;
   }

   /**
    * 系统集成接口基础信息Null字段检验
    * @param dockingSystemConfigDTO 系统集成基础信息数据传输对象
    * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
    */
   private void checkColumnNotNull(DockingSystemConfigDTO  dockingSystemConfigDTO) throws VciBaseException {
      if (SysIntegrationRequestTypeEnum.HTTP.getValue().equals(dockingSystemConfigDTO.getInterfaceType())){
         VciBaseUtil.alertNotNull(dockingSystemConfigDTO.getRequestUrl(),"HTTP接口的请求地址",dockingSystemConfigDTO.getRequestMethod(),"HTTP接口的请求方式");
      }
      if (SysIntegrationRequestTypeEnum.WEB_SERVICE.getValue().equals(dockingSystemConfigDTO.getInterfaceType())){
         VciBaseUtil.alertNotNull(dockingSystemConfigDTO.getInterfaceFunction(),"WebService的接口函数");
      }
      if (SysIntegrationRequestTypeEnum.CLASSPATH.getValue().equals(dockingSystemConfigDTO.getInterfaceType())){
         VciBaseUtil.alertNotNull(dockingSystemConfigDTO.getClassPath(),"类路径");
      }
   }

   private  R pushDockingTasks(DockingSystemConfigDTO dockingSystemConfigDTO) {
      String msg="数据推送到定时任务成功！";
      try {
         DockingSystemConfig dockingSystemConfig =dockingSystemConfigMapper.selectById(dockingSystemConfigDTO.getOid());
         String codeClassifyOid = dockingSystemConfig.getClassifyOid();
         CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
         CodeClassifyVO topClassifyVO = classifyService.getTopClassifyVO(codeClassifyOid);
         String btmTypeId = topClassifyVO.getBtmTypeId();
         if (StringUtils.isBlank(btmTypeId)) {
            return R.fail("这个分类所属顶层分类没有添加业务类型");
         }
         List<CodeClassifyVO> codeClassifyIdPathVOS = classifyService.listChildrenClassify(topClassifyVO.getOid(), true, "id", false);
         List<CodeClassifyVO> codeClassifynamePathVOS = classifyService.listChildrenClassify(topClassifyVO.getOid(), true, "name", false);
         Map<String/**分类oid**/, String/**分类代号链接符**/> clsfOidIdMap = codeClassifyIdPathVOS.stream().collect(Collectors.toMap(s -> s.getOid(), t -> reverseOrderByList(t.getPath(), topClassifyVO, 1).toLowerCase(Locale.ROOT), (o1, o2) -> o2));
         Map<String/**分类oid**/, String/**分类名称链接符**/> clsfOidNameMap = codeClassifynamePathVOS.stream().collect(Collectors.toMap(s -> s.getOid(), t -> reverseOrderByList(t.getPath(), topClassifyVO, 2).toLowerCase(Locale.ROOT), (o1, o2) -> o2));
         PageHelper pageHelper = new PageHelper();
         pageHelper.setPage(1);
         pageHelper.setLimit(1000000);
         pageHelper.setStart(0);

         HashMap<String, String> conditionMap = new HashMap<>();
         if (!classifyService.checkHasChild(codeClassifyOid)) {
            conditionMap.put(CODE_CLASSIFY_OID_FIELD, codeClassifyOid);
         } else {
            conditionMap.put(CODE_CLASSIFY_OID_FIELD, QueryOptionConstant.IN + "(select oid from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY)
               + " where lcstatus='" + FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED +
               "' start with parentCodeClassifyOid = '" + codeClassifyOid + "' CONNECT BY PRIOR OID = parentCodeClassifyOid )");
         }
         conditionMap.put("islastr", "1");
         conditionMap.put("islastv", "1");
         List<String> lcstatusList = new ArrayList<>(Arrays.asList(new String[]{"TakeBack", "Released", "Disabled"}));
         conditionMap.put("lcstatus", QueryOptionConstant.IN + VciBaseUtil.toInSql(lcstatusList.toArray(new String[0])));

         CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(btmTypeId, templateVO, conditionMap, pageHelper);
         List<Map<String,String>> maps = commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlHasPage());
         List<DockingTask> dockingTaskDO_insert = new ArrayList<>();
         if (!CollectionUtils.isEmpty(maps)) {
            maps.stream().forEach(map -> {
               String btmoid = map.get("oid".toUpperCase(Locale.ROOT)) == null ? "" : map.get("oid".toUpperCase(Locale.ROOT)).toString();//数据oid
               String sendtype = map.get("lcstatus".toUpperCase(Locale.ROOT)) == null ? "" : map.get("lcstatus".toUpperCase(Locale.ROOT)).toString();//数据推送类型
               String id = map.get("id".toUpperCase(Locale.ROOT)) == null ? "" : map.get("id".toUpperCase(Locale.ROOT)).toString();//编码
               String btmid = topClassifyVO.getBtmTypeId();//数据业务类型
               String classifyoid = map.get("codeclsfid".toUpperCase(Locale.ROOT)) == null ? "" : map.get("codeclsfid".toUpperCase(Locale.ROOT)).toString();//数据所在的分类id
               String date2Str = VciDateUtil.date2Str(new Date(), VciDateUtil.DateTimeFormatStr);
               DockingTask dockingTaskDO = new DockingTask();
               dockingTaskDO.setOid(date2Str +"_"+id);
               dockingTaskDO.setSendFlag(SEND_FLAG_FALSE);
               dockingTaskDO.setId(id);//编码
               dockingTaskDO.setUniqueCode("");
               dockingTaskDO.setBtmOid(btmoid);//数据oid
               dockingTaskDO.setBtmId(btmid);//数据业务类型id
               if (clsfOidIdMap.containsKey(classifyoid)) {
                  String classifyid = clsfOidIdMap.get(classifyoid);
                  dockingTaskDO.setClassifyId(classifyid);//数据在分类id
               }
               dockingTaskDO.setClassifyOid(classifyoid);//数据所在分类oid
               if (clsfOidNameMap.containsKey(classifyoid)) {
                  String classifyname = clsfOidNameMap.get(classifyoid);
                  dockingTaskDO.setClassifyName(classifyname);//数据所在分类名称
               }
               dockingTaskDO.setSendType(sendtype);//数据推送类型
               //String dataoid=redisService.getUUIDEveryDay();
               dockingTaskDO.setDataOid(date2Str +"_"+ btmoid);
               //intinfo
               dockingTaskDO.setSysInfoOid(dockingSystemConfigDTO.getOid());//intinfo的oid
               dockingTaskDO.setSystemOid(dockingSystemConfigDTO.getSysBaseOid());//系统oid
               dockingTaskDO.setSystemCode(dockingSystemConfigDTO.getSysBaseId());//系统编码
               dockingTaskDO.setSystemName(dockingSystemConfigDTO.getSysBaseName());//系统name
               dockingTaskDO_insert.add(dockingTaskDO);
            });
         }
//         dockingTaskService.saveBatch(dockingTaskDO_insert);
      }catch (Throwable e){
         msg="数据推送到定时任务失败!";
         log.error("数据推送到定时任务失败!"+e);
         e.printStackTrace();
      }finally {
         log.info(msg);
         return R.success("数据推送到定时任务成功！");
      }
   }

   /***
    * 分类推送集成
    * @param dockingSystemConfigDTO
    * @return
    */
   private  boolean pushClsfDatas(DockingSystemConfigDTO dockingSystemConfigDTO){
      DockingSystemConfig dockingSystemConfig= dockingSystemConfigMapper.selectById(dockingSystemConfigDTO.getOid());
      String classOid= dockingSystemConfig.getClassifyOid();
      List<CodeClassifyVO> listChildrenClassify=  classifyService.listChildrenClassify(classOid,true,"id",false);
      List<NodeClassifyDTO>nodeClassifyDTOList=new ArrayList<>();
      JsonRootDataDTO jsonRootDataDTO=new JsonRootDataDTO();
      NodeDataDTO nodeDataDTO=new NodeDataDTO();
      //每个task一个事务，开启
      boolean isSuccess=false;
      try {
         String sendString = "";
         if (!CollectionUtils.isEmpty(listChildrenClassify)) {
            listChildrenClassify.stream().forEach(codeClassifyVO -> {
               NodeClassifyDTO nodeClassifyDTO = new NodeClassifyDTO();
               nodeClassifyDTO.setClassCode(codeClassifyVO.getId());//分类代号
               nodeClassifyDTO.setDescription(codeClassifyVO.getDescription());//分类描述
               nodeClassifyDTO.setFullPathName(codeClassifyVO.getPath());//全路径
               nodeClassifyDTO.setLcStatus(codeClassifyVO.getLcStatus());//状态
               nodeClassifyDTO.setPid(codeClassifyVO.getId());//父id节点
               nodeClassifyDTO.setId(codeClassifyVO.getOid());//分类oid
               nodeClassifyDTO.setName(codeClassifyVO.getName());//分类名称
               nodeClassifyDTOList.add(nodeClassifyDTO);
            });
            NodeLibraryDTO nodeLibraryDTO = new NodeLibraryDTO();
            nodeLibraryDTO.setClassify(nodeClassifyDTOList);
            CodeClassifyVO rootClassify = classifyService.getTopClassifyVO(classOid);
            nodeLibraryDTO.setId(rootClassify.getOid());
            nodeLibraryDTO.setName(rootClassify.getName());
            nodeDataDTO.setLibrary(nodeLibraryDTO);
            jsonRootDataDTO.setData(nodeDataDTO);
            String paramType = dockingSystemConfigDTO.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, dockingSystemConfigDTO);
            isSuccess=true;
         }
      }catch (Throwable e){
         e.printStackTrace();
         isSuccess=false;
      }finally {
         return true;
      }
   }

   /***
    * 调用接口
    * @param dockingSystemConfigDTO
    * @throws Throwable
    */
   private void callInterface(String  sendString , DockingSystemConfigDTO dockingSystemConfigDTO) throws  Throwable{
      String paramString = "";

      String backString = "";
      String msg="";
      String url = dockingSystemConfigDTO.getRequestUrl();//url
      List<ResultNodeObjectDTO> resultNodeObjectDTOS =new ArrayList<>();
      try {
         String type = dockingSystemConfigDTO.getInterfaceType().toLowerCase(Locale.ROOT);//get/post/webserver/corba
         String paramType = dockingSystemConfigDTO.getParamType();//xml/json
         String returnType = dockingSystemConfigDTO.getReturnType();//xml/json
         String requestmethod= dockingSystemConfigDTO.getRequestMethod();
         String interfaceFunction = dockingSystemConfigDTO.getInterfaceFunction();//主要是webservice的方法名
         String namespace = dockingSystemConfigDTO.getNamespace();//namespace
         String soapaction = dockingSystemConfigDTO.getSoapAction();//soapaction
         String targName = dockingSystemConfigDTO.getTargetName();//targName
         String cxfaxis = dockingSystemConfigDTO.getCxfAxis();//webservice是cxf/axis
         //查询param
         List<DockingSysIntParamDTO> sysIntParamVOList = dockingSystemConfigDTO.getSysIntParamDTOS();
         //查询header
         List<DockingSysIntHeaderDTO> sysIntHeaderVOList =dockingSystemConfigDTO.getSysIntHeaderDTOS();
         if(type.equals(URLTYPE_HTTP)) {
            if (requestmethod.equals(URLTYPE_GET)) {//GET请求
               String sendurl = url + "?" + DATA_PARAM_NAME + "=" + sendString;
               //拼接param
               for (DockingSysIntParamDTO sysIntParamVO : sysIntParamVOList) {
                  sendurl = sendurl + "&" + sysIntParamVO.getParamKey() + "=" + sysIntParamVO.getParamValue();
               }
               paramString = sendurl;
               backString = HttpUtils.get(sendurl);
            } else if (requestmethod.equals(URLTYPE_POST)) {//POST请求
               MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
               if(!CollectionUtils.isEmpty(sysIntParamVOList)) {
                  for (DockingSysIntParamDTO sysIntParamVO : sysIntParamVOList) {
                     params.add(sysIntParamVO.getParamKey(), sysIntParamVO.getParamValue());
                  }
               }
               params.add(DATA_PARAM_NAME,sendString);
               paramString = params.toString();
               MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
               if(!CollectionUtils.isEmpty(sysIntHeaderVOList)) {
                  for (DockingSysIntHeaderDTO sysIntHeaderVO : sysIntHeaderVOList) {
                     headers.add(sysIntHeaderVO.getHeaderKey(), sysIntHeaderVO.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 (DockingSysIntParamDTO sysIntParamVO : sysIntParamVOList) {
               params.add(sysIntParamVO.getParamKey(), sysIntParamVO.getParamValue());
            }
            paramString = sendString;
            MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
            for (DockingSysIntHeaderDTO sysIntHeaderVO : sysIntHeaderVOList) {
               headers.add(sysIntHeaderVO.getHeaderKey(), sysIntHeaderVO.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;
         e.printStackTrace();
         //   throw  new Throwable("调用接口失败:"+e);
         ResultNodeObjectDTO   resultNodeObjectDTO=new ResultNodeObjectDTO();
         resultNodeObjectDTO.setErroid("1");
         resultNodeObjectDTO.setMsg(msg);
         resultNodeObjectDTO.setCode(dockingSystemConfigDTO.getClassifyId());
         resultNodeObjectDTO.setOid(dockingSystemConfigDTO.getClassifyOid());
         resultNodeObjectDTOS.add(resultNodeObjectDTO);
      }finally {
         boolean isSend = false;
         List<DockingLog> dockingLogList=new ArrayList<>();
         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 dockingLog = new DockingLog();
            String oid=VciBaseUtil.getPk();
            dockingLog.setOid(oid);
            dockingLog.setSystemCode(dockingSystemConfigDTO.getSysBaseId());
            dockingLog.setSystemName(dockingSystemConfigDTO.getSysBaseName());
            dockingLog.setSystemOid(dockingSystemConfigDTO.getSysBaseOid());
            dockingLog.setClassifyOid(dockingSystemConfigDTO.getClassifyOid());
            dockingLog.setClassifyId(dockingSystemConfigDTO.getClassifyId());
            dockingLog.setClassifyName(dockingSystemConfigDTO.getClassifyName());
            dockingLog.setId(dockingSystemConfigDTO.getId());
            dockingLog.setUniqueCode("");
            dockingLog.setInterfaceStatus(isSend?"true":"false");
            dockingLog.setParamString(paramString);
            dockingLog.setType(DATA_LOGE_OUT);
            dockingLog.setReturnString(backString);
            dockingLog.setMsg(msg);
            dockingLogList.add(dockingLog);
            log.info("集成推送数据,systemcode:"+dockingSystemConfigDTO.getSysBaseId()+",systemname:"+dockingSystemConfigDTO.getSysBaseName()+",url:"+url+",param:"+paramString+",e:"+msg);
         }
         dockingLogeService.saveBatch(dockingLogList);
      }
   }

   private String reverseOrderByList(String StringValue, CodeClassifyVO topClassifyVO,int type){
      String[] s=StringValue.split("#");
      StringBuffer sb=new StringBuffer();
      List<String> list=new ArrayList<>(Arrays.asList(s));
      Collections.reverse(list);
      System.out.println(list.toString());
      for (String o:list){
         if(StringUtils.isNotBlank(o)){
            sb.append(o).append(",");
         }
      }
      sb.append(type==1?topClassifyVO.getId():topClassifyVO.getName());
      System.out.println(sb.toString());

      return sb.toString();
   }
}