From be30e17e3c7685a54f761bf3a03487308c939270 Mon Sep 17 00:00:00 2001
From: 田源 <tianyuan@vci-tech.com>
Date: 星期三, 05 三月 2025 18:05:11 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java | 1807 +++++++++++++++++++++++++++++++++++++++------------------
1 files changed, 1,234 insertions(+), 573 deletions(-)
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java
index d24fc98..3b4964e 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java
@@ -1,12 +1,17 @@
package com.vci.ubcs.code.service.impl;
+import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
+import com.alibaba.nacos.shaded.com.google.protobuf.ServiceException;
+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.dao.CodeClassifyDaoI;
-import com.vci.ubcs.code.dao.DockingDataDaoI;
-import com.vci.ubcs.code.dao.DockingLogeDaoI;
-import com.vci.ubcs.code.dao.DockingTaskDaoI;
+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;
@@ -18,619 +23,1275 @@
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.code.model.*;
-import com.vci.ubcs.code.service.CodeDuckingSyncServiceI;
-import com.vci.ubcs.code.service.MdmEngineServiceI;
-import com.vci.ubcs.code.service.SysIntInfoServiceI;
-import com.vci.ubcs.code.utils.HttpUtils;
-import com.vci.ubcs.code.utils.WsErpClientUtil;
-import com.thoughtworks.xstream.XStream;
-import com.thoughtworks.xstream.io.xml.DomDriver;
-import com.vci.starter.web.constant.QueryOptionConstant;
-import com.vci.starter.web.enumpck.UserSecretEnum;
-import com.vci.starter.web.pagemodel.BaseResult;
-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.model.*;
-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.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springblade.code.model.*;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
-import com.vci.ubcs.code.vo.pagemodel.SysIntInfoVO;
+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.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.attrmap.*;
+import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
+import com.vci.ubcs.code.webService.config.AttributeMapConfig;
+import com.vci.ubcs.omd.cache.EnumCache;
+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.BeanUtilForVCI;
+import com.vci.ubcs.starter.web.util.VciBaseUtil;
+import com.vci.ubcs.starter.web.util.WebUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.map.CaseInsensitiveMap;
+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.context.annotation.Lazy;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.mock.web.MockHttpServletRequest;
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 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.servlet.http.HttpServletRequest;
+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 wangyi
- * @date 2022-03-20
- */
+ * @author xiejun
+ * @date 2023-06-19
+ **/
+
@Service
-public class CodeDuckingSyncServiceImpl implements CodeDuckingSyncServiceI {
+@Slf4j
+public class CodeDuckingSyncServiceImpl implements ICodeDuckingSyncService {
- /**
- * 鏃ュ織
- */
- private Logger logger = LoggerFactory.getLogger(getClass());
+ @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;
- /**
- * 闆嗘垚鎺ㄩ�佷换鍔℃暟鎹搷浣滃眰
- */
- @Resource
- private DockingTaskDaoI dockingTaskDaoI;
+ @Value("${erp.item.systemId:ERP}")
+ public String systemId;
+ @Value("${erp.item.secName:鍥哄畾鐮佹}")
+ public String secName;
+ @Value("${erp.item.secValue:A}")
+ public String secValue;
- /**
- * 闆嗘垚鎺ㄩ�佷换鍔℃暟鎹搷浣滃眰
- */
- @Resource
- private DockingDataDaoI dockingDataDaoI;
+ @Value("${erp.item.btmName:XHDH}")
+ public String btmName;
- /**
- * 闆嗘垚鏃ュ織鏁版嵁鎿嶄綔灞�
- */
- @Resource
- private DockingLogeDaoI dockingLogeDaoI;
+ @Value("${erp.item.bearer:bearer: Bearer 7fc32939-0a59-da71-a6e6-6b0d37b53e8a}")
+ private String ERPXHDHAUTH;
- /**
- * 妯℃澘灞炴�ф暟鎹搷浣滃眰
- */
- @Resource
- private CodeClassifyDaoI codeClassifyDaoI;
+ @Value("${erp.item.url:http://127.0.0.1/api/pp/pp/ext/extend/v1.0}")
+ private String ERPXHDHURL;
- /**
- * 涓氬姟绫诲瀷鎿嶄綔鐨勬湇鍔�
- */
- @Autowired
- private WebBoServiceI boService;
+ @Value("${erp.item.tenant:10000}")
+ private String ERPXHDHTENANT;
- /**
- * 缂撳瓨鏈嶅姟
- */
- @Autowired
- private RedisService redisService;
+ /**
+ * 涓氬姟绫诲瀷鐨勬湇鍔�
+ */
+ @Autowired
+ private IBtmTypeClient btmTypeClient;
- /**
- * 鏁版嵁鏈嶅姟
- */
- @Autowired(required = false)
- @Lazy
- private MdmEngineServiceI mdmEngineServiceI;
+ /**
+ * 閫氱敤鏌ヨ
+ */
+ @Resource
+ private CommonsMapper commonsMapper;
+ @Resource
+ private MdmEngineService mdmEngineServiceI;
- /**
- * 瑕佹帹閫佺郴缁熺殑鏈嶅姟
- */
- @Autowired
- private SysIntInfoServiceI sysIntInfoServiceI;
+ /**
+ * 鎵归噺澶勭悊鐨勬湇鍔�
+ */
+ @Resource
+ private MdmIOService mdmIOService;
- @Value("${dataSyncPush.dataParamName:xmlData}")
- public String DATA_PARAM_NAME;
+ @Resource
+ private IPasswordFreeLoginService passwordFreeLoginService;
- /**
- * 瀹氭椂浠诲姟鎺ㄩ��
- */
- @Override
- public void DockingDataSyncScheduing(){
- // insertCache2();
- initPushDataTaks(1);
- sendpushDataForService();
- }
+ @Resource
+ private IDockingLogeService dockingLogeService;
- /**
- * 鍒嗙被瀹氭椂浠诲姟鎺ㄩ��
- */
- @Override
- public void DockingClassSyncScheduing(){
- initPushDataTaks(2);//鍒嗙被鎺ㄩ��
- sendpushClsfForService();
- }
+ @Resource
+ private IDockingDataService dockingDataService;
- /**
- * 鎵嬪姩鎺ㄩ�佷负瀹屾垚鐨勬暟鎹�
- * @param oids
- * @return
- */
- @Override
- public BaseResult sendData(String oids) {
- VciBaseUtil.alertNotNull(oids,"绯荤粺闆嗘垚鍩虹淇℃伅鏁版嵁瀵硅薄",oids,"绯荤粺闆嗘垚鍩虹淇℃伅鐨勪富閿�");
- List<String> dockingTaskOidList=new ArrayList<>();
- dockingTaskOidList= VciBaseUtil.str2List(oids);
- List<DockingTaskDO> newDockingTaskDOs= this.dockingTaskDaoI.selectByPrimaryKeyCollection(dockingTaskOidList);
- Map<String,List<DockingTaskDO>> typeDockingTaskDOMap=new HashMap<>();
- newDockingTaskDOs.stream().forEach(newDockingTaskDO->{
- String btmId=newDockingTaskDO.getBtmid();
- if(btmId.equalsIgnoreCase(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
- List<DockingTaskDO> dockingTaskDOList= typeDockingTaskDOMap.get(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
- if(CollectionUtils.isEmpty(dockingTaskDOList)){
- dockingTaskDOList=new ArrayList<>();
- }
- dockingTaskDOList.add(newDockingTaskDO);
- typeDockingTaskDOMap.put(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT),dockingTaskDOList);
- }else{
- List<DockingTaskDO> dockingTaskDOList= typeDockingTaskDOMap.get("data");
- if(CollectionUtils.isEmpty(dockingTaskDOList)){
- dockingTaskDOList=new ArrayList<>();
- }
- dockingTaskDOList.add(newDockingTaskDO);
- typeDockingTaskDOMap.put("data",dockingTaskDOList);
- }
- });
- typeDockingTaskDOMap.keySet().forEach(type->{
- List<DockingTaskDO> DockingTaskDO=typeDockingTaskDOMap.get(type);
- if(!CollectionUtils.isEmpty(DockingTaskDO)){
- if(type.equalsIgnoreCase(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))){
- this.sendpushClsfForService(DockingTaskDO);
- }else{
- this.sendpushDataForService(DockingTaskDO);
- }
- }
- });
- return BaseResult.successMsg("鎵嬪姩鎺ㄩ�佸畬鎴�,璇锋牳瀵规槸鍚︽帹閫佹垚鍔�");
- }
- /***
- * 鏌ヨredis涓暟鎹紝瀵规瘮鍚庢彃鍏ockingtask
- * @param type
- */
- private void initPushDataTaks(int type){
- initSysadmin();
- //sysintinfo鏌ヨ瑕佹帹閫佺殑涓婚搴撳拰鐩稿叧绯荤粺淇℃伅
- Map<String, String> conditionMap = new HashMap<>();
- conditionMap.put("usedflag","true");
- conditionMap.put("pushType",type==2?"2":"1") ;//2鏄唬琛ㄥ垎绫绘帹閫侊紝1鏄唬琛ㄦ暟鎹帹閫�
+ @Resource
+ private IDockingTaskService dockingTaskService;
- List<SysIntInfoDO> sysIntInfoVOList = sysIntInfoServiceI.selectAll(conditionMap);
- if(CollectionUtils.isEmpty(sysIntInfoVOList)){
- String title=type==2?"鍒嗙被鎺ㄩ��":"鏁版嵁鎺ㄩ��";
- logger.info("info->鎵�鏈夐泦鎴愮郴缁燂紝鏈煡璇㈠埌鐩稿叧鐨勩��"+title+"銆戠殑鎺ュ彛閰嶇疆淇℃伅锛岄厤缃�");
- return;
- }
- Map<String ,List<SysIntInfoDO>> sysIntInfoDOMap = new HashMap<String ,List<SysIntInfoDO>>();//key=classifyoid,value=list<map>
- for (SysIntInfoDO sysIntInfoVOi:sysIntInfoVOList){
- List<SysIntInfoDO> SysIntInfoVOListi = sysIntInfoDOMap.get(sysIntInfoVOi.getClassifyoid());
- if(SysIntInfoVOListi==null){
- SysIntInfoVOListi = new ArrayList<SysIntInfoDO>();
- }
- SysIntInfoVOListi.add(sysIntInfoVOi);
- sysIntInfoDOMap.put(sysIntInfoVOi.getClassifyoid(),SysIntInfoVOListi);
- }
- //鏍规嵁绫诲瀷鍘绘煡璇㈤渶瑕侀泦鎴愮殑鍒嗙被鎴栬�呮暟鎹�
- VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(DockingDataDO.class);
- queryWrapperForDO.addQueryMap("sendflag","false");
- if(type==2){
- queryWrapperForDO.addQueryMap("btmTypeId", MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
- }else {
- queryWrapperForDO.addQueryMap("btmTypeId", QueryOptionConstant.NOTIN + "(" + VciBaseUtil.toInSql(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT)) + ")");
- }
- List<DockingDataDO> dataList = dockingDataDaoI.selectByWrapper(queryWrapperForDO);
+ @Resource
+ private IDockingSystemConfigService dockingSystemConfigService;
- for (DockingDataDO mapi:dataList){
- WebUtil.setPersistence(false);
- BatchCBO batchCBO = new BatchCBO();
- String dataoid = mapi.getOid();//data瀵硅薄鐨刼id
- 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<SysIntInfoDO> effectiveSysIntInfoVOs=new ArrayList<>();
- //鏍规嵁褰撳墠鏁版嵁鐨刬d锛屾煡璇㈣幏鍙栧摢浜涚郴缁熼渶瑕佸仛闆嗘垚
- List<CodeClassifyDO> parentLeveDO= codeClassifyDaoI.selectAllLevelParentByOid(curentClassOid);
- 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));
+ @Resource
+ private ICodeClassifyService codeClassifyService;
- oidCodeclassifyDOMap.keySet().forEach(oid->{
- if(sysIntInfoDOMap.containsKey(oid)){
- List<SysIntInfoDO> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
- effectiveSysIntInfoVOs.addAll(sysIntInfoDOS);
- }
- });
- //濡傛灉鏍￠獙鐨勭郴缁熸帴鍙ｄ俊鎭笉瀛樺湪锛屽垯鏁版嵁涓嶄笉寰�淇℃伅閲屾帹閫�
- if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
- continue;
- }
- List<DockingTaskDO> dockingTaskDO_insert = new ArrayList<DockingTaskDO>();
- for (SysIntInfoDO sysIntInfoVOi:effectiveSysIntInfoVOs){
- DockingTaskDO dockingTaskDO = new DockingTaskDO();
- dockingTaskDO.setOid(redisService.getUUIDEveryDay());
- dockingTaskDO.setSendflag(MdmDuckingConstant.SEND_FLAG_FALSE);
- dockingTaskDO.setId(id);//缂栫爜
- dockingTaskDO.setUniquecode(uniquecode);
- dockingTaskDO.setBtmoid(btmoid);//鏁版嵁oid
- dockingTaskDO.setBtmid(btmid);//鏁版嵁涓氬姟绫诲瀷id
- dockingTaskDO.setClassifyid(classifyid);//鏁版嵁鍦ㄥ垎绫籭d
- dockingTaskDO.setClassifyoid(classifyoid);//鏁版嵁鎵�鍦ㄥ垎绫籵id
- dockingTaskDO.setClassifyname(classifyname);//鏁版嵁鎵�鍦ㄥ垎绫诲悕绉�
- dockingTaskDO.setSendtype(sendtype);//鏁版嵁鎺ㄩ�佺被鍨�
- dockingTaskDO.setDataoid(dataoid);
+ @Autowired
+ private ICodeClassifyValueService codeClassifyValueService;
- //intinfo
- dockingTaskDO.setSysinfooid(sysIntInfoVOi.getOid());//intinfo鐨刼id
- dockingTaskDO.setSystemoid(sysIntInfoVOi.getSysbaseoid());//绯荤粺oid
- dockingTaskDO.setSystemcode(sysIntInfoVOi.getSysbaseid());//绯荤粺缂栫爜
- dockingTaskDO.setSystemname(sysIntInfoVOi.getSysbasename());//绯荤粺name
- dockingTaskDO_insert.add(dockingTaskDO);
- }
+ @Autowired(required = false)
+ private AttributeMapConfig attributeMapConfig;
- 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鍒嗚В浠诲姟澶辫触锛乨ataoid:"+dataoid);
- continue;
- }
+ /***
+ * resdis缂撳瓨鏈嶅姟
+ */
+ //@Resource
+ //private BladeRedis bladeRedis;
- }
- }
- private void sendpushDataForService (){
- initSysadmin();
- //鏌ヨ鍝簺浠诲姟杩樻病鏈夋墽琛屽畬鎴�
- VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(DockingTaskDO.class);
- queryWrapper.addQueryMap("sendFlag", MdmDuckingConstant.SEND_FLAG_FALSE);
- queryWrapper.addQueryMap("btmId", QueryOptionConstant.NOTIN + "(" + VciBaseUtil.toInSql(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toUpperCase(Locale.ROOT)) + ")");
- List<DockingTaskDO> dockingTaskDOS = dockingTaskDaoI.selectByWrapper(queryWrapper);
- sendpushDataForService(dockingTaskDOS);
- }
- /***
- * 鍙戦�佺紪鐮佷富鏁版嵁
- */
- private void sendpushDataForService (List<DockingTaskDO> dockingTaskDOS){
+ @Resource
+ private IDockingSysIntParamService dockingSysIntParamService;
- //姣忎釜task渚濇鎵ц鎺ㄩ��
- for (DockingTaskDO dockingTaskDO:dockingTaskDOS){
- //姣忎釜task涓�涓簨鍔★紝寮�鍚�
- WebUtil.setPersistence(false);
- BatchCBO batchCBO = new BatchCBO();
- String paramString="";
- String sendString="";
- String backString="";
- try {
- //鏌ヨ绯荤粺鎺ュ彛淇℃伅,ip method,dataType
- String systeminfooid = dockingTaskDO.getSysinfooid();//sysininfo 鐨刼id
- String classifyoid = dockingTaskDO.getClassifyoid();
- //鏌ヨ瑕佹帹閫佺殑鏁版嵁
- String btmoid = dockingTaskDO.getBtmoid();//鏁版嵁btmid
- //琛ㄧず鏄富鏁版嵁
- CodeClassifyTemplateVO codeClassifyTemplateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(classifyoid);
- BaseResult<Map<String, String>> baseResult = 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 (baseResult == null) {
- JSONObject josni = redisService.getCacheObject(MdmDuckingConstant.DOCKING_CACHE2_DELETE + btmoid);
- data = (Map) josni;
- } else {
- data = baseResult.getObj();
- }
- 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);
- }
- });
+ @Resource
+ private IDockingSysIntHeaderService dockingSysIntHeaderService;
- String[] classCodeLeves = dockingTaskDO.getClassifyid().split(",");
- NodeJosnDTO nodeJosnDTO = new NodeJosnDTO();
- NodedataDTO nodeDataDTO = new NodedataDTO();
- NodeObjectDTO nodeObjectDTO = new NodeObjectDTO();
- nodeObjectDTO.setCode(dockingTaskDO.getId());//璁剧疆缂栫爜
- 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);
- //鏌ヨ鎺ㄩ�佹帴鍙ｅ弬鏁�
- SysIntInfoVO sysIntInfoVO = sysIntInfoServiceI.getObjectByOid(systeminfooid);
- String paramType = sysIntInfoVO.getParamtype();//xml/json
- if (paramType.equals(MdmDuckingConstant.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,sysIntInfoVO, dockingTaskDO, batchCBO);
- }catch (Throwable e){
- e.printStackTrace();
- }finally {
- //姣忎竴涓猼ask涓�涓簨鐗�
- WebUtil.setPersistence(true);
- boService.persistenceBatch(batchCBO);
- }
- }
- }
- public void sendpushClsfForService(){
- initSysadmin();
- //鏌ヨ鍝簺浠诲姟杩樻病鏈夋墽琛屽畬鎴�
- VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(DockingTaskDO.class);
- queryWrapper.addQueryMap("sendFlag",MdmDuckingConstant.SEND_FLAG_FALSE);
- queryWrapper.addQueryMap("btmId", MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.toUpperCase(Locale.ROOT));
- List<DockingTaskDO> dockingTaskDOS = dockingTaskDaoI.selectByWrapper(queryWrapper);
- sendpushClsfForService(dockingTaskDOS);
- }
- /***
- * 鍙戦�佸垎绫绘暟鎹�
- */
- private void sendpushClsfForService(List<DockingTaskDO> dockingTaskDOS){
- //姣忎釜task渚濇鎵ц鎺ㄩ��
- for (DockingTaskDO dockingTaskDO:dockingTaskDOS){
- //姣忎釜task涓�涓簨鍔★紝寮�鍚�
- WebUtil.setPersistence(false);
- BatchCBO batchCBO = new BatchCBO();
- String paramString="";
- String sendString="";
- String backString="";
- //鏌ヨ绯荤粺鎺ュ彛淇℃伅,ip method,dataType
- String systeminfooid = dockingTaskDO.getSysinfooid();//sysininfo 鐨刼id
- try {
- //鏌ヨ瑕佹帹閫佺殑鏁版嵁
- String btmoid = dockingTaskDO.getBtmoid();//鏁版嵁btmid
- JsonRootDataDTO jsonRootDataDTO=new JsonRootDataDTO();
- CodeClassifyDO codeClassifyDO=codeClassifyDaoI.selectByPrimaryKey(btmoid);
- List<NodeClassifyDTO>nodeClassifyDTOList=new ArrayList<>();
- NodeClassifyDTO nodeClassifyDTO=new NodeClassifyDTO();
- nodeClassifyDTO.setClassCode(codeClassifyDO.getId());//鍒嗙被浠ｅ彿
- nodeClassifyDTO.setDescription(codeClassifyDO.getDescription());//鍒嗙被鎻忚堪
- nodeClassifyDTO.setFullPathName(codeClassifyDO.getPath());//鍏ㄨ矾寰�
- nodeClassifyDTO.setLcStatus(codeClassifyDO.getLcStatus());//鐘舵��
- // CodeClassifyDO parentClassDo=codeClassifyDaoI.selectByPrimaryKey(codeClassifyDO.getParentCodeClassifyOid());
- nodeClassifyDTO.setPid(codeClassifyDO.getId());//鐖秈d鑺傜偣
- nodeClassifyDTO.setId(codeClassifyDO.getOid());//鍒嗙被oid
- nodeClassifyDTO.setName(codeClassifyDO.getName());//鍒嗙被鍚嶇О
- nodeClassifyDTOList.add(nodeClassifyDTO);
- NodeLibraryDTO nodeLibraryDTO=new NodeLibraryDTO();
- nodeLibraryDTO.setClassify(nodeClassifyDTOList);
- CodeClassifyDO rootClassify=codeClassifyDaoI.getRootClassify(btmoid);
- nodeLibraryDTO.setId(rootClassify.getOid());
- nodeLibraryDTO.setName(rootClassify.getName());
- NodeDataDTO nodeDataDTO=new NodeDataDTO();
- nodeDataDTO.setLibrary(nodeLibraryDTO);
- jsonRootDataDTO.setData(nodeDataDTO);
+ //@Autowired(required = false)
+ //private MdmSearchItemCodeProvider mdmSearchItemCodeProvider;
- //鏌ヨ鎺ㄩ�佹帴鍙ｅ弬鏁�
- SysIntInfoVO sysIntInfoVO = sysIntInfoServiceI.getObjectByOid(systeminfooid);
- String paramType = sysIntInfoVO.getParamtype();//xml/json
- if(paramType.equals(MdmDuckingConstant.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,sysIntInfoVO,dockingTaskDO,batchCBO);
- }catch (Throwable e){
- e.printStackTrace();
- }finally {
- //姣忎竴涓猼ask涓�涓簨鐗�
- WebUtil.setPersistence(true);
- boService.persistenceBatch(batchCBO);
- }
- }
- }
+ @Resource
+ private ICodeAllCodeService codeAllCodeService;
- /***
- * 璋冪敤鎺ュ彛
- * @param sysIntInfoVO
- * @throws Throwable
- */
- private void callInterface(String sendString , SysIntInfoVO sysIntInfoVO,DockingTaskDO dockingTaskDO,BatchCBO batchCBO) throws Throwable{
- String paramString = "";
+ @Override
+ public void DockingDataSyncScheduing() {
+ // insertCache2();
+ initPushDataTaks(1);
+ sendpushDataForService();
+ }
- String backString = "";
- String msg="";
- String url = sysIntInfoVO.getRequesturl();//url
- List<ResultNodeObjectDTO> resultNodeObjectDTOS =new ArrayList<>();
- try {
+ /***
+ *
+ */
+ @Override
+ public void DockingClassSyncScheduing() {
+ initPushDataTaks(2);//鍒嗙被鎺ㄩ��
+ sendpushClsfForService();
+ }
- String type = sysIntInfoVO.getInterfacetype().toLowerCase(Locale.ROOT);//get/post/webserver/corba
- String paramType = sysIntInfoVO.getParamtype();//xml/json
- String returnType = sysIntInfoVO.getReturntype();//xml/json
- String requestmethod= sysIntInfoVO.getRequestmethod();
- String interfaceFunction = sysIntInfoVO.getInterfaceFunction();//涓昏鏄痺ebservice鐨勬柟娉曞悕
- String namespace = sysIntInfoVO.getNamespace();//namespace
- String soapaction = sysIntInfoVO.getSoapaction();//soapaction
- String targName = sysIntInfoVO.getTargName();//targName
- String cxfaxis = sysIntInfoVO.getCxfaxis();//webservice鏄痗xf/axis
- //鏌ヨparam
- List<SysIntParamDO> sysIntParamDOList = sysIntInfoServiceI.getParamsBySystemInfoOid(sysIntInfoVO.getOid());
- //鏌ヨheader
- List<SysIntHeaderDO> sysIntHeaderDOList = sysIntInfoServiceI.getHeadersBySystemInfoOid(sysIntInfoVO.getOid());
- if(type.equals(MdmDuckingConstant.URLTYPE_HTTP)) {
- if (requestmethod.equals(MdmDuckingConstant.URLTYPE_GET)) {//GET璇锋眰
- String sendurl = url + "?" + DATA_PARAM_NAME + "=" + sendString;
- //鎷兼帴param
- for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
- sendurl = sendurl + "&" + sysIntParamDO.getParamkey() + "=" + sysIntParamDO.getParamvalue();
- }
- paramString = sendurl;
- backString = HttpUtils.get(sendurl);
- } else if (requestmethod.equals(MdmDuckingConstant.URLTYPE_POST)) {//POST璇锋眰
- MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
- for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
- params.add(sysIntParamDO.getParamkey(), sysIntParamDO.getParamvalue());
- }
- params.add(DATA_PARAM_NAME,sendString);
- 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);
- }
- 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(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, sendString, 10000);
+ /***
+ * 鎵嬪姩鍚屾
+ * @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("鎵嬪姩鎺ㄩ�佸畬鎴�,璇锋牳瀵规槸鍚︽帹閫佹垚鍔�");
+ }
- } else {//corba鎺ュ彛
- //paramString=sendString;
- // backString = jacorbClient.getBOFactoryService().sendCode(sendString);
- }
+ 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);
- ResultJsonDTO resultJsonDTO = new ResultJsonDTO();
- if(returnType.equals(MdmDuckingConstant.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();
+ return searchItemDataVO;
+ }
- }catch (Throwable e){
- msg="璋冪敤鎺ュ彛澶辫触:"+e;
- e.printStackTrace();
- // throw new Throwable("璋冪敤鎺ュ彛澶辫触:"+e);
- ResultNodeObjectDTO resultNodeObjectDTO=new ResultNodeObjectDTO();
- resultNodeObjectDTO.setErroid("1");
- resultNodeObjectDTO.setMsg(msg);
- resultNodeObjectDTO.setCode(sysIntInfoVO.getPushType().equalsIgnoreCase("2")?dockingTaskDO.getClassifyid():dockingTaskDO.getId());
- resultNodeObjectDTO.setOid(dockingTaskDO.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;
- }
- DockingLogeDO dockingLogeDO = new DockingLogeDO();
- String oid=redisService.getUUIDEveryDay();
- dockingLogeDO.setOid(oid);
- dockingLogeDO.setSystemcode(dockingTaskDO.getSystemcode());
- dockingLogeDO.setSystemname(dockingTaskDO.getSystemname());
- dockingLogeDO.setSystemoid(dockingTaskDO.getSystemoid());
- dockingLogeDO.setClassifyoid(dockingTaskDO.getClassifyoid());
- dockingLogeDO.setClassifyid(dockingTaskDO.getClassifyid());
- dockingLogeDO.setClassifyname(dockingTaskDO.getClassifyname());
- dockingLogeDO.setId(dockingTaskDO.getId());
- dockingLogeDO.setUniquecode(dockingTaskDO.getUniquecode());
- dockingLogeDO.setParamstring(paramString);
- dockingLogeDO.setReturnstring(backString);
- dockingLogeDO.setInterfacestatus(isSend?"true":"false");
- dockingLogeDO.setType(MdmDuckingConstant.DATA_LOGE_OUT);
- dockingLogeDO.setMsg(msg);
- logger.error("闆嗘垚鎺ㄩ�佹暟鎹�,systemcode:"+dockingTaskDO.getSystemcode()+",systemname:"+dockingTaskDO.getSystemname()+",url:"+url+",param:"+paramString+",e:"+msg);
- BatchCBO dockingLogeDOBo = dockingLogeDaoI.insert(dockingLogeDO);
- batchCBO.copyFromOther(dockingLogeDOBo);
- }
- //鍏ㄩ兘鎺ユ敹鎴愬姛鐨勬儏鍐典笅,淇敼dockingtask sendflag涓哄凡鍙戦��
- if(isSend) {
- dockingTaskDO.setSendflag(MdmDuckingConstant.SEND_FLAG_TRUE);
- BatchCBO updateTask = dockingTaskDaoI.updateByPrimaryKey(dockingTaskDO);
- batchCBO.copyFromOther(updateTask);
- }
- }
- }
- 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);
- }
+ 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();
+ }
+ org.springblade.core.tool.utils.WebUtil.setRequest(new ServletRequestAttributes(request));
+ }
+ return request;
+ }
- @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){
+ /***
+ * 鍚屾鍨嬪彿浠ｅ彿
+ */
+ @Override
+ public void saveItemDataSyncScheduing(String endDate) throws ServiceException {
+ 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("鏌ヨ鏃堕棿------->" + dft.format(new Date()));
+ lastchangedon = dft.format(calendar.getTime());
+ } else {
+ lastchangedon = endDate;
+ }
+ searchItemParam.setLastchangedon(lastchangedon);
+ searchItemParam.setIsenabled("");
+ searchItemParam.setStatus(itemStatus);
+ //Map<String,String> searchDataMap = VciBaseUtil.objectToMapString(searchItemParam);
+ try {
+ String sendParamString = JSONObject.toJSON(searchItemParam).toString();
+ // TODO: 鏀逛负浣跨敤HttpUtils鏂瑰紡杩涜鐢宠锛屽洜涓虹幇鍦ㄧ敵璇风敤涔嬪墠鐨勬柟寮忎細鎶ラ敊
+ LinkedMultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
+ headers.add("Authorization", ERPXHDHAUTH);
+ headers.add("X-ECC-Current-Tenant", ERPXHDHTENANT);
+ headers.add("Accept-Language", "zh-CHS");
+ headers.add("Content-Type", MediaType.APPLICATION_JSON.toString());
+ String res = HttpUtils.request(ERPXHDHURL + "/getppModelByElemNew", sendParamString, headers, HttpMethod.POST, MediaType.APPLICATION_JSON);
+ // String res= mdmSearchItemCodeProvider.getppModelByElem(searchItemParam);
+ SearchItemVO searchItemVO = JSONObject.toJavaObject(JSONObject.parseObject(res), SearchItemVO.class);
+ if (searchItemVO != null) {
+ if (!"200".equals(searchItemVO.getStatus())) {
+ throw new ServiceException(String.format("鎺ュ彛杩斿洖鐘舵�佺爜涓猴細%s锛屽師鍥狅細%s", searchItemVO.getStatus(), searchItemVO.getMessage()));
+ }
+ BladeUser finalUser;
+ paramString = JSONObject.toJSON(searchItemVO).toString();
+ log.info("鍨嬪彿浠ｅ彿鏁版嵁鍊�-------銆�" + paramString);
+ HttpServletRequest request = getRequest();
+ try {
+ //鍏嶅瘑鐧诲綍鐢宠token锛宺equest涓坊鍔犵敤鎴蜂俊鎭�
+ try {
+ passwordFreeLoginService.pwdFreeLoginByBoolean(systemId.toLowerCase(Locale.ROOT), request);
+ BladeUser user = AuthUtil.getUser();
+ if (Func.isEmpty(user)) {
+ user = request.getAttribute("_BLADE_USER_REQUEST_ATTR_") == null ? null : (BladeUser) request.getAttribute("_BLADE_USER_REQUEST_ATTR_");
+ }
+ finalUser = user;
+ } catch (Throwable e) {
+ throw new Throwable("鐢ㄦ埛閴存潈澶辫触.");
+ }
+ 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("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙朚DM绯荤粺涓搴旀ā鏉�");
+ }
+ 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<SearchItemUpperCaseDataVO> dataList = searchItemVO.getData();
+ Map<String, SearchItemUpperCaseDataVO> dataVOMap = new HashMap<>();
+ List<String> itemCodeList = new ArrayList<>();
+ ApplyDatasVO allDatasVO = new ApplyDatasVO();
+ List<ApplyDataVO> allObjectList = new ArrayList<>();
+ if (Func.isNotEmpty(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());
- }
- return u;
- }
+ //List<BaseModel> baseModelList=new ArrayList<>();
+ Map<String, BaseModel> baseModelMap = new HashMap<>();
+ if (!CollectionUtils.isEmpty(newDataList)) {
+ newDataList.stream().forEach(dataMap -> {
+ BaseModel baseModel = new BaseModel();
+ Map<String, String> newDateMap = new CaseInsensitiveMap<>(dataMap);
+ DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(newDateMap, baseModel, true, finalUser);
+ DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel, finalUser);
+ //baseModelList.add(baseModel);
+ String attrKeyValue = newDateMap.getOrDefault(attrKey, "");
+ if (StringUtils.isBlank(attrKeyValue)) {
+ log.info(baseModel.getId());
+ }
+ 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(), finalUser, "editstatus", editObjectList);
+ } else {
+ changeObjectToMap(value, "", finalUser, "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("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙朚DM绯荤粺涓搴旇鍒�");
+ }
+ 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 ServiceException(e.getMessage());
+ }
+ throw new ServiceException(e1.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());
+ });
+ List<CodeOrderSecDTO> codeOrderSecDTOList = new ArrayList<>();
+ Map<String, String> errorMap = new HashMap<>();
+ String nullSymbol = EnumCache.getValue("nullSymbol", "NULL");
+ nullSymbol = Func.isBlank(nullSymbol) ? "#NaN?":nullSymbol;
+ 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) || nullSymbol.equals(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)&&!name.equals(secName)) {
+ 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("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + libray + "浠庨厤缃枃浠朵腑鎵惧搴斿睘鎬ф槧灏勯厤缃�");
+ if (libPropMaps.containsKey(libray.toUpperCase(Locale.ROOT))) {
+ log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + 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("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + libray + "鍖归厤鍒扮浉搴旂殑灞炴�ф槧灏勪俊鎭�,灞炴�ф槧灏勬潯鐩暟+" + clsfAttrMappingDOList.size());
+ } else {
+ throw new Throwable("鏍规嵁绯荤粺鏍囪瘑銆�" + systemId + "銆戞壘鍒板搴旂殑閰嶇疆鏂囦欢:銆�" + path + "銆戯紝浣嗘湭鑾峰彇鍒板搴旂殑搴撱��" + libray + "銆戝睘鎬ф槧灏勪俊鎭厤缃�");
+ }
+ } else {
+ throw new Throwable("鏍规嵁绯荤粺鏍囪瘑銆�" + systemId + "銆戞壘鍒板搴旂殑閰嶇疆鏂囦欢:銆�" + path + "銆戯紝浣嗘湭鑾峰彇鍒板搴旂殑搴撱��" + libray + "銆戝睘鎬ф槧灏勪俊鎭厤缃�");
+ }
+ } else {
+ throw new Throwable("鏈幏鍙栧埌闆嗘垚灞炴�ф槧灏勭郴缁熼厤缃俊鎭�");
+ }
+ log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�" + 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(SearchItemUpperCaseDataVO 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);
+
+ Date cretaeDon = searchItemDataVO.getCREATEDON();//鍒涘缓鏃ユ湡 鏃ユ湡鍨嬶紝濡傦細2023-09-08 19:24:11
+ initProperty("cretaedon", "", Func.formatDateTime(cretaeDon), propList);
+ Date lastchangeDon = searchItemDataVO.getLASTCHANGEDON();//鏇存敼鏃堕棿 鏃ユ湡鍨嬶紝濡傦細2023-09-08 19:24:11
+ initProperty("lastchangedon", "", Func.formatDateTime(lastchangeDon), 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(StringUtils.isBlank(text) ? "" : text);
+ vo.setValue(StringUtils.isBlank(value) ? "" : value);
+ propList.add(vo);
+ }
+
+ /***
+ * 鏌ヨredis涓暟鎹紝瀵规瘮鍚庢彃鍏ockingtask
+ * @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瀵硅薄鐨刼id
+ 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;
+ }*/
+ /*//鏍规嵁褰撳墠鏁版嵁鐨刬d锛屾煡璇㈣幏鍙栧摢浜涚郴缁熼渶瑕佸仛闆嗘垚
+ 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);//鏁版嵁鍦ㄥ垎绫籭d
+ dockingTask.setClassifyOid(dataClassifyOid);//鏁版嵁鎵�鍦ㄥ垎绫籵id
+ 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鐨刼id
+ 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鍒嗚В浠诲姟澶辫触锛乨ataoid:" + dataoid);
+ continue;
+ }
+ }
+ });
+
+ }
+
+ /***
+ * 鍙戦�佸垎绫绘暟鎹�
+ */
+ private void sendpushClsfForService(List<DockingTask> dockingTaskList) {
+ //姣忎釜task渚濇鎵ц鎺ㄩ��
+ for (DockingTask dockingTask : dockingTaskList) {
+ //姣忎釜task涓�涓簨鍔★紝寮�鍚�
+ String paramString = "";
+ Object sendString = "";
+ String backString = "";
+ //鏌ヨ绯荤粺鎺ュ彛淇℃伅,ip method,dataType
+ String systeminfooid = dockingTask.getSysInfoOid();//sysininfo 鐨刼id
+ 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());//鐖秈d鑺傜偣
+ 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;
+ } 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 {
+ //姣忎竴涓猼ask涓�涓簨鐗�
+ }
+ }
+ }
+
+ /***
+ * 鍙戦�佺紪鐮佷富鏁版嵁
+ */
+ private void sendpushDataForService(List<DockingTask> dockingTaskS) {
+ //姣忎釜task渚濇鎵ц鎺ㄩ��
+ for (DockingTask dockingTask : dockingTaskS) {
+ //姣忎釜task涓�涓簨鍔★紝寮�鍚�
+ String paramString = "";
+ Object sendString = "";
+ String backString = "";
+ try {
+ //鏌ヨ绯荤粺鎺ュ彛淇℃伅,ip method,dataType
+ String systeminfooid = dockingTask.getSysInfoOid();//sysininfo 鐨刼id
+ 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());
+ log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒版煡璇富鏁版嵁鍜屾ā鏉垮睘鎬ч樁娈碉紒锛�");
+ 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<>();
+ // TODO: 鍥炴敹缂栫爜鐨勬儏鍐碉紝浼氬嚭鐜版暟鎹凡缁忓洖鏀讹紝浣嗘槸浜嬪姟杩樻湭鎵ц鐨勬儏鍐碉紝
+ // 瀵艰嚧鍙栦笉鍒扮爜鍊硷紝鎵�浠ヨ繖鍎块�氳繃鏌ヨ鐮佸�艰〃涓瓨鍌ㄧ殑宸插洖鏀剁殑涓氬姟鏁版嵁淇℃伅锛岃В鏋愬嚭鏉�
+ if (!r.isSuccess() || Func.isEmpty(r.getData())) {
+ List<CodeAllCode> codeAllCodes = codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getId, dockingTask.getId()));
+ CodeAllCode codeAllCode = codeAllCodes.get(0);
+ BaseModel baseModel = JSONObject.parseObject(codeAllCode.getBusinessData(), BaseModel.class);
+ Map<String, Object> objectMap = VciBaseUtil.objectToMap(baseModel);
+ for (Map.Entry<String, Object> entry : objectMap.entrySet()) {
+ if (entry.getKey().equals("data") && Func.isNotEmpty(entry.getValue())) {
+ Map<String, Object> dataMap = (Map<String, Object>) ((JSONObject) entry.getValue());
+ for (Map.Entry<String, Object> dataEntry : dataMap.entrySet()) {
+ String v = String.valueOf(dataEntry.getValue());
+ data.put(dataEntry.getKey().toLowerCase(Locale.ROOT), v == null ? "" : v);
+ }
+ } else {
+ String key = entry.getKey().toLowerCase(Locale.ROOT);
+ String value = String.valueOf(entry.getValue());
+ data.put(key, value == null ? "" : value);
+ }
+ }
+ /*JSONObject josni = bladeRedis.get(DOCKING_CACHE2_DELETE + btmoid);
+ data = (Map) josni;*/
+ } else {
+ data = r.getData().get(0);
+ }
+ List<NodeProDTO> nodeProDTOS = new ArrayList<>();
+ final Map<String, String> finalData = data;
+ List<String> newItemId = new ArrayList<>();
+ finalData.keySet().forEach(field -> {
+ if (field.toLowerCase(Locale.ROOT).equals(itemId.toLowerCase(Locale.ROOT))) {
+ String Value = finalData.get(field);
+ newItemId.add(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.parseBoolean(dockingSystemConfig.getIsGroupCodeFlag());
+ }
+ if (isGroupCodeFlage) {
+ code = data.getOrDefault("groupcode", "");
+ if (StringUtils.isBlank(code)) {
+ //濡傛灉鏄帹閫侀泦鍥㈢爜锛屾病鏈夐鍙栧埌闆嗗洟鐮佸垯浠诲姟涓嶇粨鏉熺瓑寰呴泦鍥㈢爜鐢宠鍚庡啀閫氳繃瀹氭椂鍣ㄨ皟鐢ㄩ泦鍥㈢爜娈�
+ dockingTask.setDescription("绛夊緟闆嗗洟鐢宠闆嗗洟鐮�");
+ // TODO锛氬彲鑳戒細鍑虹幇鏈幏鍙栧埌闆嗗洟鐮侊紝浣嗘槸鍙堢珛椹墽琛屼簡鍥炴敹锛屾鏃惰繖鏉′换鍔″氨姘歌繙鏃犳硶缁撴潫,鎵�浠ヨ繖鍎垮垽鏂彧瑕佹槸闆嗗洟鐮佷负绌猴紝骞朵笖鏄洖鏀剁殑灏卞叧闂帹閫佽繖鏉′换鍔�
+ 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(0));
+ 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();
+ sendString = object;
+ } 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);
+ }
+ log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒拌皟鐢℉R鎺ュ彛浜嗭紒锛�");
+ //璋冪敤鎺ュ彛
+ callInterface(sendString, dockingSystemConfig, dockingTask, "pushData");
+ } catch (Throwable e) {
+ e.printStackTrace();
+ } finally {
+ }
+ }
+ }
+
+ /***
+ * 璋冪敤鎺ュ彛锛屼紶鍙備负JSON鏃朵紶object绫诲瀷,Content-Type鏀逛负鐣岄潰閰嶇疆鐨�
+ * @param sendObject
+ * @param dockingSystemConfig
+ * @param dockingTask
+ * @throws Throwable
+ */
+ private void callInterface(Object sendObject, DockingSystemConfig dockingSystemConfig, DockingTask dockingTask, String operation) throws Throwable {
+ String paramString = "";
+ String backString = "";
+ String sendString = sendObject.toString();
+ 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();//涓昏鏄痺ebservice鐨勬柟娉曞悕
+ String namespace = dockingSystemConfig.getNamespace();//namespace
+ String soapaction = dockingSystemConfig.getSoapAction();//soapaction
+ String targName = dockingSystemConfig.getTargetName();//targName
+ String cxfaxis = dockingSystemConfig.getCxfAxis();//webservice鏄痗xf/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, Object> params = new LinkedMultiValueMap<>();
+ for (DockingSysIntParam dockingSysIntParam : dockingSysIntParamList) {
+ params.add(dockingSysIntParam.getParamKey(), dockingSysIntParam.getParamValue());
+ }
+ params.add(DATA_PARAM_NAME, sendObject);
+ paramString = params.toString();
+ MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
+ for (DockingSysIntHeader dockingSysIntHeader : dockingSysIntHeaderList) {
+ headers.add(dockingSysIntHeader.getHeaderKey(), dockingSysIntHeader.getHeaderValue());
+ }
+ log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒拌皟鐢ㄦ帴鍙ｄ簡锛屽湴鍧�锛�" + url);
+ backString = HttpUtils.postByMediaType(
+ url,
+ params,
+ headers,
+ Func.isNotBlank(dockingSystemConfig.getContentType()) ? MediaType.valueOf(dockingSystemConfig.getContentType()) : MediaType.APPLICATION_FORM_URLENCODED
+ );
+ }
+ 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;
+ log.info("鎺ㄩ�佷汉鍛樻暟鎹紝鎵ц鍒癴inal闃舵浜�");
+ 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;
+ }
+
}
--
Gitblit v1.9.3