package com.vci.ubcs.code.service.impl;
|
|
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.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 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.setItemid(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();
|
}
|
}
|
