package com.vci.ubcs.code.service.impl;
|
|
|
import com.alibaba.cloud.commons.lang.StringUtils;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.thoughtworks.xstream.XStream;
|
import com.thoughtworks.xstream.io.xml.DomDriver;
|
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
|
import com.vci.ubcs.code.constant.MdmDuckingConstant;
|
import com.vci.ubcs.code.dto.CodeOrderDTO;
|
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
|
import com.vci.ubcs.code.dto.datapush.classify.JsonRootDataDTO;
|
import com.vci.ubcs.code.dto.datapush.classify.NodeClassifyDTO;
|
import com.vci.ubcs.code.dto.datapush.classify.NodeDataDTO;
|
import com.vci.ubcs.code.dto.datapush.classify.NodeLibraryDTO;
|
import com.vci.ubcs.code.dto.datapush.data.NodeJosnDTO;
|
import com.vci.ubcs.code.dto.datapush.data.NodeObjectDTO;
|
import com.vci.ubcs.code.dto.datapush.data.NodeProDTO;
|
import com.vci.ubcs.code.dto.datapush.data.NodedataDTO;
|
import com.vci.ubcs.code.dto.datapush.result.ResultJsonDTO;
|
import com.vci.ubcs.code.dto.datapush.result.ResultNodeDataDTO;
|
import com.vci.ubcs.code.dto.datapush.result.ResultNodeObjectDTO;
|
import com.vci.ubcs.code.entity.*;
|
import com.vci.ubcs.code.enumpack.CodeDefaultLC;
|
import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
|
import com.vci.ubcs.code.enumpack.SysIntegrationDataFlowTypeEnum;
|
import com.vci.ubcs.code.feign.MdmSearchItemCodeProvider;
|
import com.vci.ubcs.code.mapper.CommonsMapper;
|
import com.vci.ubcs.code.service.*;
|
import com.vci.ubcs.code.util.gennerAttrMapUtil;
|
import com.vci.ubcs.code.vo.pagemodel.*;
|
import com.vci.ubcs.code.vo.webserviceModel.apply.ApplyDataVO;
|
import com.vci.ubcs.code.vo.webserviceModel.apply.ApplyDatasVO;
|
import com.vci.ubcs.code.vo.webserviceModel.apply.ProppertyVO;
|
import com.vci.ubcs.code.vo.webserviceModel.apply.SectionVO;
|
import com.vci.ubcs.code.vo.webserviceModel.applybz.ApplyBZDataVO;
|
import com.vci.ubcs.code.vo.webserviceModel.applybz.ApplyBZDatasVO;
|
import com.vci.ubcs.code.vo.webserviceModel.attrmap.*;
|
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
|
import com.vci.ubcs.code.webService.config.AttributeMapConfig;
|
import com.vci.ubcs.omd.feign.IBtmTypeClient;
|
import com.vci.ubcs.omd.vo.BtmTypeVO;
|
import com.vci.ubcs.starter.exception.VciBaseException;
|
import com.vci.ubcs.starter.revision.model.BaseModel;
|
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
|
import com.vci.ubcs.starter.util.HttpUtils;
|
import com.vci.ubcs.code.util.WsErpClientUtil;
|
import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
|
import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
|
import com.vci.ubcs.starter.web.util.BeanUtil;
|
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
|
import com.vci.ubcs.starter.web.util.VciBaseUtil;
|
import com.vci.ubcs.starter.web.util.WebUtil;
|
import com.vci.ubcs.system.user.entity.User;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.collections4.map.CaseInsensitiveMap;
|
import org.springblade.core.log.exception.ServiceException;
|
import org.springblade.core.redis.cache.BladeRedis;
|
import org.springblade.core.secure.BladeUser;
|
import org.springblade.core.secure.utils.AuthUtil;
|
import org.springblade.core.tool.api.R;
|
import org.springblade.core.tool.utils.Func;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.mock.web.MockHttpServletRequest;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.support.DefaultTransactionStatus;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.LinkedMultiValueMap;
|
import org.springframework.util.MultiValueMap;
|
import org.springframework.web.context.request.RequestAttributes;
|
import org.springframework.web.context.request.RequestContextHolder;
|
import org.springframework.web.context.request.ServletRequestAttributes;
|
|
import javax.annotation.Resource;
|
import javax.jws.WebMethod;
|
import javax.servlet.http.HttpServletRequest;
|
import javax.xml.ws.WebServiceContext;
|
import javax.xml.ws.handler.MessageContext;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.stream.Collectors;
|
|
import static com.vci.ubcs.code.constant.MdmDuckingConstant.*;
|
import static com.vci.ubcs.code.constant.MdmEngineConstant.DEFAULT_SYNC_ATTR_LIST;
|
import static com.vci.ubcs.code.enumpack.CodeSecTypeEnum.CODE_CLASSIFY_SEC;
|
|
|
/*
|
* 主题库集成服务
|
* @author xiejun
|
* @date 2023-06-19
|
**/
|
|
@Service
|
@Slf4j
|
public class CodeDuckingSyncServiceImpl implements ICodeDuckingSyncService {
|
@Value("${dataSyncPush.dataParamName:xmlData}")
|
public String DATA_PARAM_NAME;
|
@Value("${dataSyncPush.dataId:itemid}")
|
private String itemId;
|
@Value("${erp.item.attrKey:xhdh}")
|
public String attrKey;
|
@Value("${erp.item.itemStatus:2}")
|
public String itemStatus;
|
|
@Value("${erp.item.systemId:ERP}")
|
public String systemId;
|
@Value("${erp.item.secName:固定码段}")
|
public String secName;
|
@Value("${erp.item.secValue:A}")
|
public String secValue;
|
|
@Value("${erp.item.btmName:XHDH}")
|
public String btmName;
|
/**
|
* 业务类型的服务
|
*/
|
@Autowired
|
private IBtmTypeClient btmTypeClient;
|
/**
|
* 通用查询
|
*/
|
@Resource
|
private CommonsMapper commonsMapper;
|
@Resource
|
private MdmEngineService mdmEngineServiceI;
|
/**
|
* 批量处理的服务
|
*/
|
@Resource
|
private MdmIOService mdmIOService;
|
@Resource
|
private IPasswordFreeLoginService passwordFreeLoginService;
|
|
@Resource
|
private IDockingLogeService dockingLogeService;
|
@Resource
|
private IDockingDataService dockingDataService;
|
@Resource
|
private IDockingTaskService dockingTaskService;
|
@Resource
|
private IDockingSystemConfigService dockingSystemConfigService;
|
@Resource
|
private ICodeClassifyService codeClassifyService;
|
|
@Autowired
|
private ICodeClassifyValueService codeClassifyValueService;
|
@Autowired(required = false)
|
private AttributeMapConfig attributeMapConfig;
|
/***
|
* resdis缓存服务
|
*/
|
@Resource
|
private BladeRedis bladeRedis;
|
@Resource
|
private IDockingSysIntParamService dockingSysIntParamService;
|
@Resource
|
private IDockingSysIntHeaderService dockingSysIntHeaderService;
|
@Autowired(required = false)
|
private MdmSearchItemCodeProvider mdmSearchItemCodeProvider;
|
@Autowired
|
HttpServletRequest request;
|
@Override
|
public void DockingDataSyncScheduing() {
|
|
// insertCache2();
|
initPushDataTaks(1);
|
sendpushDataForService();
|
|
}
|
|
/***
|
*
|
*/
|
@Override
|
public void DockingClassSyncScheduing() {
|
initPushDataTaks(2);//分类推送
|
sendpushClsfForService();
|
}
|
|
/***
|
* 手动同步
|
* @param oids
|
* @return
|
*/
|
@Transactional(rollbackFor = Throwable.class)
|
@Override
|
public R sendData(String oids) {
|
VciBaseUtil.alertNotNull(oids,"系统集成基础信息数据对象",oids,"系统集成基础信息的主键");
|
List<String> dockingTaskOidList=new ArrayList<>();
|
dockingTaskOidList= VciBaseUtil.str2List(oids);
|
List<DockingTask> newDockingTasks= this.dockingTaskService.listByIds(dockingTaskOidList);
|
Map<String,List<DockingTask>> typeDockingTaskMap=new HashMap<>();
|
newDockingTasks.stream().forEach(newDockingTaskDO->{
|
String btmId=newDockingTaskDO.getBtmId();
|
if(btmId.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
|
List<DockingTask> dockingTaskList= typeDockingTaskMap.get(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
|
if(CollectionUtils.isEmpty(dockingTaskList)){
|
dockingTaskList=new ArrayList<>();
|
}
|
dockingTaskList.add(newDockingTaskDO);
|
typeDockingTaskMap.put(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT),dockingTaskList);
|
}else{
|
List<DockingTask> dockingTaskDOList= typeDockingTaskMap.get("data");
|
if(CollectionUtils.isEmpty(dockingTaskDOList)){
|
dockingTaskDOList=new ArrayList<>();
|
}
|
dockingTaskDOList.add(newDockingTaskDO);
|
typeDockingTaskMap.put("data",dockingTaskDOList);
|
}
|
});
|
typeDockingTaskMap.keySet().forEach(type->{
|
List<DockingTask> DockingTaskList=typeDockingTaskMap.get(type);
|
if(!CollectionUtils.isEmpty(DockingTaskList)){
|
if(type.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
|
this.sendpushClsfForService(DockingTaskList);
|
}else{
|
this.sendpushDataForService(DockingTaskList);
|
}
|
}
|
});
|
return R.success("手动推送完成,请核对是否推送成功");
|
}
|
private SearchItemDataVO initData(String status,String itemCode,String mmCode){
|
SearchItemDataVO searchItemDataVO=new SearchItemDataVO();
|
searchItemDataVO.setLastchangedon(new Date());
|
searchItemDataVO.setLastchangedby("19831133");
|
searchItemDataVO.setCreatby("19831133");
|
searchItemDataVO.setCreatedon(new Date());
|
searchItemDataVO.setIsenabled(status);
|
searchItemDataVO.setMaterialcode("XMDH0001");
|
searchItemDataVO.setStatus("1");
|
searchItemDataVO.setProjectcode("3333");
|
searchItemDataVO.setProjectitem(itemCode);
|
searchItemDataVO.setMmodelcode(mmCode);
|
|
return searchItemDataVO;
|
}
|
|
public HttpServletRequest getRequest(){
|
HttpServletRequest request =null;
|
RequestAttributes requestAttributes = null;
|
try{
|
requestAttributes = RequestContextHolder.currentRequestAttributes();
|
}catch (IllegalStateException e){
|
//requestAttributes = new NonWebRequestAttributes();
|
//RequestContextHolder.setRequestAttributes(requestAttributes, true);
|
request = new MockHttpServletRequest();
|
RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request),true);
|
}finally {
|
if (requestAttributes instanceof ServletRequestAttributes) {
|
ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes)RequestContextHolder.currentRequestAttributes();
|
request = servletRequestAttributes.getRequest();
|
}
|
}
|
return request;
|
}
|
/***
|
* 同步型号代号
|
*/
|
@Override
|
public void saveItemDataSyncScheduing(String endDate) {
|
String paramString="";
|
String backString="成功";
|
String msg="成功";
|
boolean success=true;
|
SearchItemParam searchItemParam=new SearchItemParam();
|
searchItemParam.setSystag("VCI"); //调用系统标识
|
SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
String lastchangedon="";
|
if(StringUtils.isBlank(endDate)) {
|
Calendar calendar = Calendar.getInstance();
|
calendar.set(Calendar.HOUR_OF_DAY, 0);
|
calendar.set(Calendar.MINUTE, 0);
|
calendar.set(Calendar.SECOND, 0);
|
log.info("查询时间------->"+calendar.getTime());
|
lastchangedon= dft.format(calendar.getTime());
|
}else{
|
lastchangedon=endDate;
|
}
|
searchItemParam.setLastchangedon(lastchangedon);
|
searchItemParam.setStatus(itemStatus);//
|
Map<String,String>searchDataMap= VciBaseUtil.objectToMapString(searchItemParam);
|
try {
|
paramString=JSONObject.toJSON(searchItemParam).toString();
|
SearchItemVO searchItemVO = mdmSearchItemCodeProvider.getppModelByElem(searchItemParam);
|
/*SearchItemVO searchItemVO=new SearchItemVO();
|
List<SearchItemDataVO> data=new ArrayList<>();
|
SearchItemDataVO searchItemDataVO1=initData("1","","pro-00001");
|
SearchItemDataVO searchItemDataVO2=initData("0","item-00001","");
|
data.add(searchItemDataVO1);
|
data.add(searchItemDataVO2);
|
searchItemVO.setData(data);
|
searchItemVO.setCode("200");
|
searchItemVO.setMsg("");*/
|
if (searchItemVO != null) {
|
paramString = JSONObject.toJSON(searchItemVO).toString();
|
try {
|
//免密登录申请token，request中添加用户信息
|
try {
|
passwordFreeLoginService.pwdFreeLoginByBoolean(systemId.toLowerCase(Locale.ROOT), getRequest());
|
} catch (Throwable e) {
|
throw new Throwable("用户鉴权失败.");
|
}
|
final BladeUser user = AuthUtil.getUser();
|
List<CodeClassify> codeClassifyList = codeClassifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().in(CodeClassify::getId, btmName));
|
if (CollectionUtils.isEmpty(codeClassifyList)) {
|
throw new Throwable("分类未查询到");
|
}
|
CodeClassify codeClassify = codeClassifyList.get(0);
|
CodeClassifyTemplateVO templateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(codeClassify.getOid());
|
if (templateVO == null || StringUtils.isBlank(templateVO.getOid())) {
|
throw new Throwable("根据传输的分类，未获取MDM系统中对应模板");
|
}
|
List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) &&
|
((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
|
).collect(Collectors.toList());
|
List<SearchItemDataVO> dataList = searchItemVO.getData();
|
Map<String, SearchItemDataVO> dataVOMap = new HashMap<>();
|
List<String> itemCodeList = new ArrayList<>();
|
ApplyDatasVO allDatasVO = new ApplyDatasVO();
|
List<ApplyDataVO> allObjectList = new ArrayList<>();
|
if (!CollectionUtils.isEmpty(dataList)) {
|
dataList.stream().forEach(searchItemDataVO -> {
|
String itemCode = StringUtils.isNotBlank(searchItemDataVO.getProjectitem()) ? searchItemDataVO.getProjectitem() : searchItemDataVO.getMmodelcode();//项目代号
|
dataVOMap.put(itemCode, searchItemDataVO);
|
itemCodeList.add(itemCode);
|
});
|
String tableName = "";
|
R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(codeClassify.getBtmTypeId());
|
if (!r.isSuccess()) {
|
throw new Throwable(r.getMsg());
|
}
|
BtmTypeVO btmTypeVO = r.getData();
|
if (btmTypeVO == null) {
|
throw new Throwable("根据业务类型未查询到业务类型对象！");
|
}
|
tableName = btmTypeVO.getTableName();
|
if (StringUtils.isBlank(tableName)) {
|
throw new Throwable("根据业务类型未查询到业务类型相关联的表");
|
}
|
StringBuffer sb = new StringBuffer();
|
sb.append(" select * from ");
|
sb.append(tableName);
|
sb.append(" where 1=1");
|
sb.append(" and lastr=1 and lastv=1");
|
sb.append(" and codeclsfid = '" + codeClassify.getOid() + "' ");
|
sb.append(" and " + VciBaseUtil.toInSql(attrKey, itemCodeList.toArray(new String[]{})));
|
List<Map<String, String>> newDataList = commonsMapper.queryByOnlySqlForMap(sb.toString());
|
//List<BaseModel> baseModelList=new ArrayList<>();
|
Map<String, BaseModel> baseModelMap = new HashMap<>();
|
newDataList.stream().forEach(dataMap -> {
|
BaseModel baseModel = new BaseModel();
|
Map<String, String> newDateMap = new CaseInsensitiveMap<>(dataMap);
|
DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(newDateMap, baseModel, true, user);
|
DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel, user);
|
//baseModelList.add(baseModel);
|
|
String attrKeyValue = newDateMap.getOrDefault(attrKey, "");
|
baseModelMap.put(attrKeyValue, baseModel);
|
});
|
|
List<ApplyDataVO> addObjectList = new ArrayList<>();
|
List<ApplyDataVO> editObjectList = new ArrayList<>();
|
dataVOMap.forEach((key, value) -> {
|
if (baseModelMap.containsKey(key)) {
|
BaseModel baseModel = baseModelMap.get(key);
|
changeObjectToMap(value, baseModel.getId(), user, "editstatus", editObjectList);
|
} else {
|
changeObjectToMap(value, "", user, "create", addObjectList);
|
}
|
});
|
allObjectList.addAll(addObjectList);
|
allObjectList.addAll(editObjectList);
|
allDatasVO.setObject(allObjectList);
|
LinkedList<XMLResultDataObjectDetailDO> allResultDataObjectDetailDOS = new LinkedList<>();
|
if (!CollectionUtils.isEmpty(addObjectList)) {
|
//规则的主键需要去获取
|
CodeClassifyFullInfoBO classifyFullInfo = codeClassifyService.getClassifyFullInfo(codeClassify.getOid());
|
if (classifyFullInfo == null || classifyFullInfo.getCurrentClassifyVO() == null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())) {
|
log.info("classifyFullInfo:" + "根据传输的分类，未获取分类相关信息");
|
throw new Throwable("根据传输的分类，未获取分类相关信息");
|
}
|
CodeRuleVO ruleVO = mdmEngineServiceI.getCodeRuleByClassifyFullInfo(classifyFullInfo);
|
if (ruleVO == null || StringUtils.isBlank(ruleVO.getOid())) {
|
throw new Throwable("根据传输的分类，未获取MDM系统中对应规则");
|
}
|
DataObjectVO dataObjectVO = new DataObjectVO();
|
ApplyDatasVO applyDatasVO = new ApplyDatasVO();
|
applyDatasVO.setObject(addObjectList);
|
LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
|
this.getConfigDatas(systemId, btmName, applyDatasVO, attrVOS, dataObjectVO);
|
CodeOrderDTO orderDTO = new CodeOrderDTO();
|
orderDTO.setCodeClassifyOid(codeClassify.getOid());//分类主键
|
//码段设置
|
List<SectionVO> section = new ArrayList<>();
|
SectionVO sectionVO = new SectionVO();
|
sectionVO.setValue(secValue);
|
sectionVO.setName(secName);
|
section.add(sectionVO);
|
log.info("end：规则获取完毕");
|
List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(section, ruleVO, classifyFullInfo);
|
log.info("end：码段获取完毕");
|
orderDTO.setSecDTOList(codeOrderSecDTOList);//分类码段
|
mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs, false);
|
allResultDataObjectDetailDOS.addAll(resultDataObjectDetailDOs);
|
}
|
//更新数据（更新状态）
|
if (!CollectionUtils.isEmpty(editObjectList)) {
|
DataObjectVO dataObjectVO = new DataObjectVO();
|
ApplyDatasVO applyDatasVO = new ApplyDatasVO();
|
applyDatasVO.setObject(editObjectList);
|
LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
|
CodeClassifyVO codeClassifyVO = new CodeClassifyVO();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassify, codeClassifyVO);
|
this.getConfigDatas(systemId, btmName, applyDatasVO, attrVOS, dataObjectVO);
|
mdmIOService.batchSyncEditDatas(codeClassifyVO, dataObjectVO, resultDataObjectDetailDOs, false);
|
allResultDataObjectDetailDOS.addAll(resultDataObjectDetailDOs);
|
}
|
Object paramObject = JSONObject.toJSON(allDatasVO);
|
paramString = Func.isEmpty(paramObject) ? "" : paramObject.toString();
|
Object backObject = JSONObject.toJSON(allResultDataObjectDetailDOS);
|
backString = Func.isEmpty(backObject) ? "" : backObject.toString();
|
}
|
} catch (Throwable e) {
|
e.printStackTrace();
|
;
|
log.error("查询失败--->" + e);
|
success = false;
|
backString = "查询失败--->" + e;
|
msg = "查询失败--->" + e;
|
throw new VciBaseException(e.getMessage());
|
} finally {
|
try {
|
//记录日志
|
this.saveLogs(systemId, systemId, paramString, backString, success, msg, "queryData");
|
} catch (Throwable e) {
|
e.printStackTrace();
|
log.error(e.getMessage());
|
throw new VciBaseException(e.getMessage());
|
}
|
}
|
}else{
|
throw new Throwable("接口未返回信息");
|
}
|
}catch (Throwable e1){
|
e1.printStackTrace();
|
log.error("查询失败--->" + e1);
|
//paramString="";
|
success = false;
|
backString = "查询失败--->" + e1;
|
msg = "查询失败--->" + e1;
|
try {
|
//记录日志
|
this.saveLogs(systemId, systemId, paramString, backString, success, msg, "queryData");
|
} catch (Throwable e) {
|
e.printStackTrace();
|
log.error(e.getMessage());
|
throw new VciBaseException(e.getMessage());
|
}
|
}
|
}
|
|
/***
|
* 记录日志信息
|
* @param systemId
|
* @param parmaData
|
* @param result
|
* @return
|
*/
|
private void saveLogs(String systemId,String systemName,String parmaData, String result,boolean isSucess,String msg,String operation){
|
//记录日志信息
|
DockingLog dockingLoge=new DockingLog();
|
//String oid=redisService.getUUIDEveryDay();
|
dockingLoge.setSystemCode(StringUtils.isBlank(systemId)?"-":systemId);//设置系统标识
|
dockingLoge.setSystemName(StringUtils.isBlank(systemName)?"-":systemName);
|
dockingLoge.setMsg(msg);//日志消息
|
dockingLoge.setClassifyId("-");//分类编号
|
dockingLoge.setClassifyName("-");//分类名称
|
dockingLoge.setClassifyOid("-");//分类主键
|
dockingLoge.setUniqueCode("-");//唯一标识
|
dockingLoge.setSystemOid("-");//系统标识
|
// dockingLogeDO.setName(operation);
|
//dockingLogeDO.setOid(oid);//日志主键
|
dockingLoge.setParamString(parmaData);//参数信息
|
dockingLoge.setReturnString(result);//返回信息
|
dockingLoge.setType(operation);//日志操作类型
|
dockingLoge.setCreateTime(new Date());
|
if(isSucess) {
|
dockingLoge.setInterfaceStatus("true");//接口集成状态
|
}else{
|
dockingLoge.setInterfaceStatus("false");//接口集成状态
|
}
|
dockingLogeService.save(dockingLoge);
|
log.info("集成推送数据成功,systemId:"+systemId+",systemname:"+systemName+",operation:"+operation+",param:"+parmaData);
|
}
|
|
/***
|
* 根据传入的参数信息校验码段规则
|
*/
|
private List<CodeOrderSecDTO> getRuleCodeOrderSecDTOs(List<SectionVO> SectionVOList, CodeRuleVO ruleVO, CodeClassifyFullInfoBO classifyFullInfo) throws Throwable{
|
List<CodeBasicSecVO> codeBasicSecVOS= ruleVO.getSecVOList();
|
Map<String,String> sectionVOMap=new HashMap<>();
|
SectionVOList.stream().forEach(SectionVO->{
|
sectionVOMap.put(SectionVO.getName(),SectionVO.getValue());
|
});
|
//Map<String,CodeClassifyVO> codeClassifyVOMap= classifyFullInfo.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getId(), t -> t,(o1, o2)->o2));
|
List<CodeOrderSecDTO> codeOrderSecDTOList=new ArrayList<>();
|
Map<String,String> errorMap=new HashMap<>();
|
for(CodeBasicSecVO codeBasicSecVO: codeBasicSecVOS) {
|
String sectype = codeBasicSecVO.getSecType();
|
String newSecName=codeBasicSecVO.getName();
|
String classifySecOid= codeBasicSecVO.getOid();
|
String message="";
|
if (!sectype.equals(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue())) {
|
String name = codeBasicSecVO.getName();
|
String sectypeText = codeBasicSecVO.getSecTypeText();
|
log.info("码段名称:"+name);
|
log.info("描述:"+sectypeText);
|
CodeOrderSecDTO CodeOrderSecDTO = new CodeOrderSecDTO();
|
if (sectionVOMap.containsKey(name)) {
|
CodeOrderSecDTO.setSecOid(codeBasicSecVO.getOid());
|
String sectypeValue = sectionVOMap.get(name);
|
log.info("码段值:"+sectypeValue);
|
CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(sectype);
|
if(CODE_CLASSIFY_SEC.equals(secType)) {//如果是分类的话，则需要匹配传过来的分类代号与
|
//先简称是否有关联模板，有模板要先删除
|
List<CodeClassifyValue> codeClassifyValueDOList = codeClassifyValueService.list(Wrappers.<CodeClassifyValue>query().lambda().eq(CodeClassifyValue::getCodeClassifySecOid,classifySecOid));
|
|
if (!CollectionUtils.isEmpty(codeClassifyValueDOList)) {
|
Map<String, CodeClassifyValue> codeClassifyValueDOMap = codeClassifyValueDOList.stream().collect(Collectors.toMap(s -> s.getId(), t -> t, (o1, o2) -> o2));
|
if(codeClassifyValueDOMap.containsKey(sectypeValue)){
|
CodeClassifyValue codeClassifyValue= codeClassifyValueDOMap.get(sectypeValue);
|
sectypeValue=codeClassifyValue.getOid();
|
}else {
|
//throw new Throwable("传入的分类码段：【" + name + " 值：" + sectypeValue + "】，不符合当前分类层级代号");
|
message="传入的分类码段：【" + name + " 值：" + sectypeValue + "】，不符合当前分类层级代号";
|
errorMap.put("error",errorMap.getOrDefault("error","")+";"+message);
|
}
|
}
|
}
|
if(StringUtils.isBlank(sectypeValue)){
|
message="传入的分类码段：【" + name + " 】的值不允许为空";
|
errorMap.put("error",errorMap.getOrDefault("error","")+";"+message);
|
}
|
CodeOrderSecDTO.setSecValue(sectypeValue);
|
codeOrderSecDTOList.add(CodeOrderSecDTO);
|
} else {
|
message="传入的码段规则缺少" + name;
|
errorMap.put("error",errorMap.getOrDefault("error","")+";"+message);
|
}
|
}
|
}
|
if(errorMap.size()>0){
|
throw new Throwable(errorMap.getOrDefault("error",""));
|
}
|
return codeOrderSecDTOList;
|
}
|
/***
|
* 读取属性映射配置信息
|
* @param systemId
|
* @param libray
|
* @param applyDatasVO
|
* @param codeClassifyTemplateAttrVOList
|
* @param dataObjectVO
|
* @throws Throwable
|
*/
|
public void getConfigDatas(String systemId,String libray, ApplyDatasVO applyDatasVO,List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList,DataObjectVO dataObjectVO) throws Throwable {
|
|
LinkedHashMap<String,LinkedHashMap<String,String>> dataKeyValueMap=new LinkedHashMap<>();
|
//如果将数据转换成所需要的数据对象
|
Map<String, String> attrMapConfigMap=new HashMap<>();
|
Map<String, String> propMaps=new HashMap<>();
|
log.info("开始读取系统配置文件 start");
|
Map<String, String> stringStringMap=attributeMapConfig.getSystem_attrmap();
|
log.info("集成系统属性映射配置文件条目数-》"+stringStringMap.size());
|
//stringStringMap.put("RLM","D:\\RLM.xml");
|
if(!CollectionUtils.isEmpty(stringStringMap)) {
|
List<LibraryClsfDO> libraryClsfDOList=new ArrayList<>();
|
try {
|
log.info("info：需要读取配置文件");
|
LibraryDO libraryDO = gennerAttrMapUtil.getNewInstance().gennerAttrMapBySystem(systemId, stringStringMap);
|
libraryClsfDOList = libraryDO.getClsf();
|
} catch (Throwable e) {
|
e.printStackTrace();
|
throw new Throwable("集成系统标识为：【" + systemId + "】，分类库为:【" + libray + "】的集成属性配置文件读取失败");
|
}
|
String path = stringStringMap.get(systemId);
|
if (!CollectionUtils.isEmpty(libraryClsfDOList)) {
|
Map<String, List<ClsfAttrMappingDO>> libPropMaps = libraryClsfDOList.stream().collect(Collectors.toMap(LibraryClsfDO::getLibrary, LibraryClsfDO::getProp, (key1, key2) -> key2));
|
log.info("根据参数：libray：-》" + libray + "从配置文件中找对应属性映射配置");
|
if (libPropMaps.containsKey(libray.toUpperCase(Locale.ROOT))) {
|
log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息");
|
List<ClsfAttrMappingDO> clsfAttrMappingDOList = libPropMaps.get(libray.toUpperCase(Locale.ROOT));
|
propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2));
|
log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息,属性映射条目数+" + clsfAttrMappingDOList.size());
|
} else {
|
throw new Throwable("根据系统标识【" + systemId + "】找到对应的配置文件:【" + path + "】，但未获取到对应的库【" + libray + "】属性映射信息配置");
|
}
|
}else{
|
throw new Throwable("根据系统标识【" + systemId + "】找到对应的配置文件:【" + path + "】，但未获取到对应的库【" + libray + "】属性映射信息配置");
|
}
|
}else{
|
throw new Throwable("未获取到集成属性映射系统配置信息");
|
}
|
log.info("根据参数：libray：-》"+libray+"从配置文件中找对应属性映射配置 end ");
|
LinkedList<String> rowNameList=new LinkedList<>();
|
LinkedHashMap<String,Integer> filedIndexMap=new LinkedHashMap<>();
|
//根据分类模板组织数据
|
final int[] index = {0};
|
try {
|
//除去默认的属性.还有只有具有分类注入的才过滤出来
|
codeClassifyTemplateAttrVOList = codeClassifyTemplateAttrVOList.stream().filter(
|
s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) &&
|
((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
|
).collect(Collectors.toList());
|
codeClassifyTemplateAttrVOList.stream().forEach(codeClassifyTemplateAttrVO -> {
|
String attrName = codeClassifyTemplateAttrVO.getName();
|
String field = codeClassifyTemplateAttrVO.getId();
|
rowNameList.add(attrName);
|
filedIndexMap.put(field, index[0]++);
|
});
|
dataObjectVO.setColName(rowNameList);//放入属性
|
attrMapConfigMap.putAll(propMaps);
|
LinkedList<RowDatas> rowDataList = new LinkedList<>();
|
List<ApplyDataVO> applyDataVOList=new ArrayList<>();
|
|
if(!CollectionUtils.isEmpty(applyDatasVO.getObject())){
|
applyDataVOList=applyDatasVO.getObject();
|
}
|
//Map<String, List<ProppertyVO>> dataPropMap = applyDataVOList.stream().collect(Collectors.toMap(ApplyDataVO::getId, ApplyDataVO::getProp, (key1, key2) -> key2));
|
final int[] rowIndex = {0};
|
applyDataVOList.stream().forEach(applyDataVO -> {
|
rowIndex[0]++;
|
RowDatas rowDatas = new RowDatas();
|
rowDatas.setOid(applyDataVO.getId());
|
rowDatas.setCreator(applyDataVO.getCreator());
|
rowDatas.setEditor(applyDataVO.getEditor());
|
rowDatas.setCode(applyDataVO.getCode());
|
rowDatas.setOperation(applyDataVO.getOperate());
|
rowDatas.setStatus(applyDataVO.getStatus());
|
rowDatas.setRowIndex(rowIndex[0] + "");
|
List<ProppertyVO> proppertyVOList = applyDataVO.getProp();
|
|
LinkedHashMap<Integer, String> integerValueMap = new LinkedHashMap<>();
|
Map<String, String> filedValueMap = new HashMap<>();
|
if (!CollectionUtils.isEmpty(proppertyVOList)) {
|
Map<String, String> sourceKeyValueMap = proppertyVOList.stream().collect(Collectors.toMap(ProppertyVO::getKey, ProppertyVO::getValue, (key1, key2) -> key2));
|
Map<String, String> keyValueMap = new HashMap<>();
|
//判断attrMapConfigMap是否有值，如果没有则说明基础默认的是编码系统字段
|
if (!CollectionUtils.isEmpty(attrMapConfigMap)) {
|
sourceKeyValueMap.keySet().forEach(sourceKey -> {
|
String dataValue = sourceKeyValueMap.get(sourceKey);
|
if (attrMapConfigMap.containsKey(sourceKey)) {
|
String targetKey = attrMapConfigMap.get(sourceKey);
|
keyValueMap.put(targetKey, StringUtils.isBlank(dataValue)?"":dataValue);
|
}
|
});
|
} else {
|
sourceKeyValueMap.forEach((filed,value)->{
|
keyValueMap.put(filed,StringUtils.isBlank(value)?"":value) ;
|
});
|
}
|
|
filedIndexMap.forEach((attrKey, column) -> {
|
String keyValue = "";
|
if (keyValueMap.containsKey(attrKey)) {
|
keyValue =StringUtils.isBlank(keyValueMap.get(attrKey))?"":keyValueMap.get(attrKey);
|
}
|
integerValueMap.put(column, keyValue);
|
filedValueMap.put(attrKey, keyValue);
|
});
|
}
|
rowDatas.setData(integerValueMap);
|
rowDatas.setFiledValue(filedValueMap);
|
rowDataList.add(rowDatas);
|
});
|
dataObjectVO.setRowData(rowDataList);
|
}catch (Throwable e){
|
throw new Throwable("组织数据映射值失败");
|
}
|
}
|
private void changeObjectToMap(SearchItemDataVO searchItemDataVO, String code, BladeUser user,String operation,List<ApplyDataVO> object){
|
ApplyDataVO applyDataVO=new ApplyDataVO();
|
List<ProppertyVO> propList=new ArrayList<>();
|
//String status= searchItemDataVO.getStatus();//数据状态 字符型，枚举值；制单：0；审批中：1；通过：2；驳回：3；
|
|
String mmodelCode=searchItemDataVO.getMmodelcode();//制造型号代号
|
initProperty("mmodelcode","",mmodelCode,propList);
|
String projectCode= searchItemDataVO.getProjectcode();//项目编码
|
initProperty("projectcode","",projectCode,propList);
|
String projectItem=searchItemDataVO.getProjectitem();//项目代号
|
initProperty("projectitem","",projectItem,propList);
|
String materialCode=searchItemDataVO.getMaterialcode();//产品编码
|
initProperty("materialcode","",materialCode,propList);
|
//组合属性的处理
|
initProperty(attrKey,"",StringUtils.isNotBlank(projectItem)?projectItem:mmodelCode,propList);
|
String creatBy=searchItemDataVO.getCreatby();//创建者
|
Date cretaeDon= searchItemDataVO.getCreatedon();//创建日期 日期型，如：2023-09-08 19:24:11
|
String lastchangeBy=searchItemDataVO.getLastchangedby();//更改者
|
Date lastchangeDon=searchItemDataVO.getLastchangedon();//更改时间 日期型，如：2023-09-08 19:24:11
|
String isenabled= searchItemDataVO.getIsenabled();//字符型，枚举值；停用：0；启用：1；
|
applyDataVO.setOperate(operation);
|
applyDataVO.setCode(code);
|
if(isenabled.equals("0")){
|
applyDataVO.setStatus(CodeDefaultLC.DISABLE.getValue());
|
}else{
|
applyDataVO.setStatus(CodeDefaultLC.RELEASED.getValue());
|
}
|
applyDataVO.setId(VciBaseUtil.getPk());
|
applyDataVO.setEditor(lastchangeBy);
|
applyDataVO.setCreator(creatBy);
|
applyDataVO.setProp(propList);
|
object.add(applyDataVO);
|
}
|
private void initProperty(String key,String text,String value,List<ProppertyVO> propList){
|
ProppertyVO vo=new ProppertyVO();
|
vo.setKey(key);
|
vo.setText(text);
|
vo.setValue(value);
|
propList.add(vo);
|
}
|
/***
|
* 查询redis中数据，对比后插入dockingtask
|
* @param type
|
*/
|
private void initPushDataTaks(int type){
|
initSysadmin();
|
List<DockingSystemConfig> dockingSystemConfigList = dockingSystemConfigService.list(
|
Wrappers.<DockingSystemConfig>query().lambda().eq(DockingSystemConfig::getUsedFlag,"true")
|
.eq(DockingSystemConfig::getPushType,type==2?"2":"1").eq(DockingSystemConfig::getDataFlowType, SysIntegrationDataFlowTypeEnum.PUSH.getValue()));//2是代表分类推送，1是代表数据推送
|
|
if(CollectionUtils.isEmpty(dockingSystemConfigList)){
|
String title=type==2?"分类推送":"数据推送";
|
log.info("info->所有集成系统，未查询到相关的【"+title+"】的接口配置信息，配置");
|
return;
|
}
|
Map<String ,List<DockingSystemConfig>> sysIntInfoDOMap = new HashMap<>();//key=classifyoid,value=list<map>
|
for (DockingSystemConfig dockingSystemConfig:dockingSystemConfigList){
|
String classifyOid= dockingSystemConfig.getClassifyOid();
|
String codeclassifOid=codeClassifyService.selectLeafByPid(classifyOid);
|
List<String> codeList= VciBaseUtil.str2List(codeclassifOid);
|
codeList.stream().forEach(oid -> {
|
List<DockingSystemConfig> dockingSystemList = sysIntInfoDOMap.get(oid);
|
if(Func.isEmpty(dockingSystemList)){
|
dockingSystemList=new ArrayList<>();
|
}
|
dockingSystemList.add(dockingSystemConfig);
|
sysIntInfoDOMap.put(oid,dockingSystemList);
|
});
|
}
|
sysIntInfoDOMap.forEach((classifyOid,effectiveSysIntInfoVOs)->{
|
//根据类型去查询需要集成的分类或者数据
|
LambdaQueryWrapper<DockingData> queryWrapper = Wrappers.<DockingData>lambdaQuery();
|
queryWrapper.eq(DockingData::getSendFlag,"false");
|
if(type==2){
|
queryWrapper.eq(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY);
|
}else {
|
queryWrapper.ne(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY);
|
queryWrapper.eq(DockingData::getClassifyOid,classifyOid);
|
}
|
List<DockingData> dataList = dockingDataService.list(queryWrapper);
|
for (DockingData mapi:dataList){
|
WebUtil.setPersistence(false);
|
String dataoid = mapi.getOid();//data对象的oid
|
String dataClassifyOid = 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(!dataClassifyOid.equals(classifyOid)){
|
continue;
|
}
|
/*if(type==2){
|
curentClassOid=btmoid;
|
}else{
|
curentClassOid=classifyoid;
|
}*/
|
/*//根据当前数据的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(dataClassifyOid);//数据所在分类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;
|
}
|
}
|
