package com.vci.ubcs.code.service.impl;
|
|
|
import cn.hutool.json.XML;
|
import com.alibaba.fastjson.JSONObject;
|
import com.vci.ubcs.code.constant.MdmDuckingConstant;
|
import com.vci.code.dao.*;
|
import com.vci.code.model.*;
|
import com.vci.code.service.*;
|
import com.vci.code.utils.*;
|
import com.vci.starter.web.enumpck.UserSecretEnum;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.BaseResult;
|
import com.vci.starter.web.pagemodel.DataGrid;
|
import com.vci.starter.web.pagemodel.PageHelper;
|
import com.vci.starter.web.pagemodel.SessionInfo;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
|
import com.vci.ubcs.code.dao.*;
|
import com.vci.ubcs.code.model.*;
|
import com.vci.ubcs.code.service.*;
|
import com.vci.ubcs.code.utils.*;
|
import com.vci.web.pageModel.BatchCBO;
|
import com.vci.web.redis.RedisService;
|
import com.vci.web.service.WebBoServiceI;
|
import com.vci.web.util.PlatformClientUtil;
|
import com.vci.web.util.WebUtil;
|
import org.apache.commons.io.FileUtils;
|
import org.apache.commons.lang.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springblade.code.dao.*;
|
import com.vci.ubcs.code.dto.DockingPreApplyDataDTO;
|
import com.vci.ubcs.code.dto.DockingPreApplyDataInfoDTO;
|
import org.springblade.code.model.*;
|
import org.springblade.code.service.*;
|
import org.springblade.code.utils.*;
|
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
|
import com.vci.ubcs.code.vo.pagemodel.SysIntInfoVO;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.LinkedMultiValueMap;
|
import org.springframework.util.MultiValueMap;
|
import plm.bs.bom.clientobject.ClientBusinessObject;
|
|
import javax.annotation.Resource;
|
import java.io.File;
|
import java.io.IOException;
|
import java.util.*;
|
import java.util.concurrent.CountDownLatch;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.stream.Collectors;
|
|
import static com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant.*;
|
|
/**
|
* 主题库集成服务
|
* @author wangyi
|
* @date 2022-03-20
|
*/
|
@Service
|
public class CodeDuckingServiceImpl implements CodeDuckingServiceI {
|
|
/**
|
* 日志
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
/**
|
* 集成推送任务数据操作层
|
*/
|
@Resource
|
private DockingTaskDaoI dockingTaskDaoI;
|
|
/**
|
* 集成推送任务数据操作层
|
*/
|
@Resource
|
private DockingDataDaoI dockingDataDaoI;
|
|
/**
|
* 集成日志数据操作层
|
*/
|
@Resource
|
private DockingLogeDaoI dockingLogeDaoI;
|
|
/**
|
* 集成接口head数据操作层
|
*/
|
@Resource
|
private SysIntHeaderDaoI sysIntHeaderDaoI;
|
|
/**
|
* 模板属性数据操作层
|
*/
|
@Resource
|
@Lazy
|
private CodeClassifyDaoI codeClassifyDaoI;
|
|
|
/**
|
* 业务类型操作的服务
|
*/
|
@Autowired
|
@Lazy
|
private WebBoServiceI boService;
|
|
/**
|
* 缓存服务
|
*/
|
@Autowired
|
private RedisService redisService;
|
|
/**
|
* 数据服务
|
*/
|
@Autowired(required = false)
|
@Lazy
|
private MdmEngineServiceI mdmEngineServiceI;
|
|
/**
|
* 编码预申请服务
|
*/
|
@Autowired(required = false)
|
@Lazy
|
private DockingPreApplyDataServiceI dockingPreApplyDataServiceI;
|
|
/**
|
* 要推送系统的服务
|
*/
|
@Autowired
|
private SysIntInfoServiceI sysIntInfoServiceI;
|
|
/**
|
* 分类服务
|
*/
|
@Autowired
|
private CodeClassifyServiceI codeClassifyServiceI;
|
|
|
@Value("${docking.tuhao:tuhao}")
|
public String tuhao;
|
|
@Value("${docking.tranTemp:D:\\PLT-2022\\web\\tranTemp}")
|
public String tranTemp;
|
|
@Value("${docking.preXmlTemp:D:\\PLT-2022\\web\\preXmlTemp}")
|
public String preXmlTemp;
|
|
/**
|
* 二、1、2、3、4、
|
* 处理预申请数据
|
* @param xmlDatas
|
* @return 接收的xmlDate
|
*/
|
@Override
|
public String applicateCode(String xmlDatas){
|
|
long start = System.currentTimeMillis();
|
|
Map<String,Object> datasMap = null;
|
|
//解析xmlData
|
try {
|
datasMap = XmlUtil.readPreXmlData(xmlDatas);
|
}catch (Exception e){
|
logger.info("接收预申请数据，解析xmlData失败，xmlDatas: "+xmlDatas+",e: "+e.getMessage());
|
e.printStackTrace();
|
//返回提示
|
return XmlUtil.writePreBackXmlData(MdmDuckingConstant.XML_CODE_FAIL,"解析xmlData失败,e: "+e.getMessage(),null);
|
}
|
|
List<XmlData> xmlDataList = Collections.synchronizedList(new ArrayList<XmlData>());
|
String systemid = datasMap.getOrDefault(MdmDuckingConstant.XML_SYSTEMID,"").toString();
|
List<Map<String,Object>> dataMapList = (ArrayList<Map<String,Object>>)datasMap.get(MdmDuckingConstant.XML_DATAS);
|
|
//记录这次数据信息,并且把xmldata写入文件
|
String currentDate = DateUtils.getCurrentDate(DateUtils.DATE_TO_STRING_DETAIAL_PATTERN);
|
File preXmlFile = new File(preXmlTemp+ File.separator+systemid+"-"+currentDate+".xml");
|
|
try {
|
FileUtils.write(preXmlFile, xmlDatas);
|
}catch (Exception e){
|
logger.error(currentDate+" 接收"+systemid+"系统预申请数据，写入文件失败！e:"+e.getMessage()+",xmlDatas: "+xmlDatas);
|
e.printStackTrace();
|
}
|
|
//处理每一条申请的数据
|
ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()+1);
|
|
SessionInfo sessionInfo = WebUtil.getSessionInfo();
|
CountDownLatch countDownLatch = new CountDownLatch(dataMapList.size());
|
for (int i =0;i<dataMapList.size();i++){
|
Map<String,Object> dataMap = dataMapList.get(i);
|
pool.execute(()-> {
|
String unique = dataMap.getOrDefault(MdmDuckingConstant.XML_UNIQUE,"").toString();
|
String type = dataMap.getOrDefault(MdmDuckingConstant.XML_TYPE,"").toString();
|
|
//要插入的data
|
DockingPreApplyDataDTO dockingPreApplyDataDO = new DockingPreApplyDataDTO();
|
//要插入的datainfo
|
List<DockingPreApplyDataInfoDTO> dockingPreApplyDataInfoDOList = new ArrayList<DockingPreApplyDataInfoDTO>();
|
XmlData xmlData_ = new XmlData();
|
|
try {
|
WebUtil.setSessionInfo(sessionInfo);
|
|
String num = "";
|
String datacode = "";
|
String datamsg = "";
|
String datamsglog = "";
|
|
//state=400，处理成功，没有找到编码
|
datamsg = "接收预申请数据，未查询到对应编码，赋码后推送编码信息";
|
datacode = MdmDuckingConstant.XML_STATE_400;
|
XmlData xmlData = new XmlData();
|
xmlData.setState(MdmDuckingConstant.XML_STATE_400);
|
xmlData.setMsg(datamsg);
|
xmlData.setUnique(unique);
|
xmlData.setNum(null);
|
logger.info(datamsg+"，data: "+dataMap.get(unique)+",num: ");
|
xmlData_ = xmlData;
|
|
//如果是MPM集成过来的数据，unique作为图号查询
|
if(MdmDuckingConstant.XML_SYSTEMID_MPM.equals(systemid)&& StringUtils.isNotEmpty(unique)) {
|
|
//1、先查询这个unique根据图号查询，有数据就就返回
|
Map conditonMap = new HashMap();
|
conditonMap.put("tuhao",unique);
|
// conditonMap.put("lcstatus",FRAMEWORK_RELEASE_RELEASED);
|
List<ClientBusinessObject> clientBusinessObjectList = boService.queryCBO(type,conditonMap);
|
|
if(clientBusinessObjectList.size()>0) {
|
num = clientBusinessObjectList.get(0).getId();
|
String lcstatus = clientBusinessObjectList.get(0).getLcStatus();
|
datamsg = "接收预申请数据，未查询到对应编码，赋码后推送编码信息";
|
if(FRAMEWORK_RELEASE_RELEASED.equals(lcstatus)) {
|
datamsg = "接收预申请数据，查询编码成功";
|
datamsglog = datamsg+"，data: " + dataMap.get(unique) + ",num: " + num;
|
datacode = MdmDuckingConstant.XML_STATE_200;
|
|
}else if(FRAMEWORK_RELEASE_SUBMIT.equals(lcstatus)){
|
datamsglog = datamsg+"，编码数据状态:已提交，data: " + dataMap.get(unique) + ",num: " + num;
|
datacode = MdmDuckingConstant.XML_STATE_400;
|
|
}else if(FRAMEWORK_RELEASE_AUDITING.equals(lcstatus)){
|
datamsglog = datamsg+"，编码数据状态:审核中，data: " + dataMap.get(unique) + ",num: " + num;
|
datacode = MdmDuckingConstant.XML_STATE_400;
|
|
}else if(FRAMEWORK_RELEASE_EDITING.equals(lcstatus)){
|
datamsglog = datamsg+"，编码数据状态:编辑中，data: " + dataMap.get(unique) + ",num: " + num;
|
datacode = MdmDuckingConstant.XML_STATE_400;
|
|
}else if(FRAMEWORK_DATA_DISABLED.equals(lcstatus)){
|
datamsglog = datamsg+"，编码数据状态:停用，data: " + dataMap.get(unique) + ",num: " + num;
|
datacode = MdmDuckingConstant.XML_STATE_400;
|
}
|
xmlData.setState(datacode);
|
xmlData.setMsg(datamsg);
|
xmlData.setUnique(unique);
|
xmlData.setNum(num);
|
logger.info(datamsglog);
|
xmlData_ = xmlData;
|
}
|
}
|
dockingPreApplyDataDO.setNum(num);
|
dockingPreApplyDataDO.setDatacode(datacode);
|
dockingPreApplyDataDO.setDatamsg(datamsg);
|
|
//2、根据unique查询DockingPreApplyDataDO，有数据就修改别的所有的usedflag=false,设置这个为true
|
//3、再插入DockingPreApplyDataDO和DockingPreApplyDataInfoDO
|
//其实，2、和3、这两步在dockingPreApplyDataServiceI.addSaveDataAndInfo（）这个方法中一起做了
|
|
String dataoid = redisService.getUUIDEveryDay();
|
// String dataoid = "1";
|
dockingPreApplyDataDO.setOid(dataoid);
|
dockingPreApplyDataDO.setPreapplyoid("1");
|
dockingPreApplyDataDO.setUniquecode(unique);
|
dockingPreApplyDataDO.setType(type);
|
dockingPreApplyDataDO.setSystemid(systemid);
|
|
Object attro = dataMap.get(MdmDuckingConstant.XML_PROS);
|
|
//要插入的datainfo
|
List<Map<String,String>> attrList = null;
|
if (attro == null) {
|
attrList = new ArrayList<Map<String,String>>();
|
}else {
|
attrList = (ArrayList<Map<String,String>>)attro;
|
}
|
|
String mpm_model = null;
|
String mpm_parttype = null;
|
String mpm_unit = null;
|
for (Map<String, String> attrMap : attrList) {
|
String datainfooid = redisService.getUUIDEveryDay();
|
// datainfooid = "1";
|
String key = attrMap.getOrDefault(MdmDuckingConstant.XML_KEY,"");
|
String mean = attrMap.getOrDefault(MdmDuckingConstant.XML_MEAN,"");
|
String text = attrMap.getOrDefault(MdmDuckingConstant.XML_TEXT,"");
|
|
DockingPreApplyDataInfoDTO dockingPreApplyDataInfoDO = new DockingPreApplyDataInfoDTO();
|
dockingPreApplyDataInfoDO.setDataoid(dataoid);
|
dockingPreApplyDataInfoDO.setOid(datainfooid);
|
dockingPreApplyDataInfoDO.setKey(key);
|
dockingPreApplyDataInfoDO.setValue(text);
|
dockingPreApplyDataInfoDO.setMean(mean);
|
dockingPreApplyDataInfoDOList.add(dockingPreApplyDataInfoDO);
|
|
//取三个值
|
if(MdmDuckingConstant.XML_MPM_MODEL.equals(key)){//取MPM规格
|
mpm_model = text;
|
dockingPreApplyDataDO.setModel(mpm_model);
|
}
|
if(MdmDuckingConstant.XML_MPM_PARTTYPE.equals(key)){//取MPM零件型号
|
mpm_parttype = text;
|
dockingPreApplyDataDO.setParttype(mpm_parttype);
|
}
|
if(MdmDuckingConstant.XML_MPM_UNIT.equals(key)){//单位
|
mpm_unit = text;
|
dockingPreApplyDataDO.setUnit(mpm_unit);
|
}
|
}
|
|
dockingPreApplyDataServiceI.addSaveDataAndInfo(dockingPreApplyDataDO, dockingPreApplyDataInfoDOList);
|
|
} catch (Exception e) {
|
String datamsg = "接收预申请数据失败！，data: "+dataMap.get(unique)+",e: "+e.getMessage();
|
XmlData xmlData = new XmlData();
|
xmlData.setState(MdmDuckingConstant.XML_STATE_500);
|
xmlData.setMsg(datamsg);
|
xmlData.setUnique(unique);
|
xmlData.setNum(null);
|
logger.error(datamsg+".dockingPreApplyDataDO： "+dockingPreApplyDataDO+",dockingPreApplyDataInfoDOList: "+dockingPreApplyDataInfoDOList);
|
xmlData_ = xmlData;
|
|
e.printStackTrace();
|
}finally {
|
xmlDataList.add(xmlData_);
|
countDownLatch.countDown();
|
}
|
});
|
}
|
|
//等待所有线程执行完成
|
try {
|
countDownLatch.await();
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}
|
|
String backXmlData = XmlUtil.writePreBackXmlData(MdmDuckingConstant.XML_CODE_SUCCESS,"接收预申请数据成功！",xmlDataList);
|
|
|
long end = System.currentTimeMillis();
|
|
//拼接返回的xmlData
|
int dataMapSise = dataMapList.size();
|
int xmlDataSise = xmlDataList.size();
|
System.out.println("========================dataMapSise： "+dataMapSise+",xmlDataSise:"+xmlDataSise);
|
|
System.out.println("========================处理预申请数据一共耗时 "+(end-start)/1000+"秒");
|
return backXmlData;
|
}
|
|
/**
|
* 四、1、2、3
|
* 查询redis中数据，对比后插入dockingtask
|
*/
|
@Override
|
public void insertCache2(){
|
|
initSysadmin();
|
|
//sysintinfo查询要推送的主题库和相关系统信息
|
Map<String, String> conditionMap = new HashMap<>();
|
conditionMap.put("usedflag","true");
|
List<SysIntInfoDO> sysIntInfoVOList = sysIntInfoServiceI.selectAll(conditionMap);
|
|
//distinct出主题库btmname,存储key-value结构的分类数据，这里的分类是主题库root节点
|
Set<String> btmtypeidSet = new HashSet<>();
|
Map<String ,List<SysIntInfoDO>> sysIntInfoDOMap = new HashMap<String ,List<SysIntInfoDO>>();//key=classifyoid,value=list<map>
|
for (SysIntInfoDO sysIntInfoVOi:sysIntInfoVOList){
|
btmtypeidSet.add(sysIntInfoVOi.getBtmTypeId());
|
List<SysIntInfoDO> SysIntInfoVOListi = sysIntInfoDOMap.get(sysIntInfoVOi.getClassifyoid());
|
if(SysIntInfoVOListi==null){
|
SysIntInfoVOListi = new ArrayList<SysIntInfoDO>();
|
}
|
SysIntInfoVOListi.add(sysIntInfoVOi);
|
sysIntInfoDOMap.put(sysIntInfoVOi.getClassifyoid(),SysIntInfoVOListi);
|
}
|
|
//查询dockingdata:oid,classifyoid,btmid,btmoid,sendtype,classifyid,classifyname
|
// List<Map> dataList = getDockingDatas();
|
VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(DockingDataDO.class);
|
queryWrapperForDO.addQueryMap("sendflag","false");
|
List<DockingDataDO> dataList = dockingDataDaoI.selectByWrapper(queryWrapperForDO);
|
|
for (DockingDataDO mapi:dataList){
|
|
WebUtil.setPersistence(false);
|
BatchCBO batchCBO = new BatchCBO();
|
|
String dataoid = mapi.getOid();//data对象的oid
|
String classifyoid = mapi.getClassifyoid();
|
String id = mapi.getId();
|
String uniquecode = mapi.getUniquecode();
|
String btmid = mapi.getBtmid();
|
String btmoid = mapi.getBtmoid();
|
String sendtype = mapi.getSendtype();
|
String classifyid = mapi.getClassifyid();
|
String classifyname = mapi.getClassifyname();
|
|
//设置uniquecode
|
if(StringUtils.isEmpty(uniquecode)){
|
uniquecode = getTuhao(btmoid);//查询图号
|
if(StringUtils.isNotEmpty(uniquecode)) {
|
updateDockingDatasUniqueCode(dataoid, uniquecode);
|
}
|
}
|
List<SysIntInfoDO> effectiveSysIntInfoVOs=new ArrayList<>();
|
String rootClassifyoid = "";
|
String pushType="1";
|
if(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equalsIgnoreCase(classifyoid)){//这个对应sysintinfo中的主题库id，如果是分类数据，就是DOCKING_DEFAULT_CLASSIFY=CODECLASSIFY
|
rootClassifyoid = MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY;
|
//判断是否属于分类树,如果是组织、人员、附录之类的不生成任务,并且自动清除这个data
|
boolean iswupin = codeClassifyDaoI.isWupin(btmoid);
|
if(!"TakeBack".equals(sendtype)&&!iswupin){
|
boolean u = delteDockingData(dataoid);
|
logger.error("集成data删除非分类data失败！dataoid:"+dataoid);
|
continue;
|
}
|
pushType="2";
|
rootClassifyoid=btmoid;
|
}else {
|
/* CodeClassifyDO rootClassify = codeClassifyDaoI.getRootClassify(classifyoid);//root分类
|
if(rootClassify==null){
|
continue;//说明这个分类被删掉了，不做处理
|
}
|
rootClassifyoid = rootClassify.getOid();*/
|
rootClassifyoid=classifyoid;
|
}
|
|
List<CodeClassifyDO> parentLeveDO= codeClassifyDaoI.selectAllLevelParentByOid(rootClassifyoid);
|
if(CollectionUtils.isEmpty(parentLeveDO)){
|
continue;//说明这个分类被删掉了，不做处理
|
}
|
Map<String, CodeClassifyDO> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
|
String finalPushType = pushType;
|
oidCodeclassifyDOMap.keySet().forEach(oid->{
|
if(sysIntInfoDOMap.containsKey(oid)){
|
List<SysIntInfoDO> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
|
sysIntInfoDOS.stream().forEach(sysIntInfoDO -> {
|
String sysPushType= sysIntInfoDO.getPushType();
|
if(sysPushType.equalsIgnoreCase(finalPushType)){
|
effectiveSysIntInfoVOs.add(sysIntInfoDO);
|
}
|
});
|
|
|
}
|
});
|
if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
|
continue;
|
}
|
List<DockingTaskDO> dockingTaskDO_insert = new ArrayList<DockingTaskDO>();
|
for (SysIntInfoDO sysIntInfoVOi:effectiveSysIntInfoVOs){
|
// String sysinfoclassifyoid = sysIntInfoVOi.getClassifyoid();//intinfo的classifyoid
|
// if(!rootClassifyoid.equals(sysinfoclassifyoid)){
|
// continue;
|
// }
|
DockingTaskDO dockingTaskDO = new DockingTaskDO();
|
String oid=redisService.getUUIDEveryDay();
|
// logger.error("===================================================oid: "+redisService.getUUIDEveryDay());
|
dockingTaskDO.setOid(oid);
|
dockingTaskDO.setSendflag(MdmDuckingConstant.SEND_FLAG_FALSE);
|
dockingTaskDO.setId(id);//编码
|
dockingTaskDO.setUniquecode(uniquecode);
|
dockingTaskDO.setBtmoid(btmoid);//数据oid
|
dockingTaskDO.setBtmid(btmid);//数据业务类型id
|
dockingTaskDO.setClassifyid(classifyid);//数据在分类id
|
dockingTaskDO.setClassifyoid(classifyoid);//数据所在分类oid
|
dockingTaskDO.setClassifyname(classifyname);//数据所在分类名称
|
dockingTaskDO.setSendtype(sendtype);//数据推送类型
|
dockingTaskDO.setDataoid(dataoid);
|
|
//intinfo
|
dockingTaskDO.setSysinfooid(sysIntInfoVOi.getOid());//intinfo的oid
|
dockingTaskDO.setSystemoid(sysIntInfoVOi.getSysbaseoid());//系统oid
|
dockingTaskDO.setSystemcode(sysIntInfoVOi.getSysbaseid());//系统编码
|
dockingTaskDO.setSystemname(sysIntInfoVOi.getSysbasename());//系统name
|
|
dockingTaskDO_insert.add(dockingTaskDO);
|
}
|
|
BatchCBO bi = null;
|
if(dockingTaskDO_insert.size()!=0) {
|
bi = dockingTaskDaoI.batchInsert(dockingTaskDO_insert);
|
batchCBO.copyFromOther(bi);
|
}
|
|
WebUtil.setPersistence(true);
|
boService.persistenceBatch(batchCBO);
|
|
//dockingTaskDaoI.updateByPrimaryKey方法报错了，所以手写了这个
|
boolean u = updateDockingDatasSendFlag(dataoid, MdmDuckingConstant.SEND_FLAG_TRUE);
|
if(!u){
|
logger.error("集成data分解任务失败！dataoid:"+dataoid);
|
continue;
|
}
|
|
}
|
}
|
|
/**
|
* 四、3、
|
* 1、
|
*/
|
@Override
|
public void sendData3(){
|
|
initSysadmin();
|
|
//查询哪些任务还没有执行完成
|
VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(DockingTaskDO.class);
|
queryWrapper.addQueryMap("sendFlag", MdmDuckingConstant.SEND_FLAG_FALSE);
|
List<DockingTaskDO> dockingTaskDOS = dockingTaskDaoI.selectByWrapper(queryWrapper);
|
|
//每个task依次执行推送
|
for (DockingTaskDO dockingTaskDO:dockingTaskDOS){
|
|
//每个task一个事务，开启
|
WebUtil.setPersistence(false);
|
BatchCBO batchCBO = new BatchCBO();
|
|
String paramString = null;
|
|
//查询系统接口信息,ip method,dataType
|
String systeminfooid = dockingTaskDO.getSysinfooid();//sysininfo 的oid
|
String systemcode = dockingTaskDO.getSystemcode();
|
String systemname = dockingTaskDO.getSystemname();
|
String systemoid = dockingTaskDO.getSystemoid();
|
String dataid = dockingTaskDO.getId();//编码
|
String uniquecode = dockingTaskDO.getUniquecode();//uniquecode
|
|
//查询推送接口参数
|
SysIntInfoVO sysIntInfoVO = sysIntInfoServiceI.getObjectByOid(systeminfooid);
|
String url = sysIntInfoVO.getRequesturl();//url
|
String type = sysIntInfoVO.getInterfacetype().toLowerCase(Locale.ROOT);//get/post/webserver/corba
|
String paramType = sysIntInfoVO.getParamtype();//xml/json
|
String returnType = sysIntInfoVO.getReturntype();//xml/json
|
String interfaceFunction = sysIntInfoVO.getInterfaceFunction();//主要是webservice的方法名
|
String namespace = sysIntInfoVO.getNamespace();//namespace
|
String soapaction = sysIntInfoVO.getSoapaction();//soapaction
|
String targName = sysIntInfoVO.getTargName();//targName
|
String cxfaxis = sysIntInfoVO.getCxfaxis();//webservice是cxf/axis
|
|
//查询param
|
List<SysIntParamDO> sysIntParamDOList = sysIntInfoServiceI.getParamsBySystemInfoOid(systeminfooid);
|
//查询header
|
List<SysIntHeaderDO> sysIntHeaderDOList = sysIntInfoServiceI.getHeadersBySystemInfoOid(systeminfooid);
|
|
//查询要推送的数据
|
String btmoid = dockingTaskDO.getBtmoid();//数据oid
|
String btmid = dockingTaskDO.getBtmid();//数据btmid
|
String classifyoid = dockingTaskDO.getClassifyoid();
|
String classifyid = dockingTaskDO.getClassifyid();
|
String classifyname= dockingTaskDO.getClassifyname();
|
String sendtype = dockingTaskDO.getSendtype();
|
|
//组装数据
|
XmlData xmlData = new XmlData();
|
xmlData.setSendtype(sendtype);
|
|
if(!MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equals(btmid)) {
|
xmlData.setType(btmid);
|
}
|
|
String ret_xml = null;
|
String id = null;
|
String name = null;
|
String idpath = null;
|
String namepath = null;
|
//表示是分类信息数据
|
if(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equals(btmid)){
|
xmlData.setNamepath("");
|
xmlData.setIdpath("");
|
xmlData.setNum("");
|
|
CodeClassifyDO codeClassifyDO = null;
|
try {
|
codeClassifyDO = codeClassifyDaoI.selectByPrimaryKey(btmoid);
|
}catch (Exception e){
|
|
}
|
|
String classifyoid_parent = "";
|
int orderNum = 0;
|
if(codeClassifyDO==null){//查不到数据，说明被删除了，从DOCKING_CACHE2_DELETE取
|
CodeClassifyDO codeClassifyDOJson = (CodeClassifyDO)redisService.getCacheObject(MdmDuckingConstant.DOCKING_CACHE2_DELETE+btmoid);
|
|
if(codeClassifyDOJson==null){
|
BatchCBO insertLoge = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,"",url,"主数据系统未查询到删除的数据，未执行推送。");
|
batchCBO.copyFromOther(insertLoge);
|
WebUtil.setPersistence(true);
|
boService.persistenceBatch(batchCBO);
|
}
|
id = codeClassifyDOJson.getId();
|
name = codeClassifyDOJson.getName();
|
orderNum = codeClassifyDOJson.getOrderNum();
|
classifyoid_parent = codeClassifyDOJson.getParentCodeClassifyOid();
|
}else {
|
id = codeClassifyDO.getId();
|
name = codeClassifyDO.getName();
|
orderNum = codeClassifyDO.getOrderNum();
|
classifyoid_parent = codeClassifyDO.getParentCodeClassifyOid();
|
}
|
|
//父级,idpath,namepath,分类数据视图中没有查询出路径，需要手动去查询
|
CodeClassifyDO codeClassifyDO_parent = null;
|
try {
|
codeClassifyDO_parent = codeClassifyDaoI.selectByPrimaryKey(classifyoid_parent);
|
xmlData.setParentId(codeClassifyDO_parent.getId());
|
|
//idpath,namepath
|
|
List<CodeClassifyDO> codeClassifyDOList = codeClassifyDaoI.listParentClassify(codeClassifyDO_parent.getOid());
|
for (int i=codeClassifyDOList.size()-1;i>=0;i--){
|
CodeClassifyDO codeClassifyDOi=codeClassifyDOList.get(i);
|
String idi = codeClassifyDOi.getId();
|
String namei = codeClassifyDOi.getName();
|
idpath = idpath==null?idi:idpath+"#"+idi;
|
namepath = namepath==null?namei:namepath+"#"+namei;
|
}
|
}catch (Exception e){
|
|
}
|
|
idpath = idpath==null?id:idpath+"#"+id;
|
namepath = namepath==null?name:namepath+"#"+name;
|
|
//查询分类路径
|
xmlData.setName(name);
|
xmlData.setNamepath(namepath);
|
xmlData.setIdpath(idpath);
|
xmlData.setId(id);
|
xmlData.setOrderNum(orderNum);
|
|
List<XmlData> xmlDataList = new ArrayList<XmlData>();
|
xmlDataList.add(xmlData);
|
ret_xml = XmlUtil.writeSendXmlData_classify(xmlDataList);//xml格式数据
|
}else {
|
Map<String, String> data = null;
|
try {
|
//表示是主数据
|
CodeClassifyTemplateVO codeClassifyTemplateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(classifyoid);
|
BaseResult<Map<String, String>> baseResult = mdmEngineServiceI.getDataByOid(btmoid, codeClassifyTemplateVO.getOid());
|
|
if (baseResult == null) {
|
JSONObject josni = redisService.getCacheObject(MdmDuckingConstant.DOCKING_CACHE2_DELETE + btmoid);
|
data = (Map) josni;
|
} else {
|
data = baseResult.getObj();
|
}
|
}catch (Throwable e){
|
BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"未查询到相应数据！");
|
batchCBO.copyFromOther(failCbo);
|
continue;
|
}
|
|
//处理计量单位等转换
|
// data = tran(data);
|
|
//如果是集成erp部门数据集成，parentcode=null建立一级部门,无人机比较只有部门，没有科室,所以系统的科室其实就是他们的部门
|
if("organization".equals(btmid.toLowerCase())){
|
String materialclassify = data.get("materialclassify");
|
if("科室".equals(materialclassify)){
|
data.put("parentcode","");
|
}
|
}
|
//数据转换d
|
String tran_xml = null;
|
try {
|
//D:\MDM_important\PLT-2022\web\tranTemp\+系统名称,会去找这个文件读取数据转换信息
|
tran_xml = FileUtils.readFileToString(new File(tranTemp+File.separator+systemcode+".xml"),"utf-8");
|
}catch (IOException e){
|
e.printStackTrace();
|
}
|
if(StringUtils.isNotEmpty(tran_xml)){
|
//通过tran_xml对data数据转换
|
Map<String,Object> tran_map = null;
|
try {
|
tran_map = XmlUtil.readTranXml(tran_xml,btmid);
|
}catch (Exception e){
|
e.printStackTrace();
|
}
|
if(tran_map!=null){//读取到这个btmid设置的转换关系了才做处理
|
for (String key:tran_map.keySet()){//key=materialtype
|
Object data_pro_mapo = tran_map.get(key);//data_pro_map
|
if(data_pro_mapo!=null){//这个值设置转换了才处理
|
Map<String,String> data_pro_map = (Map<String,String>)data_pro_mapo;
|
String mdm_value = data.get(key);
|
String system_value = data_pro_map.get(mdm_value);
|
if(StringUtils.isNotEmpty(mdm_value)){
|
data.put(key,system_value);
|
}
|
}
|
}
|
}
|
}
|
|
String unique = null;
|
List<Pro> pros = new ArrayList<Pro>();
|
String codeclassifyoid = null;
|
for (String key:data.keySet()){
|
Pro pro = new Pro();
|
pro.setKey(key);
|
pro.setMean("");
|
pro.setValue(data.getOrDefault(key,""));
|
pros.add(pro);
|
if(tuhao.equals(key)){
|
unique = data.getOrDefault(key,"");
|
}
|
if("oid".equals(key)){
|
codeclassifyoid = data.getOrDefault(key,"");
|
}
|
}
|
xmlData.setNum(data.getOrDefault("id",""));
|
xmlData.setPros(pros);
|
xmlData.setUnique(unique);
|
|
//查询分类路径,主数据在视图中已经查询出了路径，只不过是,间隔的
|
namepath = classifyname.replaceAll(",","#");
|
idpath = classifyid.replaceAll(",","#");
|
|
xmlData.setNamepath(namepath);
|
xmlData.setIdpath(idpath);
|
|
List<XmlData> xmlDataList = new ArrayList<XmlData>();
|
xmlDataList.add(xmlData);
|
ret_xml = XmlUtil.writeSendXmlData(xmlDataList);//xml格式数据
|
}
|
|
//切换xml/json
|
String sendString = null;
|
String backString = null;
|
if(paramType.equals(MdmDuckingConstant.DATATYPE_JSON)){
|
sendString = XML.toJSONObject(ret_xml).toString();
|
}else {
|
sendString = ret_xml;
|
}
|
logger.info("系统："+systemcode);
|
logger.info("接口地址:"+url);
|
logger.info("接口函数:"+interfaceFunction);
|
logger.info("接口传递参数:"+sendString);
|
//推送数据
|
try {
|
if (type.equals(MdmDuckingConstant.URLTYPE_GET)) {//GET请求
|
String sendurl = url + "?" + MdmDuckingConstant.PARAM_XMLDATA + "=" + sendString;
|
//拼接param
|
for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
|
sendurl = sendurl + "&" + sysIntParamDO.getParamkey() + "=" + sysIntParamDO.getParamvalue();
|
}
|
paramString=sendurl;
|
backString = HttpUtils.get(sendurl);
|
} else if (type.equals(MdmDuckingConstant.URLTYPE_POST)) {//POST请求
|
MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
|
for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
|
params.add(sysIntParamDO.getParamkey(), sysIntParamDO.getParamvalue());
|
}
|
paramString=params.toString();
|
MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
|
for (SysIntHeaderDO sysIntHeaderDO : sysIntHeaderDOList) {
|
headers.add(sysIntHeaderDO.getHeaderkey(), sysIntHeaderDO.getHeaderalue());
|
}
|
backString = HttpUtils.post(url, params, headers);
|
} else if (type.equals(MdmDuckingConstant.URLTYPE_WEBSERVICE)) {//webserver请求
|
MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
|
for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
|
params.add(sysIntParamDO.getParamkey(), sysIntParamDO.getParamvalue());
|
}
|
paramString=sendString;
|
MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
|
for (SysIntHeaderDO sysIntHeaderDO : sysIntHeaderDOList) {
|
headers.add(sysIntHeaderDO.getHeaderkey(), sysIntHeaderDO.getHeaderalue());
|
}
|
backString = WsErpClientUtil.sendMsg(url, namespace, soapaction,interfaceFunction,targName, paramString, 10000);
|
} else {//corba接口
|
|
}
|
paramString=sendString;
|
}catch (Exception e){
|
e.printStackTrace();
|
BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"推送数据失败！");
|
batchCBO.copyFromOther(failCbo);
|
}
|
logger.info("接口返回参数:"+backString);
|
//解析返还参数
|
try {
|
BackXml backXml = null;
|
if(returnType.equals(MdmDuckingConstant.DATATYPE_JSON)){
|
backXml = XmlUtil.readSendJsonData(backString);//目前只读取主数据json返回信息
|
}else {
|
if(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equals(btmid)){
|
backXml = XmlUtil.readSendXmlData_classify(backString);//分类xml返回信息
|
}else {
|
backXml = XmlUtil.readSendXmlData(backString);//主数据xml返回信息
|
}
|
}
|
List<XmlData> datas = backXml.getDatas();
|
boolean isSend = false;
|
for (XmlData xmlDatai:datas){
|
String xml_datacode = xmlDatai.getState();
|
String xml_datamsg = xmlDatai.getMsg();
|
if(MdmDuckingConstant.XML_DATACODE_200.equals(xml_datacode)){
|
BatchCBO insertLoge = taskSuccess(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
|
batchCBO.copyFromOther(insertLoge);
|
isSend = true;
|
}else if(MdmDuckingConstant.XML_DATACODE_500.equals(xml_datacode)){
|
BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
|
batchCBO.copyFromOther(failCbo);
|
}else if("true".equals(xml_datacode.toLowerCase())){
|
BatchCBO insertLoge = taskSuccess(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
|
batchCBO.copyFromOther(insertLoge);
|
isSend = true;
|
}else if("false".equals(xml_datacode)){
|
BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
|
batchCBO.copyFromOther(failCbo);
|
}else{
|
BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"返还xml格式不正确，缺少code!");
|
batchCBO.copyFromOther(failCbo);
|
}
|
}
|
|
//全都接收成功的情况下,修改dockingtask sendflag为已发送
|
if(isSend) {
|
dockingTaskDO.setSendflag(MdmDuckingConstant.SEND_FLAG_TRUE);
|
BatchCBO updateTask = dockingTaskDaoI.updateByPrimaryKey(dockingTaskDO);
|
batchCBO.copyFromOther(updateTask);
|
}
|
|
}catch (Exception e){
|
e.printStackTrace();
|
BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"解析返还数据失败！");
|
batchCBO.copyFromOther(failCbo);
|
}
|
|
//每一个task一个事物
|
WebUtil.setPersistence(true);
|
boService.persistenceBatch(batchCBO);
|
|
}
|
}
|
|
public static Map<String,String> tranMap = new HashMap<String,String>();
|
public Map<String,String> tran(Map<String,String> data){
|
if(tranMap.isEmpty()){
|
// tranMap.put("jiliangdw","jiliangdwname");
|
}
|
|
for (String key:tranMap.keySet()){
|
String tran_key = tranMap.get(key);
|
String tran_key_value = data.get(tran_key);
|
if(StringUtils.isNotEmpty(tran_key_value)){
|
data.put(key,tran_key_value);
|
}
|
}
|
data.put("shifoupihaoguanli","0");
|
return data;
|
}
|
|
/**
|
* 定时任务推送
|
*/
|
@Override
|
public void DockingScheduing(){
|
//data 2 task
|
insertCache2();
|
|
//推送数据
|
sendData3();
|
}
|
|
/**
|
* 数据删除的时候，缓存到redis
|
* @param oid
|
*/
|
@Override
|
public void cacheDeleteData(String oid,Object obj){
|
logger.info("删除数据插入redis,key: "+ MdmDuckingConstant.DOCKING_CACHE2_DELETE+",oid: "+oid+",obj: "+obj);
|
redisService.setCacheObject(MdmDuckingConstant.DOCKING_CACHE2_DELETE + oid, obj);
|
}
|
|
@Override
|
public DataGrid<DockingDataDO> gridData(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
pageHelper.addDefaultDesc("createTime");
|
pageHelper.addDefaultAsc("sendflag");
|
List<DockingDataDO> doList = dockingDataDaoI.selectByCondition(conditionMap,pageHelper);
|
|
DataGrid<DockingDataDO> dataGrid=new DataGrid<DockingDataDO>();
|
if (!CollectionUtils.isEmpty(doList)) {
|
dataGrid.setData(doList);
|
dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingDataDaoI.countByCondition(conditionMap))));
|
}
|
return dataGrid;
|
}
|
|
@Override
|
public DataGrid<DockingTaskDO> gridTask(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException{
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
pageHelper.addDefaultDesc("createTime");
|
pageHelper.addDefaultAsc("sendflag");
|
List<DockingTaskDO> doList = dockingTaskDaoI.selectByCondition(conditionMap,pageHelper);
|
|
DataGrid<DockingTaskDO> dataGrid=new DataGrid<DockingTaskDO>();
|
if (!CollectionUtils.isEmpty(doList)) {
|
dataGrid.setData(doList);
|
dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingTaskDaoI.countByCondition(conditionMap))));
|
}
|
return dataGrid;
|
}
|
|
@Override
|
public DataGrid<DockingLogeDO> gridLoge(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException{
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
pageHelper.addDefaultDesc("createTime");
|
List<DockingLogeDO> doList = dockingLogeDaoI.selectByCondition(conditionMap,pageHelper);
|
|
DataGrid<DockingLogeDO> dataGrid=new DataGrid<DockingLogeDO>();
|
if (!CollectionUtils.isEmpty(doList)) {
|
dataGrid.setData(doList);
|
dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingLogeDaoI.countByCondition(conditionMap))));
|
}
|
return dataGrid;
|
}
|
|
@Override
|
public DataGrid<SysIntHeaderDO> gridHeader(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException{
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
pageHelper.addDefaultDesc("createTime");
|
List<SysIntHeaderDO> doList = sysIntHeaderDaoI.selectByCondition(conditionMap,pageHelper);
|
|
DataGrid<SysIntHeaderDO> dataGrid=new DataGrid<SysIntHeaderDO>();
|
if (!CollectionUtils.isEmpty(doList)) {
|
dataGrid.setData(doList);
|
dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(sysIntHeaderDaoI.countByCondition(conditionMap))));
|
}
|
return dataGrid;
|
}
|
/**
|
* 推送成功,插入dockingtask，同时记录loge
|
* @param systemcode
|
* @param systemname
|
* @param systemoid
|
* @param paramString
|
* @param url
|
*/
|
public BatchCBO taskSuccess(String systemcode,String systemname,String systemoid,String classifyoid,String classifyid,String classifyname,String id,String uniquecode,String paramString,String url,String msg){
|
String oid=redisService.getUUIDEveryDay();
|
DockingLogeDO dockingLogeDO = new DockingLogeDO();
|
dockingLogeDO.setOid(oid);
|
dockingLogeDO.setSystemcode(systemcode);
|
dockingLogeDO.setSystemname(systemname);
|
dockingLogeDO.setSystemoid(systemoid);
|
dockingLogeDO.setClassifyoid(classifyoid);
|
dockingLogeDO.setClassifyid(classifyid);
|
dockingLogeDO.setClassifyname(classifyname);
|
dockingLogeDO.setId(id);
|
dockingLogeDO.setUniquecode(uniquecode);
|
/** if(paramString.length()>100){
|
paramString = paramString.substring(0,100);
|
}***/
|
dockingLogeDO.setParamstring(paramString);
|
dockingLogeDO.setType(MdmDuckingConstant.DATA_LOGE_OUT);
|
|
// dockingLogeDO.setReturnstring(retString);
|
dockingLogeDO.setMsg(msg);
|
dockingLogeDO.setInterfacestatus(MdmDuckingConstant.INTERFACE_STATUS_TRUE);
|
BatchCBO insert = dockingLogeDaoI.insert(dockingLogeDO);
|
logger.info("集成推送数据成功,systemcode:"+systemcode+",systemname:"+systemcode+",url:"+url+",param:"+paramString);
|
return insert;
|
}
|
|
/**
|
* 推送失败,插入dockingtask，同时记录loge
|
* @param systemcode
|
* @param systemname
|
* @param systemoid
|
* @param paramString
|
* @param url
|
*/
|
public BatchCBO taskFail(String systemcode,String systemname,String systemoid,String classifyoid,String classifyid,String classifyname,String id,String uniquecode,String paramString,String url,String msg){
|
String oid=redisService.getUUIDEveryDay();
|
DockingLogeDO dockingLogeDO = new DockingLogeDO();
|
dockingLogeDO.setOid(oid);
|
dockingLogeDO.setSystemcode(systemcode);
|
dockingLogeDO.setSystemname(systemname);
|
dockingLogeDO.setSystemoid(systemoid);
|
dockingLogeDO.setClassifyoid(classifyoid);
|
dockingLogeDO.setClassifyid(classifyid);
|
dockingLogeDO.setClassifyname(classifyname);
|
dockingLogeDO.setId(id);
|
dockingLogeDO.setUniquecode(uniquecode);
|
/** if(StringUtils.isNotEmpty(paramString)&¶mString.length()>100){
|
paramString = paramString.substring(0,100);
|
}***/
|
dockingLogeDO.setParamstring(paramString);
|
dockingLogeDO.setType(MdmDuckingConstant.DATA_LOGE_OUT);
|
|
dockingLogeDO.setMsg(msg);
|
dockingLogeDO.setInterfacestatus(MdmDuckingConstant.INTERFACE_STATUS_FALSE);
|
BatchCBO insert = dockingLogeDaoI.insert(dockingLogeDO);
|
|
logger.error("集成推送数据失败,systemcode:"+systemcode+",systemname:"+systemcode+",url:"+url+",param:"+paramString+",e:"+msg);
|
return insert;
|
}
|
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查询需要推送的数据
|
* @return
|
*/
|
public List<Map> getDockingDatas(){
|
String sql = "select oid,id,classifyoid,btmid,btmoid,sendtype,classifyid,classifyname from PLATFORMBTM_codedockingDATA where sendflag = 'false'";
|
List<Map> datas = boService.queryBySqlForMap(sql,null);
|
return datas;
|
}
|
|
/**
|
* dockingdata删除
|
* @return
|
*/
|
public boolean delteDockingData(String oid){
|
boolean u = false;
|
String sql = "delete from PLATFORMBTM_codedockingDATA where oid = '"+oid+"'";
|
try {
|
u=platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
|
}catch (Exception e){
|
|
}
|
return u;
|
}
|
|
/**
|
* 查询图号
|
* @return
|
*/
|
public String getTuhao(String oid){
|
String tuhao = "";
|
String sql = "select tuhao from PLATFORMBTM_wupin where oid = '"+oid+"'";
|
List<Map> datas = boService.queryBySqlForMap(sql,null);
|
if(datas!=null&&datas.size()!=0){
|
tuhao = datas.get(0).getOrDefault("tuhao","").toString();
|
}
|
return tuhao;
|
}
|
|
@Autowired
|
private PlatformClientUtil platformClientUtil;
|
/**
|
* dockingdata根据oid修改sendflag
|
* @param oid
|
* @param sendflag
|
* @return
|
*/
|
public boolean updateDockingDatasSendFlag(String oid,String sendflag){
|
boolean u=false;
|
String sql = "update PLATFORMBTM_codedockingdata set sendFlag = '"+sendflag+"' where oid='"+oid+"'";
|
try {
|
u=platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
|
}catch (Exception e){
|
|
}
|
return u;
|
}
|
|
public boolean updateDockingDatasUniqueCode(String oid,String uniquecode){
|
boolean u=false;
|
String sql = "update PLATFORMBTM_codedockingdata set uniquecode = '"+uniquecode+"' where oid='"+oid+"'";
|
try {
|
u=platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
|
}catch (Exception e){
|
|
}
|
return u;
|
}
|
|
|
}
|
