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.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.thoughtworks.xstream.XStream;
|
import com.thoughtworks.xstream.io.xml.DomDriver;
|
import com.vci.ubcs.code.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.code.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.stream.Collectors;
|
|
import static com.vci.ubcs.code.constant.MdmDuckingConstant.*;
|
|
|
/*
|
* 主题库集成服务
|
* @author xiejun
|
* @date 2023-06-19
|
**/
|
|
@Service
|
@Slf4j
|
public class CodeDuckingSyncServiceImpl implements ICodeDuckingSyncService {
|
@Value("${dataSyncPush.dataParamName:xmlData}")
|
public String DATA_PARAM_NAME;
|
|
|
@Resource
|
private MdmEngineService mdmEngineServiceI;
|
|
@Resource
|
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();
|
initPushDataTaks(1);
|
sendpushDataForService();
|
|
}
|
|
/***
|
*
|
*/
|
@Override
|
public void DockingClassSyncScheduing() {
|
initPushDataTaks(2);//分类推送
|
sendpushClsfForService();
|
}
|
|
/***
|
* 手动同步
|
* @param oids
|
* @return
|
*/
|
@Transactional(rollbackFor = Throwable.class)
|
@Override
|
public R sendData(String oids) {
|
VciBaseUtil.alertNotNull(oids,"系统集成基础信息数据对象",oids,"系统集成基础信息的主键");
|
List<String> dockingTaskOidList=new ArrayList<>();
|
dockingTaskOidList= VciBaseUtil.str2List(oids);
|
List<DockingTask> newDockingTasks= this.dockingTaskService.listByIds(dockingTaskOidList);
|
Map<String,List<DockingTask>> typeDockingTaskMap=new HashMap<>();
|
newDockingTasks.stream().forEach(newDockingTaskDO->{
|
String btmId=newDockingTaskDO.getBtmId();
|
if(btmId.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
|
List<DockingTask> dockingTaskList= typeDockingTaskMap.get(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
|
if(CollectionUtils.isEmpty(dockingTaskList)){
|
dockingTaskList=new ArrayList<>();
|
}
|
dockingTaskList.add(newDockingTaskDO);
|
typeDockingTaskMap.put(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT),dockingTaskList);
|
}else{
|
List<DockingTask> dockingTaskDOList= typeDockingTaskMap.get("data");
|
if(CollectionUtils.isEmpty(dockingTaskDOList)){
|
dockingTaskDOList=new ArrayList<>();
|
}
|
dockingTaskDOList.add(newDockingTaskDO);
|
typeDockingTaskMap.put("data",dockingTaskDOList);
|
}
|
});
|
typeDockingTaskMap.keySet().forEach(type->{
|
List<DockingTask> DockingTaskList=typeDockingTaskMap.get(type);
|
if(!CollectionUtils.isEmpty(DockingTaskList)){
|
if(type.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
|
this.sendpushClsfForService(DockingTaskList);
|
}else{
|
this.sendpushDataForService(DockingTaskList);
|
}
|
}
|
});
|
return R.success("手动推送完成,请核对是否推送成功");
|
}
|
|
|
/***
|
* 查询redis中数据，对比后插入dockingtask
|
* @param type
|
*/
|
private void initPushDataTaks(int type){
|
initSysadmin();
|
|
List<DockingSystemConfig> dockingSystemConfigList = dockingSystemConfigService.list(
|
Wrappers.<DockingSystemConfig>query().lambda().eq(DockingSystemConfig::getUsedFlag,"true")
|
.eq(DockingSystemConfig::getPushType,type==2?"2":"1").eq(DockingSystemConfig::getDataFlowType, SysIntegrationDataFlowTypeEnum.PUSH.getValue()));//2是代表分类推送，1是代表数据推送
|
|
if(CollectionUtils.isEmpty(dockingSystemConfigList)){
|
String title=type==2?"分类推送":"数据推送";
|
log.info("info->所有集成系统，未查询到相关的【"+title+"】的接口配置信息，配置");
|
return;
|
}
|
Map<String ,List<DockingSystemConfig>> sysIntInfoDOMap = new HashMap<>();//key=classifyoid,value=list<map>
|
for (DockingSystemConfig dockingSystemConfig:dockingSystemConfigList){
|
List<DockingSystemConfig> dockingSystemList = sysIntInfoDOMap.get(dockingSystemConfig.getClassifyOid());
|
if(dockingSystemList==null){
|
dockingSystemList = new ArrayList<>();
|
}
|
dockingSystemList.add(dockingSystemConfig);
|
sysIntInfoDOMap.put(dockingSystemConfig.getClassifyOid(),dockingSystemList);
|
}
|
//根据类型去查询需要集成的分类或者数据
|
LambdaQueryWrapper<DockingData> queryWrapper = Wrappers.<DockingData>lambdaQuery();
|
queryWrapper.eq(DockingData::getSendFlag,"false");
|
if(type==2){
|
queryWrapper.eq(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
|
}else {
|
queryWrapper.notIn(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
|
}
|
List<DockingData> dataList = dockingDataService.list(queryWrapper);
|
|
for (DockingData mapi:dataList){
|
WebUtil.setPersistence(false);
|
String dataoid = mapi.getOid();//data对象的oid
|
String classifyoid = mapi.getClassifyOid();
|
String id = mapi.getId();
|
String uniquecode = mapi.getUniqueCode();
|
String btmid = mapi.getBtmId();
|
String btmoid = mapi.getBtmOid();
|
String sendtype = mapi.getSendType();
|
String classifyid = mapi.getClassifyId();
|
String classifyname = mapi.getClassifyName();
|
String curentClassOid=null;
|
if(type==2){
|
curentClassOid=btmoid;
|
}else{
|
curentClassOid=classifyoid;
|
}
|
List<DockingSystemConfig> effectiveSysIntInfoVOs=new ArrayList<>();
|
//根据当前数据的id，查询获取哪些系统需要做集成
|
List<CodeClassify> parentLeveDO= codeClassifyService.selectAllLevelParentByOid(curentClassOid);
|
if(CollectionUtils.isEmpty(parentLeveDO)){
|
continue;//说明这个分类被删掉了，不做处理
|
}
|
Map<String, CodeClassify> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
|
|
oidCodeclassifyDOMap.keySet().forEach(oid->{
|
if(sysIntInfoDOMap.containsKey(oid)){
|
List<DockingSystemConfig> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
|
effectiveSysIntInfoVOs.addAll(sysIntInfoDOS);
|
}
|
});
|
//如果校验的系统接口信息不存在，则数据不不往信息里推送
|
if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
|
continue;
|
}
|
List<DockingTask> dockingTask_insert = new ArrayList<>();
|
for (DockingSystemConfig sysIntInfoVOi:effectiveSysIntInfoVOs){
|
DockingTask dockingTask = new DockingTask();
|
dockingTask.setOid(VciBaseUtil.getPk());
|
dockingTask.setSendFlag(SEND_FLAG_FALSE);
|
dockingTask.setId(id);//编码
|
dockingTask.setUniqueCode(uniquecode);
|
dockingTask.setBtmOid(btmoid);//数据oid
|
dockingTask.setBtmId(btmid);//数据业务类型id
|
dockingTask.setClassifyId(classifyid);//数据在分类id
|
dockingTask.setClassifyOid(classifyoid);//数据所在分类oid
|
dockingTask.setClassifyName(classifyname);//数据所在分类名称
|
dockingTask.setSendType(sendtype);//数据推送类型
|
dockingTask.setDataOid(dataoid);
|
|
//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);
|
}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;
|
attrIdNameMap.keySet().forEach(field -> {
|
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= dockingSystemConfig.getIsGroupCodeFlag().equals("true")?true:false;
|
if(isGroupCodeFlage){
|
code=data.getOrDefault("groupcode","");
|
}
|
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.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);
|
}catch (Throwable e){
|
e.printStackTrace();
|
}finally {
|
}
|
}
|
}
|
/***
|
* 调用接口
|
* @param sendString
|
* @param dockingSystemConfig
|
* @param dockingTask
|
* @throws Throwable
|
*/
|
private void callInterface(String sendString , DockingSystemConfig dockingSystemConfig,DockingTask dockingTask) 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.setOid(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.setId(dockingTask.getId());
|
dockingLogeDO.setUniqueCode(dockingTask.getUniqueCode());
|
dockingLogeDO.setParamString(paramString);
|
dockingLogeDO.setReturnString(backString);
|
dockingLogeDO.setInterfaceStatus(isSend?"true":"false");
|
dockingLogeDO.setType(DATA_LOGE_OUT);
|
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);
|
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;
|
}
|
}
|
