¶Ô±ÈÐÂÎļþ |
| | |
| | | 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.dto.CodeOrderDTO; |
| | | import com.vci.ubcs.code.dto.CodeOrderSecDTO; |
| | | import com.vci.ubcs.code.dto.datapush.classify.JsonRootDataDTO; |
| | | import com.vci.ubcs.code.dto.datapush.classify.NodeClassifyDTO; |
| | | import com.vci.ubcs.code.dto.datapush.classify.NodeDataDTO; |
| | | import com.vci.ubcs.code.dto.datapush.classify.NodeLibraryDTO; |
| | | import com.vci.ubcs.code.dto.datapush.data.NodeJosnDTO; |
| | | import com.vci.ubcs.code.dto.datapush.data.NodeObjectDTO; |
| | | import com.vci.ubcs.code.dto.datapush.data.NodeProDTO; |
| | | import com.vci.ubcs.code.dto.datapush.data.NodedataDTO; |
| | | import com.vci.ubcs.code.dto.datapush.result.ResultJsonDTO; |
| | | import com.vci.ubcs.code.dto.datapush.result.ResultNodeDataDTO; |
| | | import com.vci.ubcs.code.dto.datapush.result.ResultNodeObjectDTO; |
| | | import com.vci.ubcs.code.entity.*; |
| | | import com.vci.ubcs.code.enumpack.CodeDefaultLC; |
| | | import com.vci.ubcs.code.enumpack.CodeSecTypeEnum; |
| | | import com.vci.ubcs.code.enumpack.SysIntegrationDataFlowTypeEnum; |
| | | import com.vci.ubcs.code.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.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 xiejun |
| | | * @date 2023-06-19 |
| | | **/ |
| | | |
| | | @Service |
| | | @Slf4j |
| | | public class CodeDuckingSyncServiceImpl implements ICodeDuckingSyncService { |
| | | |
| | | @Value("${dataSyncPush.dataParamName:xmlData}") |
| | | public String DATA_PARAM_NAME; |
| | | @Value("${dataSyncPush.dataId:itemid}") |
| | | private String itemId; |
| | | @Value("${erp.item.attrKey:xhdh}") |
| | | public String attrKey; |
| | | @Value("${erp.item.itemStatus:2}") |
| | | public String itemStatus; |
| | | |
| | | @Value("${erp.item.systemId:ERP}") |
| | | public String systemId; |
| | | @Value("${erp.item.secName:åºå®ç 段}") |
| | | public String secName; |
| | | @Value("${erp.item.secValue:A}") |
| | | public String secValue; |
| | | |
| | | @Value("${erp.item.btmName:XHDH}") |
| | | public String btmName; |
| | | |
| | | @Value("${erp.item.bearer:bearer: Bearer 7fc32939-0a59-da71-a6e6-6b0d37b53e8a}") |
| | | private String ERPXHDHAUTH; |
| | | |
| | | @Value("${erp.item.url:http://127.0.0.1/api/pp/pp/ext/extend/v1.0}") |
| | | private String ERPXHDHURL; |
| | | |
| | | @Value("${erp.item.tenant:10000}") |
| | | private String ERPXHDHTENANT; |
| | | |
| | | /** |
| | | * ä¸å¡ç±»åçæå¡ |
| | | */ |
| | | @Autowired |
| | | private IBtmTypeClient btmTypeClient; |
| | | |
| | | /** |
| | | * éç¨æ¥è¯¢ |
| | | */ |
| | | @Resource |
| | | private CommonsMapper commonsMapper; |
| | | |
| | | @Resource |
| | | private MdmEngineService mdmEngineServiceI; |
| | | |
| | | /** |
| | | * æ¹éå¤ççæå¡ |
| | | */ |
| | | @Resource |
| | | private MdmIOService mdmIOService; |
| | | |
| | | @Resource |
| | | private IPasswordFreeLoginService passwordFreeLoginService; |
| | | |
| | | @Resource |
| | | private IDockingLogeService dockingLogeService; |
| | | |
| | | @Resource |
| | | private IDockingDataService dockingDataService; |
| | | |
| | | @Resource |
| | | private IDockingTaskService dockingTaskService; |
| | | |
| | | @Resource |
| | | private IDockingSystemConfigService dockingSystemConfigService; |
| | | |
| | | @Resource |
| | | private ICodeClassifyService codeClassifyService; |
| | | |
| | | @Autowired |
| | | private ICodeClassifyValueService codeClassifyValueService; |
| | | |
| | | @Autowired(required = false) |
| | | private AttributeMapConfig attributeMapConfig; |
| | | |
| | | /*** |
| | | * resdisç¼åæå¡ |
| | | */ |
| | | //@Resource |
| | | //private BladeRedis bladeRedis; |
| | | |
| | | @Resource |
| | | private IDockingSysIntParamService dockingSysIntParamService; |
| | | |
| | | @Resource |
| | | private IDockingSysIntHeaderService dockingSysIntHeaderService; |
| | | |
| | | //@Autowired(required = false) |
| | | //private MdmSearchItemCodeProvider mdmSearchItemCodeProvider; |
| | | |
| | | @Resource |
| | | private ICodeAllCodeService codeAllCodeService; |
| | | |
| | | @Override |
| | | public void DockingDataSyncScheduing() { |
| | | // insertCache2(); |
| | | initPushDataTaks(1); |
| | | sendpushDataForService(); |
| | | } |
| | | |
| | | /*** |
| | | * |
| | | */ |
| | | @Override |
| | | public void DockingClassSyncScheduing() { |
| | | initPushDataTaks(2);//åç±»æ¨é |
| | | sendpushClsfForService(); |
| | | } |
| | | |
| | | /*** |
| | | * æå¨åæ¥ |
| | | * @param oids |
| | | * @return |
| | | */ |
| | | @Transactional(rollbackFor = Throwable.class) |
| | | @Override |
| | | public R sendData(String oids) { |
| | | VciBaseUtil.alertNotNull(oids, "ç³»ç»éæåºç¡ä¿¡æ¯æ°æ®å¯¹è±¡", oids, "ç³»ç»éæåºç¡ä¿¡æ¯ç主é®"); |
| | | List<String> dockingTaskOidList = new ArrayList<>(); |
| | | dockingTaskOidList = VciBaseUtil.str2List(oids); |
| | | List<DockingTask> newDockingTasks = this.dockingTaskService.listByIds(dockingTaskOidList); |
| | | Map<String, List<DockingTask>> typeDockingTaskMap = new HashMap<>(); |
| | | newDockingTasks.stream().forEach(newDockingTaskDO -> { |
| | | String btmId = newDockingTaskDO.getBtmId(); |
| | | if (btmId.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))) { |
| | | List<DockingTask> dockingTaskList = typeDockingTaskMap.get(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT)); |
| | | if (CollectionUtils.isEmpty(dockingTaskList)) { |
| | | dockingTaskList = new ArrayList<>(); |
| | | } |
| | | dockingTaskList.add(newDockingTaskDO); |
| | | typeDockingTaskMap.put(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT), dockingTaskList); |
| | | } else { |
| | | List<DockingTask> dockingTaskDOList = typeDockingTaskMap.get("data"); |
| | | if (CollectionUtils.isEmpty(dockingTaskDOList)) { |
| | | dockingTaskDOList = new ArrayList<>(); |
| | | } |
| | | dockingTaskDOList.add(newDockingTaskDO); |
| | | typeDockingTaskMap.put("data", dockingTaskDOList); |
| | | } |
| | | }); |
| | | typeDockingTaskMap.keySet().forEach(type -> { |
| | | List<DockingTask> DockingTaskList = typeDockingTaskMap.get(type); |
| | | if (!CollectionUtils.isEmpty(DockingTaskList)) { |
| | | if (type.equalsIgnoreCase(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT))) { |
| | | this.sendpushClsfForService(DockingTaskList); |
| | | } else { |
| | | this.sendpushDataForService(DockingTaskList); |
| | | } |
| | | } |
| | | }); |
| | | return R.success("æå¨æ¨é宿,è¯·æ ¸å¯¹æ¯å¦æ¨éæå"); |
| | | } |
| | | |
| | | private SearchItemDataVO initData(String status, String itemCode, String mmCode) { |
| | | SearchItemDataVO searchItemDataVO = new SearchItemDataVO(); |
| | | searchItemDataVO.setLastchangedon(new Date()); |
| | | searchItemDataVO.setLastchangedby("19831133"); |
| | | searchItemDataVO.setCreatby("19831133"); |
| | | searchItemDataVO.setCreatedon(new Date()); |
| | | searchItemDataVO.setIsenabled(status); |
| | | searchItemDataVO.setMaterialcode("XMDH0001"); |
| | | searchItemDataVO.setStatus("1"); |
| | | searchItemDataVO.setProjectcode("3333"); |
| | | searchItemDataVO.setProjectitem(itemCode); |
| | | searchItemDataVO.setMmodelcode(mmCode); |
| | | |
| | | return searchItemDataVO; |
| | | } |
| | | |
| | | public HttpServletRequest getRequest() { |
| | | HttpServletRequest request = null; |
| | | RequestAttributes requestAttributes = null; |
| | | try { |
| | | requestAttributes = RequestContextHolder.currentRequestAttributes(); |
| | | } catch (IllegalStateException e) { |
| | | //requestAttributes = new NonWebRequestAttributes(); |
| | | //RequestContextHolder.setRequestAttributes(requestAttributes, true); |
| | | request = new MockHttpServletRequest(); |
| | | RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request), true); |
| | | } finally { |
| | | if (requestAttributes instanceof ServletRequestAttributes) { |
| | | ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes(); |
| | | request = servletRequestAttributes.getRequest(); |
| | | } |
| | | org.springblade.core.tool.utils.WebUtil.setRequest(new ServletRequestAttributes(request)); |
| | | } |
| | | return request; |
| | | } |
| | | |
| | | /*** |
| | | * 忥åå·ä»£å· |
| | | */ |
| | | @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ï¼request䏿·»å ç¨æ·ä¿¡æ¯ |
| | | 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("æ ¹æ®ä¼ è¾çåç±»ï¼æªè·åMDMç³»ç»ä¸å¯¹åºæ¨¡æ¿"); |
| | | } |
| | | List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && |
| | | ((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag())) |
| | | ).collect(Collectors.toList()); |
| | | List<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()); |
| | | |
| | | //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("æ ¹æ®ä¼ è¾çåç±»ï¼æªè·åMDMç³»ç»ä¸å¯¹åºè§å"); |
| | | } |
| | | DataObjectVO dataObjectVO = new DataObjectVO(); |
| | | ApplyDatasVO applyDatasVO = new ApplyDatasVO(); |
| | | applyDatasVO.setObject(addObjectList); |
| | | LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>(); |
| | | this.getConfigDatas(systemId, btmName, applyDatasVO, attrVOS, dataObjectVO); |
| | | CodeOrderDTO orderDTO = new CodeOrderDTO(); |
| | | orderDTO.setCodeClassifyOid(codeClassify.getOid());//åç±»ä¸»é® |
| | | //ç æ®µè®¾ç½® |
| | | List<SectionVO> section = new ArrayList<>(); |
| | | SectionVO sectionVO = new SectionVO(); |
| | | sectionVO.setValue(secValue); |
| | | sectionVO.setName(secName); |
| | | section.add(sectionVO); |
| | | log.info("endï¼è§åè·å宿¯"); |
| | | List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(section, ruleVO, classifyFullInfo); |
| | | log.info("endï¼ç 段è·å宿¯"); |
| | | orderDTO.setSecDTOList(codeOrderSecDTOList);//åç±»ç æ®µ |
| | | mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs, false); |
| | | allResultDataObjectDetailDOS.addAll(resultDataObjectDetailDOs); |
| | | } |
| | | //æ´æ°æ°æ®ï¼æ´æ°ç¶æï¼ |
| | | if (!CollectionUtils.isEmpty(editObjectList)) { |
| | | DataObjectVO dataObjectVO = new DataObjectVO(); |
| | | ApplyDatasVO applyDatasVO = new ApplyDatasVO(); |
| | | applyDatasVO.setObject(editObjectList); |
| | | LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>(); |
| | | CodeClassifyVO codeClassifyVO = new CodeClassifyVO(); |
| | | BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassify, codeClassifyVO); |
| | | this.getConfigDatas(systemId, btmName, applyDatasVO, attrVOS, dataObjectVO); |
| | | mdmIOService.batchSyncEditDatas(codeClassifyVO, dataObjectVO, resultDataObjectDetailDOs, false); |
| | | allResultDataObjectDetailDOS.addAll(resultDataObjectDetailDOs); |
| | | } |
| | | Object paramObject = JSONObject.toJSON(allDatasVO); |
| | | paramString = Func.isEmpty(paramObject) ? "" : paramObject.toString(); |
| | | Object backObject = JSONObject.toJSON(allResultDataObjectDetailDOS); |
| | | backString = Func.isEmpty(backObject) ? "" : backObject.toString(); |
| | | } |
| | | } catch (Throwable e) { |
| | | e.printStackTrace(); |
| | | log.error("æ¥è¯¢å¤±è´¥--->" + e); |
| | | success = false; |
| | | backString = "æ¥è¯¢å¤±è´¥--->" + e; |
| | | msg = "æ¥è¯¢å¤±è´¥--->" + e; |
| | | throw new VciBaseException(e.getMessage()); |
| | | } finally { |
| | | try { |
| | | //è®°å½æ¥å¿ |
| | | this.saveLogs(systemId, systemId, paramString, backString, success, msg, "queryData"); |
| | | } catch (Throwable e) { |
| | | e.printStackTrace(); |
| | | log.error(e.getMessage()); |
| | | throw new VciBaseException(e.getMessage()); |
| | | } |
| | | } |
| | | } else { |
| | | throw new Throwable("æ¥å£æªè¿åä¿¡æ¯"); |
| | | } |
| | | } catch (Throwable e1) { |
| | | e1.printStackTrace(); |
| | | log.error("æ¥è¯¢å¤±è´¥--->" + e1); |
| | | //paramString=""; |
| | | success = false; |
| | | backString = "æ¥è¯¢å¤±è´¥--->" + e1; |
| | | msg = "æ¥è¯¢å¤±è´¥--->" + e1; |
| | | try { |
| | | //è®°å½æ¥å¿ |
| | | this.saveLogs(systemId, systemId, paramString, backString, success, msg, "queryData"); |
| | | } catch (Throwable e) { |
| | | e.printStackTrace(); |
| | | log.error(e.getMessage()); |
| | | throw new 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("æ ¹æ®åæ°ï¼librayï¼-ã" + libray + "ä»é
ç½®æä»¶ä¸æ¾å¯¹åºå±æ§æ å°é
ç½®"); |
| | | if (libPropMaps.containsKey(libray.toUpperCase(Locale.ROOT))) { |
| | | log.info("æ ¹æ®åæ°ï¼librayï¼-ã" + libray + "å¹é
å°ç¸åºç屿§æ å°ä¿¡æ¯"); |
| | | List<ClsfAttrMappingDO> clsfAttrMappingDOList = libPropMaps.get(libray.toUpperCase(Locale.ROOT)); |
| | | propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2)); |
| | | log.info("æ ¹æ®åæ°ï¼librayï¼-ã" + libray + "å¹é
å°ç¸åºç屿§æ å°ä¿¡æ¯,屿§æ å°æ¡ç®æ°+" + clsfAttrMappingDOList.size()); |
| | | } else { |
| | | throw new Throwable("æ ¹æ®ç³»ç»æ è¯ã" + systemId + "ãæ¾å°å¯¹åºçé
ç½®æä»¶:ã" + path + "ãï¼ä½æªè·åå°å¯¹åºçåºã" + libray + "ã屿§æ å°ä¿¡æ¯é
ç½®"); |
| | | } |
| | | } else { |
| | | throw new Throwable("æ ¹æ®ç³»ç»æ è¯ã" + systemId + "ãæ¾å°å¯¹åºçé
ç½®æä»¶:ã" + path + "ãï¼ä½æªè·åå°å¯¹åºçåºã" + libray + "ã屿§æ å°ä¿¡æ¯é
ç½®"); |
| | | } |
| | | } else { |
| | | throw new Throwable("æªè·åå°éæå±æ§æ å°ç³»ç»é
置信æ¯"); |
| | | } |
| | | log.info("æ ¹æ®åæ°ï¼librayï¼-ã" + libray + "ä»é
ç½®æä»¶ä¸æ¾å¯¹åºå±æ§æ å°é
ç½® end "); |
| | | LinkedList<String> rowNameList = new LinkedList<>(); |
| | | LinkedHashMap<String, Integer> filedIndexMap = new LinkedHashMap<>(); |
| | | //æ ¹æ®å类模æ¿ç»ç»æ°æ® |
| | | final int[] index = {0}; |
| | | try { |
| | | //é¤å»é»è®¤ç屿§.è¿æåªæå
·æå类注å
¥çæè¿æ»¤åºæ¥ |
| | | codeClassifyTemplateAttrVOList = codeClassifyTemplateAttrVOList.stream().filter( |
| | | s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && |
| | | ((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag())) |
| | | ).collect(Collectors.toList()); |
| | | codeClassifyTemplateAttrVOList.stream().forEach(codeClassifyTemplateAttrVO -> { |
| | | String attrName = codeClassifyTemplateAttrVO.getName(); |
| | | String field = codeClassifyTemplateAttrVO.getId(); |
| | | rowNameList.add(attrName); |
| | | filedIndexMap.put(field, index[0]++); |
| | | }); |
| | | dataObjectVO.setColName(rowNameList);//æ¾å
¥å±æ§ |
| | | attrMapConfigMap.putAll(propMaps); |
| | | LinkedList<RowDatas> rowDataList = new LinkedList<>(); |
| | | List<ApplyDataVO> applyDataVOList = new ArrayList<>(); |
| | | |
| | | if (!CollectionUtils.isEmpty(applyDatasVO.getObject())) { |
| | | applyDataVOList = applyDatasVO.getObject(); |
| | | } |
| | | //Map<String, List<ProppertyVO>> dataPropMap = applyDataVOList.stream().collect(Collectors.toMap(ApplyDataVO::getId, ApplyDataVO::getProp, (key1, key2) -> key2)); |
| | | final int[] rowIndex = {0}; |
| | | applyDataVOList.stream().forEach(applyDataVO -> { |
| | | rowIndex[0]++; |
| | | RowDatas rowDatas = new RowDatas(); |
| | | rowDatas.setOid(applyDataVO.getId()); |
| | | rowDatas.setCreator(applyDataVO.getCreator()); |
| | | rowDatas.setEditor(applyDataVO.getEditor()); |
| | | rowDatas.setCode(applyDataVO.getCode()); |
| | | rowDatas.setOperation(applyDataVO.getOperate()); |
| | | rowDatas.setStatus(applyDataVO.getStatus()); |
| | | rowDatas.setRowIndex(rowIndex[0] + ""); |
| | | List<ProppertyVO> proppertyVOList = applyDataVO.getProp(); |
| | | |
| | | LinkedHashMap<Integer, String> integerValueMap = new LinkedHashMap<>(); |
| | | Map<String, String> filedValueMap = new HashMap<>(); |
| | | if (!CollectionUtils.isEmpty(proppertyVOList)) { |
| | | Map<String, String> sourceKeyValueMap = proppertyVOList.stream().collect(Collectors.toMap(ProppertyVO::getKey, ProppertyVO::getValue, (key1, key2) -> key2)); |
| | | Map<String, String> keyValueMap = new HashMap<>(); |
| | | //夿attrMapConfigMapæ¯å¦æå¼ï¼å¦ææ²¡æå说æåºç¡é»è®¤çæ¯ç¼ç ç³»ç»å段 |
| | | if (!CollectionUtils.isEmpty(attrMapConfigMap)) { |
| | | sourceKeyValueMap.keySet().forEach(sourceKey -> { |
| | | String dataValue = sourceKeyValueMap.get(sourceKey); |
| | | if (attrMapConfigMap.containsKey(sourceKey)) { |
| | | String targetKey = attrMapConfigMap.get(sourceKey); |
| | | keyValueMap.put(targetKey, StringUtils.isBlank(dataValue) ? "" : dataValue); |
| | | } |
| | | }); |
| | | } else { |
| | | sourceKeyValueMap.forEach((filed, value) -> { |
| | | keyValueMap.put(filed, StringUtils.isBlank(value) ? "" : value); |
| | | }); |
| | | } |
| | | |
| | | filedIndexMap.forEach((attrKey, column) -> { |
| | | String keyValue = ""; |
| | | if (keyValueMap.containsKey(attrKey)) { |
| | | keyValue = StringUtils.isBlank(keyValueMap.get(attrKey)) ? "" : keyValueMap.get(attrKey); |
| | | } |
| | | integerValueMap.put(column, keyValue); |
| | | filedValueMap.put(attrKey, keyValue); |
| | | }); |
| | | } |
| | | rowDatas.setData(integerValueMap); |
| | | rowDatas.setFiledValue(filedValueMap); |
| | | rowDataList.add(rowDatas); |
| | | }); |
| | | dataObjectVO.setRowData(rowDataList); |
| | | } catch (Throwable e) { |
| | | throw new Throwable("ç»ç»æ°æ®æ å°å¼å¤±è´¥"); |
| | | } |
| | | } |
| | | |
| | | private void changeObjectToMap(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䏿°æ®ï¼å¯¹æ¯åæå
¥dockingtask |
| | | * @param type |
| | | */ |
| | | private void initPushDataTaks(int type) { |
| | | initSysadmin(); |
| | | List<DockingSystemConfig> dockingSystemConfigList = dockingSystemConfigService.list( |
| | | Wrappers.<DockingSystemConfig>query().lambda().eq(DockingSystemConfig::getUsedFlag, "true") |
| | | .eq(DockingSystemConfig::getPushType, type == 2 ? "2" : "1").eq(DockingSystemConfig::getDataFlowType, SysIntegrationDataFlowTypeEnum.PUSH.getValue()));//2æ¯ä»£è¡¨åç±»æ¨éï¼1æ¯ä»£è¡¨æ°æ®æ¨é |
| | | |
| | | if (CollectionUtils.isEmpty(dockingSystemConfigList)) { |
| | | String title = type == 2 ? "åç±»æ¨é" : "æ°æ®æ¨é"; |
| | | log.info("info->ææéæç³»ç»ï¼æªæ¥è¯¢å°ç¸å
³çã" + title + "ãçæ¥å£é
置信æ¯ï¼é
ç½®"); |
| | | return; |
| | | } |
| | | Map<String, List<DockingSystemConfig>> sysIntInfoDOMap = new HashMap<>();//key=classifyoid,value=list<map> |
| | | for (DockingSystemConfig dockingSystemConfig : dockingSystemConfigList) { |
| | | String classifyOid = dockingSystemConfig.getClassifyOid(); |
| | | String codeclassifOid = codeClassifyService.selectLeafByPid(classifyOid); |
| | | List<String> codeList = VciBaseUtil.str2List(codeclassifOid); |
| | | codeList.stream().forEach(oid -> { |
| | | List<DockingSystemConfig> dockingSystemList = sysIntInfoDOMap.get(oid); |
| | | if (Func.isEmpty(dockingSystemList)) { |
| | | dockingSystemList = new ArrayList<>(); |
| | | } |
| | | dockingSystemList.add(dockingSystemConfig); |
| | | sysIntInfoDOMap.put(oid, dockingSystemList); |
| | | }); |
| | | } |
| | | sysIntInfoDOMap.forEach((classifyOid, effectiveSysIntInfoVOs) -> { |
| | | //æ ¹æ®ç±»å廿¥è¯¢éè¦éæçåç±»æè
æ°æ® |
| | | LambdaQueryWrapper<DockingData> queryWrapper = Wrappers.<DockingData>lambdaQuery(); |
| | | queryWrapper.eq(DockingData::getSendFlag, "false"); |
| | | if (type == 2) { |
| | | queryWrapper.eq(DockingData::getBtmId, DOCKING_DEFAULT_CLASSIFY); |
| | | } else { |
| | | queryWrapper.ne(DockingData::getBtmId, DOCKING_DEFAULT_CLASSIFY); |
| | | queryWrapper.eq(DockingData::getClassifyOid, classifyOid); |
| | | } |
| | | List<DockingData> dataList = dockingDataService.list(queryWrapper); |
| | | for (DockingData mapi : dataList) { |
| | | WebUtil.setPersistence(false); |
| | | String dataoid = mapi.getOid();//data对象çoid |
| | | String dataClassifyOid = mapi.getClassifyOid(); |
| | | String id = mapi.getId(); |
| | | String uniquecode = mapi.getUniqueCode(); |
| | | String btmid = mapi.getBtmId(); |
| | | String btmoid = mapi.getBtmOid(); |
| | | String sendtype = mapi.getSendType(); |
| | | String classifyid = mapi.getClassifyId(); |
| | | String classifyname = mapi.getClassifyName(); |
| | | String curentClassOid = null; |
| | | if (!dataClassifyOid.equals(classifyOid)) { |
| | | continue; |
| | | } |
| | | /*if(type==2){ |
| | | curentClassOid=btmoid; |
| | | }else{ |
| | | curentClassOid=classifyoid; |
| | | }*/ |
| | | /*//æ ¹æ®å½åæ°æ®çidï¼æ¥è¯¢è·ååªäºç³»ç»éè¦åéæ |
| | | List<CodeClassify> parentLeveDO= codeClassifyService.selectAllLevelParentByOid(curentClassOid); |
| | | if(CollectionUtils.isEmpty(parentLeveDO)){ |
| | | continue;//说æè¿ä¸ªåç±»è¢«å æäºï¼ä¸åå¤ç |
| | | } |
| | | Map<String, CodeClassify> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t)); |
| | | |
| | | oidCodeclassifyDOMap.keySet().forEach(oid->{ |
| | | if(sysIntInfoDOMap.containsKey(oid)){ |
| | | List<DockingSystemConfig> sysIntInfoDOS= sysIntInfoDOMap.get(oid); |
| | | effectiveSysIntInfoVOs.addAll(sysIntInfoDOS); |
| | | } |
| | | }); |
| | | //å¦ææ ¡éªçç³»ç»æ¥å£ä¿¡æ¯ä¸åå¨ï¼åæ°æ®ä¸ä¸å¾ä¿¡æ¯éæ¨é |
| | | if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){ |
| | | continue; |
| | | }*/ |
| | | List<DockingTask> dockingTask_insert = new ArrayList<>(); |
| | | for (DockingSystemConfig sysIntInfoVOi : effectiveSysIntInfoVOs) { |
| | | DockingTask dockingTask = new DockingTask(); |
| | | dockingTask.setOid(VciBaseUtil.getPk()); |
| | | dockingTask.setSendFlag(SEND_FLAG_FALSE); |
| | | dockingTask.setId(id);//ç¼ç |
| | | dockingTask.setUniqueCode(uniquecode); |
| | | dockingTask.setBtmOid(btmoid);//æ°æ®oid |
| | | dockingTask.setBtmId(btmid);//æ°æ®ä¸å¡ç±»åid |
| | | dockingTask.setClassifyId(classifyid);//æ°æ®å¨åç±»id |
| | | dockingTask.setClassifyOid(dataClassifyOid);//æ°æ®æå¨åç±»oid |
| | | dockingTask.setClassifyName(classifyname);//æ°æ®æå¨åç±»åç§° |
| | | dockingTask.setSendType(sendtype);//æ°æ®æ¨éç±»å |
| | | dockingTask.setDataOid(dataoid); |
| | | dockingTask.setCreateTime(new Date()); |
| | | dockingTask.setLastModifyTime(new Date()); |
| | | dockingTask.setCreator("sysAdmin"); |
| | | dockingTask.setLastModifier("sysAdmin"); |
| | | //intinfo |
| | | dockingTask.setSysInfoOid(sysIntInfoVOi.getOid());//intinfoçoid |
| | | dockingTask.setSystemOid(sysIntInfoVOi.getSysBaseOid());//ç³»ç»oid |
| | | dockingTask.setSystemCode(sysIntInfoVOi.getSysBaseId());//ç³»ç»ç¼ç |
| | | dockingTask.setSystemName(sysIntInfoVOi.getSysBaseName());//ç³»ç»name |
| | | dockingTask_insert.add(dockingTask); |
| | | } |
| | | |
| | | if (dockingTask_insert.size() != 0) { |
| | | dockingTaskService.saveBatch(dockingTask_insert); |
| | | } |
| | | //dockingTaskDaoI.updateByPrimaryKeyæ¹æ³æ¥éäºï¼æä»¥æåäºè¿ä¸ª |
| | | boolean u = updateDockingDatasSendFlag(dataoid, SEND_FLAG_TRUE); |
| | | if (!u) { |
| | | log.error("éædataå解任å¡å¤±è´¥ï¼dataoid:" + dataoid); |
| | | continue; |
| | | } |
| | | } |
| | | }); |
| | | |
| | | } |
| | | |
| | | /*** |
| | | * åéåç±»æ°æ® |
| | | */ |
| | | private void sendpushClsfForService(List<DockingTask> dockingTaskList) { |
| | | //æ¯ä¸ªtask便¬¡æ§è¡æ¨é |
| | | for (DockingTask dockingTask : dockingTaskList) { |
| | | //æ¯ä¸ªtaskä¸ä¸ªäºå¡ï¼å¼å¯ |
| | | String paramString = ""; |
| | | Object sendString = ""; |
| | | String backString = ""; |
| | | //æ¥è¯¢ç³»ç»æ¥å£ä¿¡æ¯,ip method,dataType |
| | | String systeminfooid = dockingTask.getSysInfoOid();//sysininfo çoid |
| | | try { |
| | | //æ¥è¯¢è¦æ¨éçæ°æ® |
| | | String btmoid = dockingTask.getBtmOid();//æ°æ®btmid |
| | | JsonRootDataDTO jsonRootDataDTO = new JsonRootDataDTO(); |
| | | CodeClassify codeClassify = codeClassifyService.getById(btmoid); |
| | | List<NodeClassifyDTO> nodeClassifyDTOList = new ArrayList<>(); |
| | | NodeClassifyDTO nodeClassifyDTO = new NodeClassifyDTO(); |
| | | nodeClassifyDTO.setClassCode(codeClassify.getId());//åç±»ä»£å· |
| | | nodeClassifyDTO.setDescription(codeClassify.getDescription());//åç±»æè¿° |
| | | nodeClassifyDTO.setFullPathName(codeClassify.getPath());//å
¨è·¯å¾ |
| | | nodeClassifyDTO.setLcStatus(codeClassify.getLcStatus());//ç¶æ |
| | | // CodeClassifyDO parentClassDo=codeClassifyDaoI.selectByPrimaryKey(codeClassifyDO.getParentCodeClassifyOid()); |
| | | nodeClassifyDTO.setPid(codeClassify.getParentCodeClassifyOid());//ç¶idèç¹ |
| | | nodeClassifyDTO.setId(codeClassify.getOid());//åç±»oid |
| | | nodeClassifyDTO.setName(codeClassify.getName());//åç±»åç§° |
| | | nodeClassifyDTOList.add(nodeClassifyDTO); |
| | | NodeLibraryDTO nodeLibraryDTO = new NodeLibraryDTO(); |
| | | CodeClassifyVO rootClassify = codeClassifyService.getTopClassifyVO(btmoid); |
| | | nodeLibraryDTO.setClassify(nodeClassifyDTOList); |
| | | nodeLibraryDTO.setId(rootClassify.getOid()); |
| | | nodeLibraryDTO.setName(rootClassify.getName()); |
| | | nodeLibraryDTO.setClassCode(rootClassify.getId()); |
| | | NodeDataDTO nodeDataDTO = new NodeDataDTO(); |
| | | nodeDataDTO.setLibrary(nodeLibraryDTO); |
| | | jsonRootDataDTO.setData(nodeDataDTO); |
| | | |
| | | //æ¥è¯¢æ¨éæ¥å£åæ° |
| | | DockingSystemConfig dockingSystemConfig = dockingSystemConfigService.getById(systeminfooid); |
| | | String paramType = dockingSystemConfig.getParamType();//xml/json |
| | | if (paramType.equals(DATATYPE_JSON)) { |
| | | Object object = JSONObject.toJSON(jsonRootDataDTO); |
| | | sendString = object; |
| | | } else { |
| | | //ç»ç»è¿åæ¥å£ä¿¡æ¯ |
| | | XStream xStream = new XStream(new DomDriver()); |
| | | xStream.processAnnotations(NodeDataDTO.class); |
| | | xStream.autodetectAnnotations(true); |
| | | sendString = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(nodeDataDTO); |
| | | } |
| | | //è°ç¨æ¥å£ |
| | | callInterface(sendString, dockingSystemConfig, dockingTask, "pushClassifyData"); |
| | | } catch (Throwable e) { |
| | | e.printStackTrace(); |
| | | } finally { |
| | | //æ¯ä¸ä¸ªtaskä¸ä¸ªäºç© |
| | | } |
| | | } |
| | | } |
| | | |
| | | /*** |
| | | * åéç¼ç ä¸»æ°æ® |
| | | */ |
| | | private void sendpushDataForService(List<DockingTask> dockingTaskS) { |
| | | //æ¯ä¸ªtask便¬¡æ§è¡æ¨é |
| | | for (DockingTask dockingTask : dockingTaskS) { |
| | | //æ¯ä¸ªtaskä¸ä¸ªäºå¡ï¼å¼å¯ |
| | | String paramString = ""; |
| | | Object sendString = ""; |
| | | String backString = ""; |
| | | try { |
| | | //æ¥è¯¢ç³»ç»æ¥å£ä¿¡æ¯,ip method,dataType |
| | | String systeminfooid = dockingTask.getSysInfoOid();//sysininfo çoid |
| | | String classifyoid = dockingTask.getClassifyOid(); |
| | | //æ¥è¯¢è¦æ¨éçæ°æ® |
| | | String btmoid = dockingTask.getBtmOid();//æ°æ®btmid |
| | | String code = dockingTask.getId(); |
| | | ; |
| | | //表示æ¯ä¸»æ°æ® |
| | | CodeClassifyTemplateVO codeClassifyTemplateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(classifyoid); |
| | | R<List<Map<String, String>>> r = mdmEngineServiceI.getDataByOid(btmoid, codeClassifyTemplateVO.getOid()); |
| | | 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("æ¨éäººåæ°æ®ï¼æ§è¡å°è°ç¨HRæ¥å£äºï¼ï¼"); |
| | | //è°ç¨æ¥å£ |
| | | 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();//ä¸»è¦æ¯webserviceçæ¹æ³å |
| | | String namespace = dockingSystemConfig.getNamespace();//namespace |
| | | String soapaction = dockingSystemConfig.getSoapAction();//soapaction |
| | | String targName = dockingSystemConfig.getTargetName();//targName |
| | | String cxfaxis = dockingSystemConfig.getCxfAxis();//webserviceæ¯cxf/axis |
| | | //æ¥è¯¢param |
| | | List<DockingSysIntParam> dockingSysIntParamList = dockingSysIntParamService.list(Wrappers.<DockingSysIntParam>query().lambda().eq(DockingSysIntParam::getInfoOid, dockingSystemConfig.getOid())); |
| | | //æ¥è¯¢header |
| | | List<DockingSysIntHeader> dockingSysIntHeaderList = dockingSysIntHeaderService.list(Wrappers.<DockingSysIntHeader>query().lambda().eq(DockingSysIntHeader::getInfoOid, dockingSystemConfig.getOid())); |
| | | if (type.equals(URLTYPE_HTTP)) { |
| | | if (requestmethod.equals(URLTYPE_GET)) {//GETè¯·æ± |
| | | String sendurl = url + "?" + DATA_PARAM_NAME + "=" + sendString; |
| | | //æ¼æ¥param |
| | | for (DockingSysIntParam dockingSysIntParam : dockingSysIntParamList) { |
| | | sendurl = sendurl + "&" + dockingSysIntParam.getParamKey() + "=" + dockingSysIntParam.getParamValue(); |
| | | } |
| | | paramString = sendurl; |
| | | backString = HttpUtils.get(sendurl); |
| | | } else if (requestmethod.equals(URLTYPE_POST)) {//POSTè¯·æ± |
| | | MultiValueMap<String, 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("æ¨éäººåæ°æ®ï¼æ§è¡å°finalé¶æ®µäº"); |
| | | 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; |
| | | } |
| | | |
| | | } |
| | | |