From c659560c7ee8d8f8278b938421de13bf65d1e1b1 Mon Sep 17 00:00:00 2001 From: ludc <ludc@vci-tech.com> Date: 星期三, 15 一月 2025 14:28:25 +0800 Subject: [PATCH] Merge remote-tracking branch 'origin/master' --- Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java | 1078 +++++++++++++++++++++++++++++++++++++++++++---------------- 1 files changed, 782 insertions(+), 296 deletions(-) diff --git a/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java b/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java index 22c0296..fcba915 100644 --- a/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java +++ b/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java @@ -1,24 +1,39 @@ package com.vci.web.service.impl; +import cn.hutool.core.io.FileUtil; +import cn.hutool.core.util.ZipUtil; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; +import com.vci.client.common.oq.OQTool; import com.vci.client.common.providers.ClientServiceProvider; -import com.vci.client.mw.ClientSessionUtility; +import com.vci.common.qt.object.Condition; +import com.vci.common.qt.object.QueryTemplate; +import com.vci.constant.FrameWorkLangCodeConstant; import com.vci.corba.common.PLException; import com.vci.corba.omd.atm.AttributeDef; import com.vci.corba.omd.btm.BizType; +import com.vci.corba.omd.data.AttributeValue; +import com.vci.corba.omd.data.BusinessObject; import com.vci.corba.omd.etm.EnumType; import com.vci.corba.omd.lcm.Bound; import com.vci.corba.omd.lcm.LifeCycle; import com.vci.corba.omd.ltm.LinkType; import com.vci.corba.omd.stm.StatePool; +import com.vci.corba.omd.tim.TypeIndexDef; import com.vci.corba.omd.vrm.VersionRule; import com.vci.dto.OsBtmTypeDTO; -import com.vci.dto.OsBtmTypeLinkAttributesDTO; +import com.vci.model.IndexObject; import com.vci.omd.constants.AttributeConstants; import com.vci.omd.constants.FileObjectType; import com.vci.omd.objects.OtherInfo; +import com.vci.omd.utils.ObjectTool; import com.vci.pagemodel.*; +import com.vci.po.OsBtmTypePO; +import com.vci.starter.poi.bo.ReadExcelOption; +import com.vci.starter.poi.bo.WriteExcelData; +import com.vci.starter.poi.bo.WriteExcelOption; +import com.vci.starter.poi.constant.ExcelLangCodeConstant; +import com.vci.starter.poi.util.ExcelUtil; import com.vci.starter.web.annotation.log.VciUnLog; import com.vci.starter.web.enumpck.BooleanEnum; import com.vci.starter.web.exception.VciBaseException; @@ -26,13 +41,12 @@ import com.vci.starter.web.pagemodel.DataGrid; import com.vci.starter.web.pagemodel.PageHelper; import com.vci.starter.web.pagemodel.Tree; -import com.vci.starter.web.util.BeanUtil; -import com.vci.starter.web.util.VciBaseUtil; -import com.vci.starter.web.util.VciDateUtil; -import com.vci.starter.web.util.WebThreadLocalUtil; +import com.vci.starter.web.util.*; +import com.vci.starter.web.util.Lcm.ConcurrentDateFormat; +import com.vci.starter.web.util.Lcm.DateUtil; +import com.vci.starter.web.util.Lcm.Func; +import com.vci.web.other.AllOsEnumVOMapThreadLocal; import com.vci.web.service.*; -import com.vci.web.util.ConcurrentDateFormat; -import com.vci.web.util.Func; import com.vci.web.util.PlatformClientUtil; import com.vci.web.util.WebUtil; import org.apache.commons.lang3.StringUtils; @@ -42,8 +56,10 @@ import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; import org.springframework.util.CollectionUtils; +import org.springframework.web.multipart.MultipartFile; -import javax.swing.*; +import javax.servlet.http.HttpServletResponse; +import java.io.File; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; @@ -135,8 +151,23 @@ @VciUnLog public List<OsBtmTypeVO> selectAllBtm() { try { - return btmDO2VOs(Arrays.stream(platformClientUtil.getBtmService().getBizTypes("")).collect(Collectors.toList())); - } catch (PLException e) { + return btmDO2VOs(Arrays.stream(platformClientUtil.getBtmService().getBizTypes("")).collect(Collectors.toList()),null); + } catch (PLException e) { + throw new RuntimeException(e); + } + } + + /** + * 鏌ヨ鎵�鏈夌殑涓氬姟绫诲瀷 + * + * @return 涓氬姟绫诲瀷瀵硅薄 + */ + @Override + @VciUnLog + public List<OsBtmTypeVO> selectAllBtm(Map<String, OsAttributeVO> attributeVOMap) { + try { + return btmDO2VOs(Arrays.stream(platformClientUtil.getBtmService().getBizTypes("")).collect(Collectors.toList()),attributeVOMap); + } catch (PLException e) { throw new RuntimeException(e); } } @@ -149,7 +180,17 @@ @Override @VciUnLog public Map<String, OsBtmTypeVO> selectAllBtmMap() { - return Optional.ofNullable(self.selectAllBtm()).orElseGet(()->new ArrayList<OsBtmTypeVO>()).stream().collect(Collectors.toMap(s->s.getId().toLowerCase(), t->t,(o1,o2)->o1)); + return Optional.ofNullable(self.selectAllBtm()).orElseGet(() -> new ArrayList<OsBtmTypeVO>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(), t -> t, (o1, o2) -> o1)); + } + /** + * 鏌ヨ鎵�鏈夌殑涓氬姟绫诲瀷鏄犲皠 + * + * @return key 鏄笟鍔$殑鑻辨枃鍚嶇О鐨勫皬鍐� + */ + @Override + @VciUnLog + public Map<String, OsBtmTypeVO> selectAllBtmMap(Map<String, OsAttributeVO> attributeVOMap) { + return Optional.ofNullable(self.selectAllBtm(attributeVOMap)).orElseGet(() -> new ArrayList<OsBtmTypeVO>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(), t -> t, (o1, o2) -> o1)); } /** @@ -159,12 +200,16 @@ * @return 鏄剧ず瀵硅薄 */ @Override - public List<OsBtmTypeVO> btmDO2VOs(Collection<BizType> btmItems) { + public List<OsBtmTypeVO> btmDO2VOs(Collection<BizType> btmItems,Map<String, OsAttributeVO> attributeVOMap) { List<OsBtmTypeVO> VOS = new ArrayList<>(); - Optional.ofNullable(btmItems).orElseGet(()->new ArrayList<>()).stream().forEach(btmItem -> { - OsBtmTypeVO vo = btmDO2VO(btmItem); +// Optional.ofNullable(btmItems).orElseGet(() -> new ArrayList<>()).parallelStream().forEach(btmItem -> { +// OsBtmTypeVO vo = btmDO2VO(btmItem,attributeVOMap); +// VOS.add(vo); +// }); + for (BizType btmItem : btmItems) { + OsBtmTypeVO vo = btmDO2VO(btmItem,attributeVOMap); VOS.add(vo); - }); + } return VOS; } @@ -175,9 +220,9 @@ * @return 鏄剧ず瀵硅薄 */ @Override - public OsBtmTypeVO btmDO2VO(BizType btmItem) { + public OsBtmTypeVO btmDO2VO(BizType btmItem, Map<String, OsAttributeVO> attributeVOMap) { OsBtmTypeVO vo = new OsBtmTypeVO(); - if(btmItem !=null){ + if (btmItem != null) { vo.setOid(btmItem.oid); vo.setCreator(btmItem.creator); vo.setLastModifier(btmItem.modifier); @@ -185,14 +230,14 @@ // btmItem.createTime鎷垮埌鐨勬槸鏃堕棿鎴筹紝浣嗘槸杩欏効瑕佺殑鏄緥濡�2017-12-27 09:32:20.034杩欐牱鐨勬牸寮忥紝鎵�浠ヤ笉璋冪敤杩欎釜鏂规硶锛屾敼璋冪敤鍏朵粬鏂规硶 //vo.setCreateTime(VciDateUtil.str2Date(String.valueOf(btmItem.createTime),VciDateUtil.DateTimeFormat)); vo.setCreateTime(Func.parse(btmItem.createTime, ConcurrentDateFormat.of(VciDateUtil.DateTimeFormat))); - vo.setLastModifyTime( Func.parse(btmItem.modifyTime, ConcurrentDateFormat.of(VciDateUtil.DateTimeFormat))); - vo.setTs(Func.parse(btmItem.ts, ConcurrentDateFormat.of(VciDateUtil.DateTimeFormat))); + vo.setLastModifyTime(Func.parse(btmItem.modifyTime, ConcurrentDateFormat.of(VciDateUtil.DateTimeFormat))); + vo.setTs(Func.parse(btmItem.ts, ConcurrentDateFormat.of(VciDateUtil.DateTimeMillFormat))); } catch (Exception e) { e.printStackTrace(); } vo.setDescription(btmItem.description); vo.setId(btmItem.name); - vo.setName(btmItem.label); + vo.setName(btmItem.label); vo.setLifeCycleId(btmItem.lifeCycle); vo.setAbstractFlag(btmItem.isAbstract); vo.setImplClass(btmItem.implClass); @@ -202,34 +247,39 @@ vo.setTableName(VciBaseUtil.getTableName(vo.getId())); vo.setInputRevisionFlag(btmItem.revInput); vo.setDelimiter(btmItem.delimiter); - if(StringUtils.isNotBlank(vo.getRevisionRuleId()) || vo.isInputRevisionFlag()){ + vo.setImageName(btmItem.imageName); + vo.setfName(btmItem.fName); + vo.setVersionRule(String.valueOf(btmItem.verRuleName)); + if (StringUtils.isNotBlank(vo.getRevisionRuleId()) || vo.isInputRevisionFlag()) { vo.setRevisionFlag(true); } - vo.setVersionRule(String.valueOf(btmItem.verRuleName)); - vo.setSubLifeCycleId(Arrays.stream(btmItem.lifeCycles).collect(Collectors.joining(","))); - List<OsAttributeVO> attributeVOS = attributeService.listAttrByIds(Arrays.stream(btmItem.apNameArray).collect(Collectors.toList())); + vo.setLifeCycleIds(Arrays.stream(btmItem.lifeCycles).collect(Collectors.joining(","))); + vo.setApNameArray(btmItem.apNameArray); + List<OsAttributeVO> attributeVOS = attributeService.listAttrByIds(Arrays.stream(btmItem.apNameArray).collect(Collectors.toList()),attributeVOMap); List<OsBtmTypeAttributeVO> btmTypeAttributeVOS = new ArrayList<>(); - Optional.ofNullable(attributeVOS).orElseGet(()->new ArrayList<>()).stream().forEach(attributeVO->{ +// Optional.ofNullable(attributeVOS).orElseGet(() -> new ArrayList<>()).stream().forEach(attributeVO -> { + for (OsAttributeVO attributeVO : attributeVOS) { OsBtmTypeAttributeVO btmTypeAttributeVO = new OsBtmTypeAttributeVO(); - BeanUtil.convert(attributeVO,btmTypeAttributeVO); + BeanUtilForVCI.convert(attributeVO, btmTypeAttributeVO); btmTypeAttributeVO.setPkBtmType(vo.getOid()); btmTypeAttributeVO.setBtmTypeId(vo.getId()); - btmTypeAttributeVO.setAttrDataType(attributeVO.getAttributeDataType()); + btmTypeAttributeVO.setAttributeDataType(attributeVO.getAttributeDataType()); btmTypeAttributeVO.setAttributeLength(attributeVO.getAttrLength()); btmTypeAttributeVO.setDefaultValue(attributeVO.getDefaultValue()); - if("secretgrade".equalsIgnoreCase(attributeVO.getId())){ + if ("secretgrade".equalsIgnoreCase(attributeVO.getId())) { vo.setSecretFlag(true); } - if(StringUtils.isNotBlank(attributeVO.getBtmTypeId())){ + if (StringUtils.isNotBlank(attributeVO.getBtmTypeId())) { btmTypeAttributeVO.setReferFlag(true); btmTypeAttributeVO.setReferBtmTypeId(attributeVO.getBtmTypeId()); } - if(StringUtils.isNotBlank(attributeVO.getEnumId())){ + if (StringUtils.isNotBlank(attributeVO.getEnumId())) { btmTypeAttributeVO.setEnumFlag(true); btmTypeAttributeVO.setEnumItemMap(enumService.getEnumValueMap(btmTypeAttributeVO.getEnumId())); } btmTypeAttributeVOS.add(btmTypeAttributeVO); - }); +// }); + } vo.setAttributes(btmTypeAttributeVOS); } return vo; @@ -243,15 +293,15 @@ */ @Override public List<OsBtmTypeVO> listBtmByIds(Collection<String> btmIds) { - if(CollectionUtils.isEmpty(btmIds)){ + if (CollectionUtils.isEmpty(btmIds)) { return null; } - Map<String, OsBtmTypeVO> btmTypeVOMap = self.selectAllBtmMap(); + //Map<String, OsBtmTypeVO> btmTypeVOMap = self.selectAllBtmMap(); + BtmDataFetcher btmDataFetcher = new BtmDataFetcher(); List<OsBtmTypeVO> btmTypeVOS = new ArrayList<>(); - btmIds.stream().forEach(id->{ - if(btmTypeVOMap.containsKey(id.toLowerCase())){ - btmTypeVOS.add(btmTypeVOMap.get(id.toLowerCase())); - } + btmIds.stream().forEach(id -> { + OsBtmTypeVO btmType = btmDataFetcher.getBtmType(id); + btmTypeVOS.add(btmType); }); return btmTypeVOS; } @@ -263,11 +313,44 @@ * @return 涓氬姟绫诲瀷 */ @Override - public OsBtmTypeVO getBtmById(String id) { - if(StringUtils.isBlank(id)){ + public OsBtmTypeVO getBtmById(String id) throws PLException { + if (StringUtils.isBlank(id)) { return null; } - return self.selectAllBtmMap().getOrDefault(id.toLowerCase(),null); + BizType bizType = platformClientUtil.getBtmService().getBizTypeByName(id); + return btmDO2VO(bizType,null); + } + + /** + * 浣跨敤绫诲瀷鍚嶈幏鍙栦笟鍔$被鍨�,鏌ヤ笉鍒扮洿鎺ユ姤閿� + * @param btmName 绫诲瀷鍚� + * @return 涓氬姟绫诲瀷 + * @throws + */ + @Override + public OsBtmTypeVO getBtmByName(String btmName) throws PLException{ + if(Func.isBlank(btmName)){ + throw new PLException("500",new String[]{"鏌ヨ鏉′欢绫诲瀷鍚嶄笉鑳戒负绌猴紒"}); + } + BizType bizType = platformClientUtil.getBtmService().getBizTypeByName(btmName); + if(Func.isEmpty(bizType) || Func.isBlank(bizType.oid)){ + throw new PLException("500",new String[]{"鏍规嵁銆�"+btmName+"銆戞湭鏌ヨ鍒板搴斾笟鍔$被鍨嬶紒"}); + } + return btmDO2VO(bizType,null); + } + + /** + * 浣跨敤缂栧彿鑾峰彇涓氬姟绫诲瀷 + * + * @param id 缂栧彿 + * @return 涓氬姟绫诲瀷 + */ + @Override + public OsBtmTypeVO getBtmById(String id,Map<String, OsAttributeVO> attributeVOMap) { + if (StringUtils.isBlank(id)) { + return null; + } + return self.selectAllBtmMap(attributeVOMap).getOrDefault(id.toLowerCase(), null); } /** @@ -278,33 +361,33 @@ */ @Override public List<OsUsedAttributeVO> listBtmUsedInfo(String btmName) { - return listBtmUsedInfo(btmName,false); + return listBtmUsedInfo(btmName, false); } /** * 鑾峰彇涓氬姟绫诲瀷鐨勫湪鍝釜灞炴�т腑浣跨敤 * - * @param btmId 涓氬姟绫诲瀷 + * @param btmId 涓氬姟绫诲瀷 * @param hasLink 鏄惁鍖呭惈閾炬帴绫诲瀷涓� * @return 寮曠敤鐨勪俊鎭� */ @Override - public List<OsUsedAttributeVO> listBtmUsedInfo(String btmId, boolean hasLink){ - VciBaseUtil.alertNotNull(btmId,"涓氬姟绫诲瀷鐨勫悕绉�"); - List<OsAttributeVO> allReferThisBtmAttributes = Optional.ofNullable(attributeService.selectAllAttribute()).orElseGet(()->new ArrayList<>()).stream().filter(s->btmId.equalsIgnoreCase(s.getBtmTypeId())).collect(Collectors.toList()); - if(CollectionUtils.isEmpty(allReferThisBtmAttributes)){ + public List<OsUsedAttributeVO> listBtmUsedInfo(String btmId, boolean hasLink) { + VciBaseUtil.alertNotNull(btmId, "涓氬姟绫诲瀷鐨勫悕绉�"); + List<OsAttributeVO> allReferThisBtmAttributes = Optional.ofNullable(attributeService.selectAllAttribute()).orElseGet(() -> new ArrayList<>()).stream().filter(s -> btmId.equalsIgnoreCase(s.getBtmTypeId())).collect(Collectors.toList()); + if (CollectionUtils.isEmpty(allReferThisBtmAttributes)) { return null; } //鏍规嵁杩欎簺灞炴�э紝鎵惧畠浣跨敤鐨勪笟鍔$被鍨� - List<OsUsedAttributeVO> usedInfos= new ArrayList<>(); + List<OsUsedAttributeVO> usedInfos = new ArrayList<>(); List<OsBtmTypeVO> btmTypeVOMap = self.selectAllBtmMap().values().stream().collect(Collectors.toList()); List<OsLinkTypeVO> linkTypeVOS = linkTypeService.selectAllLinkMap().values().stream().collect(Collectors.toList()); - allReferThisBtmAttributes.stream().forEach(attribute->{ + allReferThisBtmAttributes.stream().forEach(attribute -> { //鍏朵粬鐨勪笟鍔$被鍨嬪寘鍚簡杩欎釜灞炴�х殑 List<OsBtmTypeVO> usedBtms = btmTypeVOMap.stream().filter(btmTypeVO -> !CollectionUtils.isEmpty(btmTypeVO.getAttributes()) && btmTypeVO.getAttributes().stream().anyMatch(s -> attribute.getId().equalsIgnoreCase(s.getId()))).collect(Collectors.toList()); - if(!CollectionUtils.isEmpty(usedBtms)){ - usedBtms.stream().forEach(btm->{ - btm.getAttributes().stream().filter(s->attribute.getId().equalsIgnoreCase(s.getId())).forEach(attrInBtm->{ + if (!CollectionUtils.isEmpty(usedBtms)) { + usedBtms.stream().forEach(btm -> { + btm.getAttributes().stream().filter(s -> attribute.getId().equalsIgnoreCase(s.getId())).forEach(attrInBtm -> { OsUsedAttributeVO usedAttributeVO = new OsUsedAttributeVO(); usedAttributeVO.setId(attrInBtm.getId()); usedAttributeVO.setName(attrInBtm.getName()); @@ -314,11 +397,11 @@ }); }); } - if(hasLink){ - List<OsLinkTypeVO> usedLinks = linkTypeVOS.stream().filter(linkTypeVO -> !CollectionUtils.isEmpty(linkTypeVO.getAttributes()) &&linkTypeVO.getAttributes().stream().anyMatch(s->attribute.getId().equalsIgnoreCase(s.getId())) ).collect(Collectors.toList()); - if(!CollectionUtils.isEmpty(usedLinks)){ - usedLinks.stream().forEach(link->{ - link.getAttributes().stream().filter(s->attribute.getId().equalsIgnoreCase(s.getId())).forEach(attrInBtm->{ + if (hasLink) { + List<OsLinkTypeVO> usedLinks = linkTypeVOS.stream().filter(linkTypeVO -> !CollectionUtils.isEmpty(linkTypeVO.getAttributes()) && linkTypeVO.getAttributes().stream().anyMatch(s -> attribute.getId().equalsIgnoreCase(s.getId()))).collect(Collectors.toList()); + if (!CollectionUtils.isEmpty(usedLinks)) { + usedLinks.stream().forEach(link -> { + link.getAttributes().stream().filter(s -> attribute.getId().equalsIgnoreCase(s.getId())).forEach(attrInBtm -> { OsUsedAttributeVO usedAttributeVO = new OsUsedAttributeVO(); usedAttributeVO.setId(attrInBtm.getId()); usedAttributeVO.setName(attrInBtm.getName()); @@ -340,11 +423,16 @@ * @return 灞炴�х殑鍐呭 */ @Override - public List<OsBtmTypeAttributeVO> listAttributeByBtmId(String btmId) { - VciBaseUtil.alertNotNull(btmId,"涓氬姟绫诲瀷鐨勭紪鍙�"); - OsBtmTypeVO btmTypeVO = getBtmById(btmId); + public List<OsBtmTypeAttributeVO> listAttributeByBtmId(String btmId) throws PLException { + VciBaseUtil.alertNotNull(btmId, "涓氬姟绫诲瀷鐨勭紪鍙�"); + BizType[] bizTypes = platformClientUtil.getBtmService().getBizTypes(btmId); + if (Func.isEmpty(bizTypes)) { + return new ArrayList<>(); + } + BizType bizType = bizTypes[0]; + OsBtmTypeVO btmTypeVO = btmDO2VO(bizType,null); List<OsBtmTypeAttributeVO> attributes = btmTypeVO.getAttributes(); - if(attributes == null){ + if (attributes == null) { attributes = new ArrayList<>(); } return attributes.stream().sorted(((o1, o2) -> o1.getId().toLowerCase(Locale.ROOT).compareTo(o2.getId().toLowerCase(Locale.ROOT)))).collect(Collectors.toList()); @@ -357,17 +445,18 @@ * @return 灞炴�х殑鍐呭 */ @Override - public List<OsBtmTypeAttributeVO> listAttributeByBtmIdHasDefault(String btmId) { + public List<OsBtmTypeAttributeVO> listAttributeByBtmIdHasDefault(String btmId) throws PLException { List<OsBtmTypeAttributeVO> attrVOs = listAttributeByBtmId(btmId); - if(attrVOs == null){ + if (attrVOs == null) { attrVOs = new ArrayList<>(); } - if(!CollectionUtils.isEmpty(attributeService.getDefaultAttributeVOs())) { + List<OsAttributeVO> defaultAttributeVOs = attributeService.getDefaultAttributeVOs(); + if (!CollectionUtils.isEmpty(defaultAttributeVOs)) { List<OsBtmTypeAttributeVO> finalAttrVOs = attrVOs; - attributeService.getDefaultAttributeVOs().stream().forEach(attr->{ + defaultAttributeVOs.stream().forEach(attr -> { OsBtmTypeAttributeVO attributeVO = new OsBtmTypeAttributeVO(); - BeanUtil.convert(attr, attributeVO); - attributeVO.setAttrDataType(attr.getAttributeDataType()); + BeanUtilForVCI.convert(attr, attributeVO); + attributeVO.setAttributeDataType(attr.getAttributeDataType()); attributeVO.setAttributeLength(attr.getAttrLength()); attributeVO.setReferBtmTypeId(attr.getBtmTypeId()); attributeVO.setReferBtmTypeName(attr.getBtmTypeName()); @@ -375,7 +464,8 @@ }); attrVOs = finalAttrVOs; } - return attrVOs; + // TODO: 2024/12/2 Ludc 杩斿洖鍊兼帓搴� + return attrVOs.stream().sorted(Comparator.comparing(o->o.getId(),String.CASE_INSENSITIVE_ORDER)).collect(Collectors.toList()); } /** @@ -388,6 +478,7 @@ /** * 淇敼涓氬姟绫诲瀷涓搴斿睘鎬у悕鐨勫睘鎬� + * * @param apName * @return * @throws PLException @@ -402,7 +493,7 @@ } catch (PLException e1) { e1.printStackTrace(); } - if(abItem == null || abItem.equals("")){ + if (abItem == null || abItem.equals("")) { return true; } try { @@ -410,21 +501,21 @@ } catch (PLException e) { e.printStackTrace(); } - if(btmNames == null || btmNames.length <= 0){ + if (btmNames == null || btmNames.length <= 0) { return true; } btmNameList = Arrays.asList(btmNames); - for(Iterator<String> i = btmNameList.iterator(); i.hasNext();){ + for (Iterator<String> i = btmNameList.iterator(); i.hasNext(); ) { String btmName = i.next(); try { platformClientUtil.getBtmService().modifyBTAttribute(btmName, apName); } catch (PLException e) { // TODO Auto-generated catch block e.printStackTrace(); - String erreMsg = "璋冩暣涓氬姟绫诲瀷涓��"+apName+"銆戝睘鎬ф椂鍑虹幇閿欒锛屽師鍥狅細"+e.getMessage(); + String erreMsg = "璋冩暣涓氬姟绫诲瀷涓��" + apName + "銆戝睘鎬ф椂鍑虹幇閿欒锛屽師鍥狅細" + e.getMessage(); logger.error(erreMsg); - throw new PLException("500",new String[]{erreMsg}); + throw new PLException("500", new String[]{erreMsg}); } } return false; @@ -439,14 +530,14 @@ @Override public boolean hasInstance(String abName) throws PLException { String[] btmNames = platformClientUtil.getBtmService().getBTNamesByAPName(abName); - if(btmNames == null || btmNames.length == 0){ + if (btmNames == null || btmNames.length == 0) { return false; } - for(int i = 0; i < btmNames.length; i++){ + for (int i = 0; i < btmNames.length; i++) { String btmName = btmNames[i]; boolean flag; flag = platformClientUtil.getBtmService().hasData(btmName); - if(flag){ + if (flag) { return flag; } } @@ -456,16 +547,55 @@ /** * 鑾峰彇鍚嶅瓧浠ilter寮�濮嬬殑涓氬姟绫诲瀷(for 鏌ヨ)锛屼富瑕佺敤浜庡睘鎬ф睜鐨勪笟鍔$被鍨嬮�夋嫨瀵硅瘽妗� * 鑾峰彇鍏ㄩ儴涓氬姟绫诲瀷锛屼紶鍙俧ilter涓�"" + * * @param btmName * @return * @throws PLException */ @Override public BizType[] getBizTypes(String btmName) throws PLException { - if(null == btmName){ + if (null == btmName) { btmName = ""; } return platformClientUtil.getBtmService().getBizTypes(btmName); + } + + /** + * 涓氬姟绫诲瀷鍒楄〃鏌ヨ锛岄潪鏍戠粨鏋勶細鐢ㄤ簬UI瀹氫箟宸︿晶涓氬姟绫诲瀷鏌ヨ锛屽彧杩斿洖name鍜宭able + * + * @param btmName + * @return + * @throws PLException + */ + @Override + public Tree getBizTree(String btmName) throws PLException { + if (null == btmName) { + btmName = ""; + } + Tree returnTree = new Tree(); + BizType[] bizTypes = platformClientUtil.getBtmService().getBizTypes(btmName); + if (Func.isEmpty(bizTypes)) { + return returnTree; + } + returnTree.setOid(""); + returnTree.setText("涓氬姟绫诲瀷"); + returnTree.setLeaf(false); + List<Tree> trees = new ArrayList<>(); + Arrays.stream(bizTypes).forEach(bizType -> { + Tree tree = new Tree(); + tree.setText(bizType.name + " " + bizType.label); + tree.setOid(bizType.oid); + tree.setLeaf(true); + tree.setParentName(bizType.fName); + tree.setIcon(bizType.imageName); + Map<String, String> atrrMap = new HashMap<>(); + atrrMap.put("name", bizType.name); + atrrMap.put("label", bizType.label); + tree.setAttributes(atrrMap); + trees.add(tree); + }); + returnTree.setChildren(trees); + return returnTree; } /** @@ -477,7 +607,7 @@ */ @Override public DataGrid<OsBtmTypeVO> referDataGrid(Map<String, String> conditionMap, PageHelper pageHelper) { - DataGrid<OsBtmTypeVO> dataGrid = queryObjectServiceInfoBySql(conditionMap, pageHelper, "plbtmtype",OsBtmTypeVO.class,((data, obj) -> { + DataGrid<OsBtmTypeVO> dataGrid = queryObjectServiceInfoBySql(conditionMap, pageHelper, "plbtmtype", OsBtmTypeVO.class, ((data, obj) -> { obj.setTableName(VciBaseUtil.getTableName(obj.getId())); })); return dataGrid; @@ -492,7 +622,7 @@ @Override public OsBtmTypeVO selectByOid(String oid) { List<OsBtmTypeVO> btmTypeVOS = self.selectAllBtmMap().values().stream().collect(Collectors.toList()); - return Optional.ofNullable(btmTypeVOS).orElseGet(()->new ArrayList<>()).stream().filter(s->s.getOid().equalsIgnoreCase(oid)).findFirst().orElseGet(()->null); + return Optional.ofNullable(btmTypeVOS).orElseGet(() -> new ArrayList<>()).stream().filter(s -> s.getOid().equalsIgnoreCase(oid)).findFirst().orElseGet(() -> null); } /** @@ -502,10 +632,10 @@ * @return 鏋氫妇鐨勫悕绉� */ @Override - public String getNameById(String id) { + public String getNameById(String id) throws PLException { OsBtmTypeVO btmTypeVO = getBtmById(id); - if(btmTypeVO == null){ - throw new VciBaseException("涓氬姟绫诲瀷[{0}]鍦ㄧ郴缁熼噷涓嶅瓨鍦�",new String[]{id}); + if (btmTypeVO == null) { + throw new VciBaseException("涓氬姟绫诲瀷[{0}]鍦ㄧ郴缁熼噷涓嶅瓨鍦�", new String[]{id}); } return btmTypeVO.getName(); } @@ -516,13 +646,13 @@ * @param btmId 涓氬姟绫诲瀷涓婚敭 */ @Override - public OsERVO createERDiagram(String btmId) { + public OsERVO createERDiagram(String btmId) throws PLException { VciBaseUtil.alertNotNull(btmId, "涓氬姟绫诲瀷缂栧彿"); OsBtmTypeVO btmTypeVO = getBtmById(btmId); List<OsERNodeVO> nodeVOList = new ArrayList<>(); List<OsERRelationVO> relationVOList = new ArrayList<>(); //鐪嬪綋鍓嶈繖涓笟鍔$被鍨嬶紝鍙傜収浜嗗叾浠栫殑鍝簺涓氬姟绫诲瀷 .鎴戜滑涓嶆樉绀哄紩鐢ㄥ綋鍓嶄笟鍔$被鍨嬬殑涓氬姟绫诲瀷 - splicingBtmType2Json(nodeVOList, relationVOList, btmTypeVO,true); + splicingBtmType2Json(nodeVOList, relationVOList, btmTypeVO, true); loadAllLinkTypeByBtmType(nodeVOList, relationVOList, btmTypeVO); OsERVO osERVO = new OsERVO(); osERVO.setTabViewList(nodeVOList); @@ -537,32 +667,32 @@ * @return 鎵ц缁撴灉 */ @Override - public OsERVO createERUsed(String btmId) { + public OsERVO createERUsed(String btmId) throws PLException { VciBaseUtil.alertNotNull(btmId, "涓氬姟绫诲瀷缂栧彿"); OsBtmTypeVO btmTypeVO = getBtmById(btmId); //鑾峰彇浣跨敤褰撳墠绫诲瀷鐨勫睘鎬� List<OsUsedAttributeVO> usedAttributeVOS = listBtmUsedInfo(btmTypeVO.getId()); List<OsERNodeVO> nodeVOList = new ArrayList<>(); List<OsERRelationVO> relationVOList = new ArrayList<>(); - splicingBtmType2Json(nodeVOList, relationVOList, btmTypeVO,false); - if(!CollectionUtils.isEmpty(usedAttributeVOS)){ - usedAttributeVOS.stream().forEach(usedAttr->{ + splicingBtmType2Json(nodeVOList, relationVOList, btmTypeVO, false); + if (!CollectionUtils.isEmpty(usedAttributeVOS)) { + usedAttributeVOS.stream().forEach(usedAttr -> { //涓氬姟绫诲瀷鍜岄摼鎺ョ被鍨嬮兘鏈夊彲鑳� - if(BooleanEnum.TRUE.getValue().equalsIgnoreCase(usedAttr.getBusinessType())){ + if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(usedAttr.getBusinessType())) { //涓氬姟绫诲瀷 OsBtmTypeVO linkBtmVO = self.selectAllBtmMap().get(usedAttr.getPkBtmType().toLowerCase(Locale.ROOT)); - splicingBtmType2Json(nodeVOList, relationVOList, linkBtmVO,false); + splicingBtmType2Json(nodeVOList, relationVOList, linkBtmVO, false); OsERRelationVO relationVO = new OsERRelationVO(); relationVO.setTo(btmTypeVO.getId() + " " + btmTypeVO.getName()); relationVO.setFrom(linkBtmVO.getId() + " " + linkBtmVO.getName()); relationVO.setToText("寮曠敤"); relationVOList.add(relationVO); - }else{ + } else { //鏄摼鎺ョ被鍨� OsLinkTypeVO linkTypeVO = linkTypeService.selectAllLinkMap().get(usedAttr.getPkBtmType().toLowerCase(Locale.ROOT)); List<OsLinkTypeVO> linkTypeVOList = new ArrayList<>(); linkTypeVOList.add(linkTypeVO); - splicingLinkType2Json(nodeVOList, relationVOList,linkTypeVOList,btmTypeVO,true); + splicingLinkType2Json(nodeVOList, relationVOList, linkTypeVOList, btmTypeVO, true); } }); } @@ -574,39 +704,52 @@ /** * 鑾峰彇鎵�鏈変笟鍔$被鍨嬶紙鏍戝舰缁撴瀯锛� + * * @return 鏌ヨ缁撴灉 */ @Override public List<Tree> getTreeBizTypes() throws PLException { List<Tree> rootTreeList = new ArrayList<>(); BizType[] bizTypes = getBizTypes(""); - BizType btItem = null; - for(int i = 0; i < bizTypes.length; i++){ - btItem = bizTypes[i]; - if(btItem.fName.equals("")){ + OsBtmTypeVO osBtmTypeVO = null; + Map<String, OsAttributeVO> attributeVOMap = null; + if(bizTypes.length > 0){ + //鍏堝皢鎵�闇�瑕佺殑灞炴�с�佹灇涓炬暟鎹叏閮ㄥ姞杞藉嚭鏉ワ紝閬垮厤鍚庣画杩涜閲嶅鍔犺浇 + attributeVOMap = attributeService.selectAllAttributeMap(); + AllOsEnumVOMapThreadLocal.set(enumService.selectAllEnumMap()); + } + List<OsBtmTypeVO> osBtmTypeVOS = btmDO2VOs(Arrays.asList(bizTypes),attributeVOMap); + for (int i = 0; i < osBtmTypeVOS.size(); i++) { + osBtmTypeVO = osBtmTypeVOS.get(i); + + if (osBtmTypeVO.getfName().equals("")) { Tree tree = new Tree(); - tree.setOid(btItem.oid); + tree.setOid(osBtmTypeVO.getOid()); tree.setParentName(null); tree.setParentId(null); tree.setLeaf(true); - tree.setText(btItem.description); - tree.setAttributes(WebUtil.objectToMapString(btItem)); - tree.setChildren(getChildren(bizTypes,btItem)); + tree.setIcon(osBtmTypeVO.getImageName()); + tree.setId(osBtmTypeVO.getId()); + tree.setText(osBtmTypeVO.getDescription()); + tree.setAttributes(WebUtil.objectToMapString(osBtmTypeVO)); + tree.setChildren(getChildren(osBtmTypeVOS, osBtmTypeVO)); rootTreeList.add(tree); } } - + AllOsEnumVOMapThreadLocal.remove(); + rootTreeList = rootTreeList.stream().sorted((o1, o2) -> o1.getId().compareTo(o2.getId())).collect(Collectors.toList()); return rootTreeList; } /** * 鑾峰彇鎵�鏈変笟鍔$被鍨嬪悕绉伴泦鍚� + * * @return */ @Override public List<String> getAllBtmName() throws PLException { BizType[] bizTypes = platformClientUtil.getBtmService().getBizTypes(""); - if(null != bizTypes && bizTypes.length > 0){ + if (null != bizTypes && bizTypes.length > 0) { return Arrays.stream(bizTypes).map(bizType -> bizType.name).collect(Collectors.toList()); } return null; @@ -614,6 +757,7 @@ /** * 鑾峰彇涓氬姟鍏ㄩ儴灞炴�х被鍨� + * * @param btmName 涓氬姟绫诲瀷鍚嶇О * @return 灞炴�х殑淇℃伅 */ @@ -628,7 +772,7 @@ AttributeDef sysAttributeDef = collect.get(attrName.toLowerCase()); OsBtmTypeAttributeVO vo = new OsBtmTypeAttributeVO(); vo.setOid(sysAttributeDef.oid); - vo.setAttrDataType(sysAttributeDef.vtDataType); + vo.setAttributeDataType(sysAttributeDef.vtDataType); vo.setPkBtmType(btmName); vo.setCreateTime(new Date(sysAttributeDef.createTime)); vo.setCreator(sysAttributeDef.creator); @@ -647,7 +791,7 @@ for (AttributeDef attribute : attributeDefs) { OsBtmTypeAttributeVO vo = new OsBtmTypeAttributeVO(); vo.setOid(attribute.oid); - vo.setAttrDataType(attribute.vtDataType); + vo.setAttributeDataType(attribute.vtDataType); vo.setPkBtmType(btmName); vo.setCreateTime(new Date(attribute.createTime)); vo.setCreator(attribute.creator); @@ -661,7 +805,7 @@ vo.setOwner(attribute.creator); vo.setLastModifyTime(new Date(attribute.modifyTime)); String maxLength = AttributeConstants.getOtherValueByType(attribute.other, AttributeConstants.LENGTH); - if(StringUtils.isNotBlank(maxLength)){ + if (StringUtils.isNotBlank(maxLength)) { vo.setAttributeLength(Integer.valueOf(maxLength)); } osBtms.add(vo); @@ -671,15 +815,18 @@ /** * dto杞琩o瀵硅薄 + * * @return */ - private BizType dto2BizType(OsBtmTypeDTO dto){ + private BizType dto2BizType(OsBtmTypeDTO dto) { BizType bizType = new BizType(); - bizType.name =dto.getId(); + bizType.oid = dto.getOid(); + bizType.name = dto.getId(); bizType.isAbstract = dto.isAbstractFlag(); bizType.label = dto.getName(); bizType.fName = dto.getfName(); bizType.implClass = dto.getImplClass(); + bizType.imageName = dto.getImageName(); bizType.shape = ""; bizType.lifeCycle = dto.getLifeCycleId(); List<String> lcList = Arrays.asList(dto.getSubLifeCycleId().split(",")); @@ -690,35 +837,31 @@ } bizType.description = dto.getDescription(); bizType.revLevel = dto.getRevLevel(); - - bizType.revRuleName = dto.getRevisionRuleName(); + bizType.revRuleName = dto.getRevisionRuleId(); bizType.revInput = dto.isInputRevisionFlag(); - bizType.delimiter = (dto.getDelimiter() == null ? "" : dto.getDelimiter()); - - bizType.verRuleName = Short.parseShort(dto.getRevisionRuleName()); - - //bizType.imageName = dto.get; + bizType.verRuleName = Func.isBlank(dto.getVersionRule()) ? 0 : Short.parseShort(dto.getVersionRule()); //List<String> attrIdList = dto.getAttributesDTOList().stream().map(OsBtmTypeLinkAttributesDTO::getId).collect(Collectors.toList()); - - bizType.apNameArray = dto.getApNameArray();//attrIdList.toArray(new String[attrIdList.size()]); + bizType.apNameArray = dto.getApNameArray().split(",");//attrIdList.toArray(new String[attrIdList.size()]); String userId = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId(); long timeMillis = System.currentTimeMillis(); - bizType.creator = Func.isBlank(dto.getCreator()) ? userId:dto.getCreator(); - bizType.createTime = Func.isEmpty(dto.getCreateTime()) ? timeMillis:dto.getCreateTime().getTime(); + bizType.creator = Func.isBlank(dto.getCreator()) ? userId : dto.getCreator(); + bizType.createTime = Func.isEmpty(dto.getCreateTime()) ? timeMillis : dto.getCreateTime().getTime(); bizType.modifier = userId; bizType.modifyTime = timeMillis; + bizType.ts = Func.isEmpty(dto.getTs()) ? timeMillis : dto.getTs().getTime(); return bizType; } /** * 鍒涘缓鏂扮殑涓氬姟绫诲瀷 + * * @return * @throws PLException */ @Override public boolean addBtmType(OsBtmTypeDTO btmTypeDTO) throws PLException { - VciBaseUtil.alertNotNull(btmTypeDTO,"鍒涘缓鐨勪笟鍔$被鍨嬪璞�"); + VciBaseUtil.alertNotNull(btmTypeDTO, "鍒涘缓鐨勪笟鍔$被鍨嬪璞�"); //涓氬姟绫诲瀷鍚嶇О妫�鏌� checkName(btmTypeDTO.getId()); //鐢熷懡鍛ㄦ湡妫�鏌� @@ -734,7 +877,7 @@ * @param bizTypes * @return */ - @Override +/* @Override public boolean addBtmTypes(List<BizType> bizTypes) { VciBaseUtil.alertNotNull(bizTypes,"鍒涘缓鐨勪笟鍔$被鍨嬪璞″垪琛�"); bizTypes.stream().forEach(bizType->{ @@ -747,32 +890,32 @@ throw new VciBaseException(exceptionMessage); } }); - return true; - } + }*/ /** * 妫�鏌ヤ笟鍔$被鍨嬪悕绉版槸鍚﹀悎瑙� + * * @param btmName * @throws PLException */ private void checkName(String btmName) throws PLException { if (Func.isBlank(btmName)) { - throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶄笉鑳戒负绌�!"}); + throw new PLException("500", new String[]{"涓氬姟绫诲瀷鍚嶄笉鑳戒负绌�!"}); } if (!btmName.matches("[a-z A-Z]*")) { - throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶅彧鑳戒负鑻辨枃瀛楁瘝!"}); + throw new PLException("500", new String[]{"涓氬姟绫诲瀷鍚嶅彧鑳戒负鑻辨枃瀛楁瘝!"}); } int maxLength = platformClientUtil.getBtmService().getBTNameMaxLength(); if (btmName.length() > maxLength) { - throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶉暱搴︿笉鑳借秴杩�" + maxLength}); + throw new PLException("500", new String[]{"涓氬姟绫诲瀷鍚嶉暱搴︿笉鑳借秴杩�" + maxLength}); } if (platformClientUtil.getBtmService().checkRowIsExists(btmName)) { - throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶅凡缁忓瓨鍦�"}); + throw new PLException("500", new String[]{"涓氬姟绫诲瀷鍚嶅凡缁忓瓨鍦�"}); } } @@ -783,72 +926,76 @@ */ private void checkLifeCycle(OsBtmTypeDTO btmTypeDTO) throws PLException { if (Func.isBlank(btmTypeDTO.getLifeCycleId())) { - throw new PLException("500",new String[]{"鐢熷懡鍛ㄦ湡涓嶈兘涓虹┖"}); + throw new PLException("500", new String[]{"鐢熷懡鍛ㄦ湡涓嶈兘涓虹┖"}); } } /** * 閫夋嫨涓�绾х増鏈細蹇呴』閫夋嫨鎴栨墜宸ヨ緭鍏ョ増鏈彿瑙勫垯; 閫夋嫨浜岀骇鐗堟湰锛氬繀椤婚�夋嫨鎴栨墜宸ヨ緭鍏ョ増鏈彿瑙勫垯, (鐗堟鍙峰凡缁忛粯璁ら�夋嫨). + * * @return */ private void checkVersionInfo(OsBtmTypeDTO dto) throws PLException { - //闇�瑕佹墜鍔ㄨ緭鍏ョ増鏈椂revisionRuleName涓嶈兘涓虹┖ - if (dto.isInputRevisionFlag() && Func.isBlank(dto.getRevisionRuleName())) { - throw new PLException("500",new String[]{"鐗堟湰鍙疯鍒欎笉鑳戒负绌�"}); + //闇�瑕佹墜鍔ㄨ緭鍏ョ増鏈椂revisionRuleId涓嶈兘涓虹┖ + if (dto.getRevLevel() == 1 || dto.getRevLevel() == 2) { + if (Func.isBlank(dto.getRevisionRuleId()) && !dto.isInputRevisionFlag()) { + throw new PLException("500", new String[]{"鐗堟湰鍙疯鍒欎笉鑳戒负绌�"}); + } } } /** * 鐗堟湰鏈哄埗淇敼: 浠呭厑璁哥被鍨嬩粠"涓嶅彲淇"鍙樻洿鑷�"涓�绾х増鏈鐞嗘満鍒�","浜岀骇鐗堟湰绠$悊鏈哄埗杩涜璋冩暣"; "涓�绾х増鏈鐞嗘満鍒�"鍙樻洿鑷�"浜岀骇鐗堟湰绠$悊鏈哄埗"; * 涓ょ鏂瑰紡. + * * @param dbBizType 褰撳墠淇敼鍓嶇殑涓氬姟绫诲瀷锛堝簱涓瓨鍌ㄧ殑锛� - * @param dto 褰撳墠淇敼涓氬姟绫诲瀷 + * @param dto 褰撳墠淇敼涓氬姟绫诲瀷 * @throws PLException */ - private void checkRevLevel(BizType dbBizType,OsBtmTypeDTO dto) throws PLException { - if (dbBizType.revLevel == 1 && dto.getRevLevel()==0) { - throw new PLException("500",new String[]{"鐗堟湰鍙樻洿閿欒锛氫笉鑳戒粠涓�绾у彉涓轰笉鍙慨璁�"}); + private void checkRevLevel(BizType dbBizType, OsBtmTypeDTO dto) throws PLException { + if (dbBizType.revLevel == 1 && dto.getRevLevel() == 0) { + throw new PLException("500", new String[]{"鐗堟湰鍙樻洿閿欒锛氫笉鑳戒粠涓�绾у彉涓轰笉鍙慨璁�"}); } - if (dbBizType.revLevel == 2 && (dto.getRevLevel() == 1 || dto.getRevLevel() == 0)) { - throw new PLException("500",new String[]{"鐗堟湰鍙樻洿閿欒锛氫笉鑳戒粠浜岀骇鍙樹负涓�绾ф垨涓嶅彲淇"}); + throw new PLException("500", new String[]{"鐗堟湰鍙樻洿閿欒锛氫笉鑳戒粠浜岀骇鍙樹负涓�绾ф垨涓嶅彲淇"}); } } /** * 淇敼涓氬姟绫诲瀷 + * * @param btmTypeDTO * @return * @throws PLException */ @Override public boolean updateBtmType(OsBtmTypeDTO btmTypeDTO) throws PLException { - VciBaseUtil.alertNotNull(btmTypeDTO,"淇敼鐨勪笟鍔$被鍨嬪璞�"); + VciBaseUtil.alertNotNull(btmTypeDTO, "淇敼鐨勪笟鍔$被鍨嬪璞�"); //妫�鏌ョ敓鍛藉懆鏈熸槸鍚﹀悎瑙� checkLifeCycle(btmTypeDTO); //鏌ヨ鏁版嵁搴撲腑鐨勪笟鍔$被鍨� String id = btmTypeDTO.getId(); BizType dbBizType = platformClientUtil.getBtmService().getBizTypeByName(id); - if(Func.isEmpty(dbBizType) || Func.isBlank(dbBizType.oid)){ - throw new PLException("500",new String[]{"褰撳墠淇敼鐨勪笟鍔$被鍨嬩笉瀛樺湪锛�"}); + if (Func.isEmpty(dbBizType) || Func.isBlank(dbBizType.oid)) { + throw new PLException("500", new String[]{"褰撳墠淇敼鐨勪笟鍔$被鍨嬩笉瀛樺湪锛�"}); } //妫�鏌ョ増鏈鍒欎慨鏀规槸鍚﹀悎瑙� - checkRevLevel(dbBizType,btmTypeDTO); + checkRevLevel(dbBizType, btmTypeDTO); checkVersionInfo(btmTypeDTO); //澶勭悊涓氬姟绫诲瀷涓嬬殑灞炴�� - List<String> lastAttrList = new ArrayList<>(Arrays.asList(btmTypeDTO.getApNameArray())); + List<String> lastAttrList = new ArrayList<>(Arrays.asList(btmTypeDTO.getApNameArray().split(","))); //涓嶈兘绉婚櫎鐨勫睘鎬� String[] unRemovableFields = null; List<String> unRemovableFields_ = null; //闇�瑕佺Щ闄ょ殑灞炴�� - List<String> removableFields = null; + List<String> removableFields = new ArrayList<>(); //淇敼鍓嶄笟鍔$被鍨嬪湪鏁版嵁搴撲腑宸插瓨鍦ㄧ殑鎵�鏈夊睘鎬� - String[] apNameArray = btmTypeDTO.getApNameArray(); + List<String> apNameArray = Func.toStrList(btmTypeDTO.getApNameArray()); Set<String> dbApNameArray = Arrays.stream(dbBizType.apNameArray) .collect(Collectors.toSet()); //杩囨护鍑洪渶瑕佺Щ闄ょ殑灞炴�� - removableFields = Arrays.stream(apNameArray) - .filter(ap -> !dbApNameArray.contains(ap)) // 杩囨护涓嶅湪 dbApSet 涓殑鍏冪礌 + removableFields = dbApNameArray.stream() + .filter(ap -> !apNameArray.contains(ap)) // 杩囨护涓嶅湪 dbApSet 涓殑鍏冪礌 .collect(Collectors.toList()); // 褰撲笟鍔$被鍨嬭〃涓煇灞炴�у凡缁忔湁鍊�, 涓嶅垹闄よ灞炴��, 灏嗗凡缁忕Щ闄ょ殑灞炴�ф坊鍔犲洖鏉� unRemovableFields = platformClientUtil.getBtmService().getUnRemovableFields(id, removableFields.toArray(new String[0])); @@ -857,7 +1004,9 @@ if (this.hasInstanceByBtmName(id)) { //涓氬姟绫诲瀷宸叉湁瀹炰緥, 鍙兘鍒犻櫎娌℃湁鏁版嵁鐨勫垪 if (unRemovableFields != null && unRemovableFields.length > 0) { - unRemovableFields_ = Arrays.asList(unRemovableFields); + //绉婚櫎浜嗕笉鍙慨鏀圭殑灞炴�х洿鎺ユ姤閿欙紝灏变笉寰�涓嬫墽琛屼簡 + throw new VciBaseException("涓氬姟绫诲瀷宸叉湁瀹炰緥, 鍙兘鍒犻櫎娌℃湁鏁版嵁鐨勫垪锛屾湁鏁版嵁鐨勫垪鍚嶄负锛�" + removableFields); + /*unRemovableFields_ = Arrays.asList(unRemovableFields); for (int i = 0; i < removableFields.size(); i++) { String abName = removableFields.get(i); if (unRemovableFields_.contains(abName)) { @@ -865,7 +1014,7 @@ lastAttrList.add(abName); } } - } + }*/ } } } @@ -876,28 +1025,29 @@ /** * 鍒犻櫎涓氬姟绫诲瀷 + * * @param btmTypeDTO * @return * @throws PLException */ @Override public boolean deleteBtmType(OsBtmTypeDTO btmTypeDTO) throws PLException { - VciBaseUtil.alertNotNull(btmTypeDTO,"鍒犻櫎鐨勪笟鍔$被鍨�"); + VciBaseUtil.alertNotNull(btmTypeDTO, "鍒犻櫎鐨勪笟鍔$被鍨�"); String btmName = btmTypeDTO.getId(); //鍙兘鍒犻櫎鍙跺瓙鑺傜偣 - if(Func.isNotBlank(btmTypeDTO.getfName())){ - throw new PLException("500",new String[]{"鍙兘鍒犻櫎鍙跺瓙鑺傜偣"}); + if (Func.isNotBlank(btmTypeDTO.getfName())) { + throw new PLException("500", new String[]{"鍙兘鍒犻櫎鍙跺瓙鑺傜偣"}); } // 涓氬姟绫诲瀷琚摼鎺ョ被鍨嬩娇鐢�, 涓嶈兘鍒犻櫎 List<String> usedNameList = linkTypeService.getUsedBtmLinkList(btmName); if (usedNameList != null && usedNameList.size() > 0) { - throw new PLException("500",new String[]{"璇ョ被鍨嬪凡琚摼鎺ョ被鍨嬩娇鐢紝绂佹鍒犻櫎"}); + throw new PLException("500", new String[]{"璇ョ被鍨嬪凡琚摼鎺ョ被鍨嬩娇鐢紝绂佹鍒犻櫎"}); } // 涓氬姟绫诲瀷宸茬粡鐢熸垚浜嗕笟鍔″璞�, 涓嶈兘鍒犻櫎 if (hasInstanceByBtmName(btmName)) { - throw new PLException("500",new String[]{"璇ョ被鍨嬪凡鏈夊疄渚嬶紝绂佹鍒犻櫎"}); + throw new PLException("500", new String[]{"璇ョ被鍨嬪凡鏈夊疄渚嬶紝绂佹鍒犻櫎"}); } - + BizType bizType = new BizType(); bizType.ts = btmTypeDTO.getTs().getTime(); bizType.oid = btmTypeDTO.getOid(); @@ -907,6 +1057,7 @@ /** * 涓�鑷存�ф鏌� + * * @return * @throws PLException */ @@ -914,9 +1065,9 @@ public BaseResult checkBtmConsistency() throws PLException { String[] result = platformClientUtil.getBtmService().btmConsistencyCheck(); Map<String, String> dbCheckMap = new HashMap<String, String>(); - for(int i = 0; i < result.length; i++){ + for (int i = 0; i < result.length; i++) { String info = result[i]; - if(info.equals("")){ + if (info.equals("")) { continue; } String[] infos = info.split("/DML"); @@ -924,9 +1075,9 @@ String dml = infos[1]; dbCheckMap.put(typeName, dml); } - if(dbCheckMap.size() < 1){ + if (dbCheckMap.size() < 1) { return BaseResult.successMsg("鏁版嵁搴撲腑鐨勮〃缁撴瀯涓庣被鍨嬩竴鑷�,鏃犻渶淇!!"); - }else{ + } else { //闇�瑕佷慨澶嶆椂灏遍渶瑕佺晫闈㈠敜璧峰璇濇杩涜澶勭悊 List<Map> list = new ArrayList<>(); list.add(dbCheckMap); @@ -938,26 +1089,29 @@ /** * 涓�鑷存�ф鏌ヤ慨澶嶅姛鑳� + * * @param repairData * @return */ @Override public BaseResult executeRepair(String repairData) throws Exception { - Map<String, String> dbCheckMap = new ObjectMapper().readValue(repairData, new TypeReference<Map<String,String>>(){}); + Map<String, String> dbCheckMap = new ObjectMapper().readValue(repairData, new TypeReference<Map<String, String>>() { + }); List<String> list = this.getRepairDML(dbCheckMap); - if(list.size() < 1){ + if (list.size() < 1) { return BaseResult.success(); } try { String[] result = platformClientUtil.getBtmService().executeRepair(list.toArray(new String[0])); return BaseResult.success(result); - }catch (PLException e){ - return BaseResult.fail("涓氬姟绫诲瀷淇澶辫触锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e)); + } catch (PLException e) { + return BaseResult.fail("涓氬姟绫诲瀷淇澶辫触锛屽師鍥狅細" + VciBaseUtil.getExceptionMessage(e)); } } /** * 鍒涘缓瑙嗗浘 + * * @return * @throws PLException */ @@ -968,6 +1122,7 @@ /** * 鍒犻櫎鏁版嵁鐣岄潰鐨勬煡璇� + * * @return 涓氬姟绫诲瀷锛岄摼鎺ョ被鍨� */ @Override @@ -976,11 +1131,11 @@ List<String> allBtmName = this.getAllBtmName(); //鑾峰彇閾炬帴绫诲瀷鍚嶇О闆嗗悎 List<String> allLinkType = linkTypeService.getAllLtName(); - Map<String,List> map = new HashMap<>(); - map.put("btmType",allBtmName); - map.put("linkType",allLinkType); - map.put("table",tableList); - map.put("workFlow",workFlowTableList); + Map<String, List> map = new HashMap<>(); + map.put("btmType", allBtmName); + map.put("linkType", allLinkType); + map.put("table", tableList); + map.put("workFlow", workFlowTableList); List<Map> list = new ArrayList<>(); list.add(map); return BaseResult.dataList(list); @@ -988,24 +1143,25 @@ /** * 鍒犻櫎鏁版嵁 - * @param btmNames 涓氬姟绫诲瀷鍚� + * + * @param btmNames 涓氬姟绫诲瀷鍚� * @param linkNames 閾炬帴绫诲瀷鍚� * @return * @throws PLException */ @Override - public List<Map> truncateTable(String[] btmNames,String[] linkNames) throws PLException { + public List<Map> truncateTable(String[] btmNames, String[] linkNames) throws PLException { List<Map> returnMapList = new ArrayList<>(); Map<String, List<String>> map = new HashMap<>(); - map.put("btmSuccess",new ArrayList<>()); - map.put("btmFail",new ArrayList<>()); - map.put("linkSuccess",new ArrayList<>()); - map.put("linkFail",new ArrayList<>()); - if(Func.isNotEmpty(btmNames)){ - for(int i = 0; i < btmNames.length; i++){ + map.put("btmSuccess", new ArrayList<>()); + map.put("btmFail", new ArrayList<>()); + map.put("linkSuccess", new ArrayList<>()); + map.put("linkFail", new ArrayList<>()); + if (Func.isNotEmpty(btmNames)) { + for (int i = 0; i < btmNames.length; i++) { String btName = btmNames[i]; try { - if(platformClientUtil.getBtmService().truncateTable(btName)){ + if (platformClientUtil.getBtmService().truncateTable(btName)) { //淇敼鎴愬姛璁板綍涓嬫垚鍔熺殑涓氬姟绫诲瀷鍚� map.get("btmSuccess").add(btName); } @@ -1017,12 +1173,12 @@ } } } - if(Func.isNotEmpty(linkNames)){ + if (Func.isNotEmpty(linkNames)) { //truncate閾炬帴绫诲瀷鏁版嵁 - for(int i = 0; i < linkNames.length; i++){ + for (int i = 0; i < linkNames.length; i++) { String ltName = linkNames[i]; try { - if(platformClientUtil.getLinkTypeService().truncateTable(ltName)){ + if (platformClientUtil.getLinkTypeService().truncateTable(ltName)) { map.get("linkSuccess").add(ltName); } } catch (PLException e1) { @@ -1038,6 +1194,7 @@ /** * 鍒犻櫎鍏ㄩ儴绫诲瀷 + * * @return * @throws PLException */ @@ -1045,7 +1202,7 @@ public BaseResult deleteAllType() throws PLException { DeleteType deleteType = new DeleteType(); //鑾峰彇寰呭垹闄ょ殑涓氬姟绫诲瀷 - List<BizType> delBtList = deleteType.getDelBtList(); + List<BizType> delBtList = deleteType.getDelBtList(); //鑾峰彇寰呭垹闄ょ殑閾炬帴绫诲瀷 List<LinkType> ltNames = deleteType.getDelLtList(); //鑾峰彇寰呭垹闄ょ殑灞炴�� @@ -1062,7 +1219,7 @@ platformClientUtil.getBtmService().deleteBtsAndTables(delBtList.toArray(new BizType[0])); } catch (PLException e) { e.printStackTrace(); - String exceptionMessage = "娓呴櫎涓氬姟绫诲瀷鍜屽搴旇〃鏍兼椂鍑虹幇寮傚父锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e); + String exceptionMessage = "娓呴櫎涓氬姟绫诲瀷鍜屽搴旇〃鏍兼椂鍑虹幇寮傚父锛屽師鍥狅細" + VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); return BaseResult.fail(exceptionMessage); } @@ -1070,7 +1227,7 @@ ClientServiceProvider.getOMDService().getLinkTypeService().deleteLtsAndTables(ltNames.toArray(new LinkType[0])); } catch (PLException e) { e.printStackTrace(); - String exceptionMessage = "娓呴櫎閾炬帴绫诲瀷鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e); + String exceptionMessage = "娓呴櫎閾炬帴绫诲瀷鏃跺嚭鐜板紓甯革紝鍘熷洜锛�" + VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); return BaseResult.fail(exceptionMessage); } @@ -1079,7 +1236,7 @@ platformClientUtil.getAttributeService().deleteAttributeDefs(abs); } catch (PLException e) { e.printStackTrace(); - String exceptionMessage = "娓呴櫎灞炴�ф睜灞炴�ф椂鍑虹幇寮傚父锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e); + String exceptionMessage = "娓呴櫎灞炴�ф睜灞炴�ф椂鍑虹幇寮傚父锛屽師鍥狅細" + VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); return BaseResult.fail(exceptionMessage); } @@ -1087,7 +1244,7 @@ platformClientUtil.getEnumService().deleteEnumTypes(delEnumList.toArray(new EnumType[0])); } catch (PLException e) { e.printStackTrace(); - String exceptionMessage = "娓呴櫎鏋氫妇绫诲瀷鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e); + String exceptionMessage = "娓呴櫎鏋氫妇绫诲瀷鏃跺嚭鐜板紓甯革紝鍘熷洜锛�" + VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); return BaseResult.fail(exceptionMessage); } @@ -1095,7 +1252,7 @@ platformClientUtil.getLifeCycleService().deleteLifeCycles(delLCList.toArray(new LifeCycle[0])); } catch (PLException e) { e.printStackTrace(); - String exceptionMessage = "娓呴櫎鐢熷懡鍛ㄦ湡鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e); + String exceptionMessage = "娓呴櫎鐢熷懡鍛ㄦ湡鏃跺嚭鐜板紓甯革紝鍘熷洜锛�" + VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); return BaseResult.fail(exceptionMessage); } @@ -1103,7 +1260,7 @@ platformClientUtil.getStatePoolService().deleteStatePools(delStateList.toArray(new StatePool[0])); } catch (PLException e) { e.printStackTrace(); - String exceptionMessage = "娓呴櫎鐘舵�佹睜鐘舵�佹椂鍑虹幇寮傚父锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e); + String exceptionMessage = "娓呴櫎鐘舵�佹睜鐘舵�佹椂鍑虹幇寮傚父锛屽師鍥狅細" + VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); return BaseResult.fail(exceptionMessage); } @@ -1111,7 +1268,7 @@ platformClientUtil.getVersionService().deleteVersionRules(delVRList.toArray(new VersionRule[0])); } catch (PLException e) { e.printStackTrace(); - String exceptionMessage = "娓呴櫎鐗堟湰瑙勫垯鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e); + String exceptionMessage = "娓呴櫎鐗堟湰瑙勫垯鏃跺嚭鐜板紓甯革紝鍘熷洜锛�" + VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); return BaseResult.fail(exceptionMessage); } @@ -1119,45 +1276,314 @@ } /** - * 鏍规嵁涓氬姟绫诲瀷鍚嶇О鍜屽叾涓嬬殑灞炴�у悕绉拌幏鍙栦篃鏈夌殑绱㈠紩 - * @param btmName - * @param attrName + * 鏍规嵁涓氬姟绫诲瀷鍚嶇О鍜屽叾涓嬬殑灞炴�у悕绉拌幏鍙栧凡鏈夌殑绱㈠紩 + * + * @param conditionMap 鏍规嵁鏌ヨ鏉′欢浼犲弬: typename:涓氬姟绫诲瀷鍚�; * @return */ @Override - public List<String> getIndexByBtmAndAttrName(String btmName, String attrName) { - return null; + public List<IndexObject> getIndexByCondition(Map<String, String> conditionMap) throws PLException { + if (Func.isEmpty(conditionMap)) { + return new ArrayList<>(); + } + List<IndexObject> indexObjects = new ArrayList<>(); + TypeIndexDef[] typenames = ClientServiceProvider.getOMDService().getTypeIndexService().getBTIndexDefs(conditionMap.get("typename")); + + for (int i = 0; i < typenames.length; i++) { + TypeIndexDef typename = typenames[i]; + IndexObject indexObject = new IndexObject(); + indexObject.setOid(typename.oid); + indexObject.setDescription(typename.description); + indexObject.setCreateTime(Func.format(new Date(typename.createTime), DateUtil.PATTERN_DATE)); + indexObject.setIndexName(typename.name); + indexObject.setTypeName(typename.typeName); + indexObject.setAttrNames(typename.attributes); + indexObjects.add(indexObject); + } + return indexObjects; } /** * 鏍规嵁涓氬姟绫诲瀷鍚嶇О鍜屽叾涓嬬殑灞炴�у悕绉板垹闄ょ储寮� + * * @param btmName - * @param attrName + * @param indexName * @return */ @Override - public boolean delIndexByBtmAndAttrName(String btmName, String attrName) { - return false; + public boolean delIndex(String btmName, String indexName) throws PLException { + VciBaseUtil.alertNotNull(btmName, "涓氬姟绫诲瀷鍚�", indexName, "绱㈠紩鍚�"); + TypeIndexDef[] typeIndexDef= ClientServiceProvider.getOMDService().getTypeIndexService().getBTIndexDefs(btmName); + if( typeIndexDef != null && typeIndexDef.length > 0 ){ + String[] indexAttr = {indexName}; + + boolean alterFlag = platformClientUtil.getBtmService().dropIndex(btmName, indexAttr); + + if (!alterFlag) { + return false; + } + for (int i = 0; i < typeIndexDef.length; i++) { + if(!typeIndexDef[i].name.equals(indexName)) { + continue; + } + String oid = typeIndexDef[i].oid; + ClientServiceProvider.getOMDService().getTypeIndexService().delIndexDef(oid); + } + } + return true; } /** * 缁欎笟鍔$被鍨嬩笅鐨勬寚瀹氬睘鎬ф柊澧炵储寮� - * @param addMap 濡傦細(btmName:part attrName:name indexName: PARTNAMEINDEX) + * + * @param indexObjectList * @return */ @Override - public boolean addIndex(Map<String, String> addMap) { - return false; + public boolean addIndex(List<IndexObject> indexObjectList) throws PLException { + VciBaseUtil.alertNotNull(indexObjectList, "鏂板鐨勭储寮曚俊鎭�"); + String btmName = indexObjectList.get(0).getTypeName(); + String indexNames = indexObjectList.stream().map(IndexObject::getIndexName).collect(Collectors.joining(",")); + String[] oldindexAttr = {indexNames}; +// BusinessObject bo; +// List<BusinessObject> boList = new ArrayList<>(); +// //鍏堟煡璇㈠綋鍓嶆坊鍔犵储寮曟槸鍚﹀凡缁忓瓨鍦紝濡傛灉瀛樺湪灏卞厛鍒犻櫎鍐嶆柊澧炲疄鐜版浛鎹㈡搷浣� +// Map<String, String> conditionMap = new HashMap<>(); +// conditionMap.put("typename", btmName); +// //鍏堣繖鏍峰鐞嗭紝鍓嶇鐜板湪鍙仛浜嗗崟娆′繚瀛橈紝鎵�浠ヤ笉鐢╥n +// conditionMap.put("indexname", indexNames); + TypeIndexDef[] typeIndexDefs = platformClientUtil.getTypeIndexService().getBTIndexDefs(btmName); + + if(typeIndexDefs!=null && typeIndexDefs.length>0){ + boolean hasIndex = false; + for(int i = 0; i < typeIndexDefs.length; i ++){ + if(!typeIndexDefs[i].name.equals(indexNames)) { + continue; + } + String oid = typeIndexDefs[i].oid; + platformClientUtil.getTypeIndexService().delIndexDef(oid); + hasIndex = true; + } + //绱㈠紩涓嶅瓨鍦ㄦ椂鍒犻櫎灏变細鎶ラ敊绱㈠紩涓嶅瓨鍦紝鎵�浠ヨ繖閲屾湁绱㈠紩鎵嶅幓鍒犻櫎 + if(hasIndex) { + platformClientUtil.getBtmService().dropIndex(btmName, oldindexAttr); + } + } + StringBuilder sb = new StringBuilder(); + List<TypeIndexDef> saveDefs = new ArrayList<>(); + for(int i = 0; i < indexObjectList.size(); i ++){ + TypeIndexDef saveDef = new TypeIndexDef(); + saveDef.typeName = indexObjectList.get(i).getTypeName(); + saveDef.name = indexObjectList.get(i).getIndexName(); + saveDef.description = indexObjectList.get(i).getDescription(); + saveDef.attributes = indexObjectList.get(i).getAttrNames(); + sb.append(indexObjectList.get(i).getAttrNames()); + if(i<indexObjectList.size()-1){ + sb.append(","); + } + saveDefs.add(saveDef); + } + String[] indexAttr = {indexObjectList.get(0).getIndexName(),sb.toString()}; + boolean alterFlag = platformClientUtil.getBtmService().addIndex(btmName, indexAttr); + if(!alterFlag) { + return false; + } + ClientServiceProvider.getOMDService().getTypeIndexService().saveIndexDefs(saveDefs.toArray(new TypeIndexDef[saveDefs.size()])); + return true; + } + + /** + * 瀵煎嚭涓氬姟绫诲瀷 + * oid 涓氬姟绫诲瀷鍚嶇О + * + * @return 鍒涘缓缁撴灉 + */ + @Override + public void expData(String names, HttpServletResponse response) throws PLException, IOException { + String defaultTempFolder = LocalFileUtil.getDefaultTempFolder(); + //鍐檈xcel + String excelPath = defaultTempFolder + File.separator + "btm.xls"; + //璁剧疆鍒楀悕 + List<String> columns = new ArrayList<>( + Arrays.asList("绫诲瀷鍚嶇О", "鏍囩", "缁ф壙鑷�", "瀹炵幇绫�", "鎻忚堪", "鐗堟湰瑙勫垯", "鐗堟湰鍙疯鍒�", + "鏄惁鎵嬪伐杈撳叆", "鍒嗛殧绗�", "鐗堟鍙疯鍒�","鍥炬爣", "鐢熷懡鍛ㄦ湡", "澶囬�夌敓鍛藉懆鏈熷垪琛�", "灞炴�у垪琛�") + ); + try { + new File(excelPath).createNewFile(); + //璁剧疆鍒� + List<WriteExcelData> excelDataList = new ArrayList<>(); + //璁剧疆鍒楀ご + for (int index = 0; index < columns.size(); index++) { + excelDataList.add(new WriteExcelData(0, index, columns.get(index))); + } + HashSet<String> attributes = new HashSet<>(); + int i = 0; + for (String name : names.split(",")) { + BizType bizType = platformClientUtil.getBtmService().getBizTypeByName(name); + excelDataList.add(new WriteExcelData(i + 1, 0, bizType.name)); + excelDataList.add(new WriteExcelData(i + 1, 1, bizType.label)); + excelDataList.add(new WriteExcelData(i + 1, 2, bizType.fName)); + excelDataList.add(new WriteExcelData(i + 1, 3, bizType.implClass)); + excelDataList.add(new WriteExcelData(i + 1, 4, bizType.description)); + excelDataList.add(new WriteExcelData(i + 1, 5, bizType.revLevel)); + excelDataList.add(new WriteExcelData(i + 1, 6, bizType.revRuleName)); + excelDataList.add(new WriteExcelData(i + 1, 7, bizType.revInput)); + excelDataList.add(new WriteExcelData(i + 1, 8, bizType.delimiter)); + excelDataList.add(new WriteExcelData(i + 1, 9, bizType.verRuleName)); + excelDataList.add(new WriteExcelData(i + 1, 10, bizType.imageName)); + excelDataList.add(new WriteExcelData(i + 1, 11, bizType.lifeCycle)); + excelDataList.add(new WriteExcelData(i + 1, 12, String.join(",", bizType.lifeCycles))); + excelDataList.add(new WriteExcelData(i + 1, 13, String.join(",", bizType.apNameArray))); + attributes.addAll(Arrays.asList(bizType.apNameArray)); + i++; + } + WriteExcelOption excelOption = new WriteExcelOption(excelDataList); + ExcelUtil.writeDataToFile(excelPath, excelOption); + //瀵煎嚭灞炴�� + String attrPath = attributeService.exportAttributes("btmattr", + attributes.stream().collect(Collectors.joining(",")), true); + //绉诲姩灞炴�у埌閾炬帴绫诲瀷鏂囦欢澶归噷闈㈠幓 + FileUtil.move(new File(attrPath), new File(defaultTempFolder), true); + FileUtil.del(attrPath.substring(0, attrPath.lastIndexOf("\\"))); + } catch (IOException e) { + throw new RuntimeException(e); + } + File zip = ZipUtil.zip(defaultTempFolder); + FileUtil.del(defaultTempFolder + File.separator); + ControllerUtil.writeFileToResponse(response, zip.getAbsoluteFile()); + } + + /** + * 瀵煎叆涓氬姟绫诲瀷 + * + * @param file 涓婁紶鐨勬枃浠� + * @return + */ + @Override + public BaseResult impData(MultipartFile file) throws Exception { + String defaultTempFolder = LocalFileUtil.getDefaultTempFolder(); + String fileName = defaultTempFolder + File.separator + LocalFileUtil.getFileNameForIE(file.getOriginalFilename()); + file.transferTo(new File(fileName)); + if (file == null) { + return BaseResult.fail(FrameWorkLangCodeConstant.IMPORT_FAIL, new String[]{"鏃犲鍏ョ殑鏂囦欢"}); + } + if (!fileName.endsWith(".zip") || !fileName.endsWith(".rar")) { + throw new VciBaseException("浠呰兘涓婁紶zip鍘嬬缉鏂囦欢锛岃閲嶆柊涓婁紶锛�"); + } + File unzip = ZipUtil.unzip(fileName); + File btmExcel = new File(unzip.getAbsolutePath() + File.separator + "btm.xls"); + File attrExcel = new File(unzip.getAbsolutePath() + File.separator + "btmattr.xls"); + if (!attrExcel.exists()) { + //澧炲姞瑙e帇鐨勮矾寰勶紝鐪嬫枃浠惰繕鍦ㄦ病鏈� + attrExcel = new File(unzip.getAbsolutePath() + File.separator + unzip.getName() + File.separator + "btmattr.xls"); + if (!attrExcel.exists()) { + return BaseResult.fail(FrameWorkLangCodeConstant.IMPORT_FAIL, new String[]{"娌℃湁瀵煎叆鐨勫睘鎬ф枃浠躲�傚鍏ョ粓姝紒"}); + } + } + //TODO锛氬鍏ュ睘鎬э紝浣嗘槸杩欎釜閫昏緫瀹為檯涓婂瓨鍦ㄤ竴浜涢棶棰橈紝瀵煎叆鐨勫睘鎬у彧鏄笟鍔$被鍨嬬殑灞炴�т笉搴旇鍘荤粰灞炴�ф睜瀵煎叆锛屽彲鑳芥槸鎯崇殑灞炴�т笉瀛樺湪鐨勫氨鏂板涓�娆� + BaseResult baseResult = attributeService.importAttributes(attrExcel, true); + if (!baseResult.isSuccess()) { + //鍒犻櫎涓婁紶鐨勬枃浠跺す + FileUtil.del(defaultTempFolder + File.separator); + return baseResult; + } + //鍏ヤ笟鍔$被鍨� + if (!btmExcel.exists()) { + //澧炲姞瑙e帇鐨勮矾寰勶紝鐪嬫枃浠惰繕鍦ㄦ病鏈� + btmExcel = new File(unzip.getAbsolutePath() + File.separator + unzip.getName() + File.separator + "btm.xls"); + if (!btmExcel.exists()) { + //鍒犻櫎涓婁紶鐨勬枃浠跺す + FileUtil.del(defaultTempFolder + File.separator); + return BaseResult.fail(FrameWorkLangCodeConstant.IMPORT_FAIL, new String[]{"娌℃湁瀵煎叆鐨勯摼鎺ユ枃浠躲�傚鍏ョ粓姝紒"}); + } + } + try { + //1銆佽鍙杄xcel涓殑鏁版嵁锛岀粍鎴愬璞� + ReadExcelOption excelOption = new ReadExcelOption(); + List<OsBtmTypePO> poList = ExcelUtil.readDataObjectFromExcel(btmExcel, OsBtmTypePO.class, excelOption, (value, po, fieldName) -> { + }); + //鍘婚櫎閮芥槸绌虹殑鎯呭喌 + if (CollectionUtils.isEmpty(poList)) { + return BaseResult.fail(ExcelLangCodeConstant.IMPORT_CONTENT_NULL, new String[]{}); + } + //褰撳墠excel涓槸鍚﹂噸澶嶇敤鐨勫垽閲峂ap:锛坘ey锛氬垽閲嶅睘鎬э紝value锛氳鍙凤級 + Map<String, String> excelReapeat = new HashMap<>(); + int maxLength = platformClientUtil.getLinkTypeService().getLTNameMaxLength(); + + //鍒ゆ柇蹇呭~灞炴�ф槸鍚︿负绌猴紝鐢ㄦ埛鏄惁宸插瓨鍦紝浠ュ強閮ㄩ棬鏄惁濉敊绛夋牎楠岄�昏緫 + poList.stream().forEach(osBtmTypePO -> { + if (Func.isBlank(osBtmTypePO.getName())) {//灞炴�у悕鍒ょ┖ + throw new VciBaseException("绗��" + osBtmTypePO.getRowIndex() + "銆戣锛宯ame"); + } else if (osBtmTypePO.getName().length() > maxLength) { + throw new VciBaseException("绗��" + osBtmTypePO.getRowIndex() + "銆戣锛屼笟鍔$被鍨嬪悕闀垮害涓嶈兘瓒呰繃" + maxLength); + } else if (!osBtmTypePO.getName().matches("^[A-Za-z]+$")) { + throw new VciBaseException("绗��" + osBtmTypePO.getRowIndex() + "銆戣锛屼笟鍔$被鍨嬪悕绉板彧鑳戒负鑻辨枃瀛楁瘝"); + } else if (osBtmTypePO.getName().length() > maxLength) { + throw new VciBaseException("绗��" + osBtmTypePO.getRowIndex() + "銆戣锛屼笟鍔$被鍨嬪悕闀垮害涓嶈兘瓒呰繃" + maxLength); + } else if (excelReapeat.containsKey(osBtmTypePO.getName())) {//涓氬姟绫诲瀷鍚嶅湪琛ㄦ牸涓垽閲� + throw new VciBaseException("绗��" + excelReapeat.get(osBtmTypePO.getName()) + "銆戣鍜岀銆�" + osBtmTypePO.getRowIndex() + "銆戣鏁版嵁锛屼笟鍔$被鍨嬪悕閲嶅"); + } else if (Func.isBlank(osBtmTypePO.getLifeCycle())) { + throw new VciBaseException("绗��" + osBtmTypePO.getRowIndex() + "銆戣锛岀敓鍛藉懆鏈熶笉鑳戒负绌�"); + } else if ("true".equalsIgnoreCase(osBtmTypePO.getRevInput()) && Func.isBlank(osBtmTypePO.getRevRuleName())) { + throw new VciBaseException("绗��" + osBtmTypePO.getRowIndex() + "銆戣锛岀増鏈彿瑙勫垯涓嶈兘涓虹┖"); + } + try { + BizType historyBtm = platformClientUtil.getBtmService().getBizTypeByName(osBtmTypePO.getName()); + //宸叉湁姝ゆ暟鎹繘琛屽垹闄よ鐩� + if (historyBtm != null && !historyBtm.name.equals("")) { + platformClientUtil.getBtmService().deleteBizType(historyBtm); + } + } catch (PLException e) { + throw new RuntimeException(e); + } + + //灞炴�у悕excel涓垽閲嶅鐞� + excelReapeat.put(osBtmTypePO.getName(), osBtmTypePO.getRowIndex()); + BizType bizType = new BizType(); + bizType.name = osBtmTypePO.getName(); + bizType.label = osBtmTypePO.getLabel(); + bizType.description = osBtmTypePO.getDescription(); + bizType.fName = osBtmTypePO.getFName(); + bizType.implClass = osBtmTypePO.getImplClass(); + bizType.revLevel = osBtmTypePO.getRevLevel(); + bizType.revRuleName = osBtmTypePO.getRevRuleName(); + bizType.revInput = Boolean.parseBoolean(osBtmTypePO.getRevInput().toLowerCase(Locale.ROOT)); + bizType.delimiter = osBtmTypePO.getDelimiter(); + bizType.verRuleName = osBtmTypePO.getVerRuleName(); + bizType.imageName = osBtmTypePO.getImageName(); + bizType.lifeCycle = osBtmTypePO.getLifeCycle(); + bizType.lifeCycles = osBtmTypePO.getLifeCycles().split(","); + bizType.apNameArray = osBtmTypePO.getApNameArray().split(","); + String userId = WebUtil.getCurrentUserId(); + bizType.modifier = userId; + bizType.creator = userId; + try { + platformClientUtil.getBtmService().addBizType(bizType); + } catch (PLException e) { + throw new RuntimeException(e); + } + }); + } catch (Exception e) { + if (logger.isErrorEnabled()) { + logger.error("璇诲彇excel鍐呭鏃舵垨淇濆瓨涓氬姟绫诲瀷淇℃伅鏃跺嚭鐜颁簡閿欒锛屽叿浣撳師鍥狅細", VciBaseUtil.getExceptionMessage(e)); + } + e.printStackTrace(); + return BaseResult.fail(VciBaseUtil.getExceptionMessage(e), new String[]{}, e); + } + //鍒犻櫎涓婁紶鐨勬枃浠跺す + FileUtil.del(defaultTempFolder + File.separator); + return BaseResult.success("涓氬姟绫诲瀷瀵煎叆鎴愬姛锛�"); } /** * 鑾峰彇闇�瑕佷慨澶嶇殑浼猻ql + * * @param dbCheckMap * @return */ private List<String> getRepairDML(Map<String, String> dbCheckMap) { List<String> list = new ArrayList<String>(); - for(Iterator<String> ite = dbCheckMap.keySet().iterator(); ite.hasNext();){ + for (Iterator<String> ite = dbCheckMap.keySet().iterator(); ite.hasNext(); ) { String type = ite.next(); String dml = dbCheckMap.get(type); list.add(type + "/DML" + dml); @@ -1175,32 +1601,33 @@ //boolean flag = DDLToolClient.getService().hasInstanceOralce(tableName); boolean flag = false; try { - flag = ClientServiceProvider.getOMDService().getBTMService().hasData(btmName); + flag = platformClientUtil.getBtmService().hasData(btmName); } catch (PLException e) { // TODO Auto-generated catch block e.printStackTrace(); String exceptionMessage = VciBaseUtil.getExceptionMessage(e); logger.error(exceptionMessage); - throw new PLException("500",new String[]{exceptionMessage}); + throw new PLException("500", new String[]{exceptionMessage}); } return flag; } - private List<Tree> getChildren(BizType[] bizTypes,BizType parentBIzType){ - List<Tree> trees= new ArrayList<>(); - for (BizType bizType : bizTypes) { - if(StringUtils.isBlank(bizType.fName)){ + private List<Tree> getChildren(List<OsBtmTypeVO> osBtmTypeVOS, OsBtmTypeVO parentBIzType) { + List<Tree> trees = new ArrayList<>(); + for (OsBtmTypeVO bizType : osBtmTypeVOS) { + if (StringUtils.isBlank(bizType.getfName())) { continue; } - if(bizType.fName.equals(parentBIzType.name)){ + if (bizType.getfName().equals(parentBIzType.getId())) { Tree tree = new Tree(); - tree.setOid(bizType.oid); - tree.setParentName(parentBIzType.fName); - tree.setParentId(parentBIzType.oid); + tree.setOid(bizType.getOid()); + tree.setParentName(parentBIzType.getfName()); + tree.setParentId(parentBIzType.getOid()); tree.setLeaf(true); - tree.setText(bizType.description); + tree.setIcon(bizType.getImageName()); + tree.setText(bizType.getDescription()); tree.setAttributes(WebUtil.objectToMapString(bizType)); - tree.setChildren(getChildren(bizTypes,bizType)); + tree.setChildren(getChildren(osBtmTypeVOS, bizType)); trees.add(tree); } } @@ -1210,12 +1637,12 @@ /** * 灏嗕笟鍔$被鍨嬫嫾鎺son * - * @param nodeVOList 瀵硅薄鑺傜偣鐨勪俊鎭� - * @param relationVOList 鍏崇郴鐨勪俊鎭� - * @param btmTypeVO 涓氬姟绫诲瀷鏄剧ず瀵硅薄 - * @param hasRefer 鍖呭惈鍙傜収 + * @param nodeVOList 瀵硅薄鑺傜偣鐨勪俊鎭� + * @param relationVOList 鍏崇郴鐨勪俊鎭� + * @param btmTypeVO 涓氬姟绫诲瀷鏄剧ず瀵硅薄 + * @param hasRefer 鍖呭惈鍙傜収 */ - private void splicingBtmType2Json(List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList, OsBtmTypeVO btmTypeVO,boolean hasRefer) { + private void splicingBtmType2Json(List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList, OsBtmTypeVO btmTypeVO, boolean hasRefer) { OsERNodeVO nodeVO = new OsERNodeVO(); nodeVO.setKey(btmTypeVO.getId() + " " + btmTypeVO.getName()); List<OsERNodePropertyVO> itemList = new ArrayList<>(); @@ -1223,16 +1650,23 @@ OsERNodePropertyVO nodePropertyVO = new OsERNodePropertyVO(); nodePropertyVO.setName(attribute.getId() + " " + attribute.getName()); nodePropertyVO.setKey("oid".equals(attribute.getId().toLowerCase())); - if(StringUtils.isNotBlank(attribute.getReferBtmTypeId())){ + if (StringUtils.isNotBlank(attribute.getReferBtmTypeId())) { //鍙傜収鐨勫睘鎬э紝璁剧疆涓洪粍鑹� nodePropertyVO.setColor("#FEDD32FF"); - }else{ + } else { nodePropertyVO.setColor("#000"); } itemList.add(nodePropertyVO); //鍒ゆ柇鍙傜収 - if(hasRefer) { - selectReferenceBtmType(attribute, btmTypeVO, nodeVOList, relationVOList); + if (hasRefer) { + try { + selectReferenceBtmType(attribute, btmTypeVO, nodeVOList, relationVOList); + } catch (PLException e) { + e.printStackTrace(); + String exceptionMessage = "鍒ゆ柇涓氬姟绫诲瀷鐨勫睘鎬ф槸涓嶆槸鍙傜収绫诲瀷鏃跺嚭鐜伴敊璇紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e); + logger.error(exceptionMessage); + throw new VciBaseException(exceptionMessage); + } } }); nodeVO.setItems(itemList); @@ -1242,13 +1676,13 @@ /** * 鍒ゆ柇涓氬姟绫诲瀷鐨勫睘鎬ф槸涓嶆槸鍙傜収绫诲瀷锛屽苟灏嗗弬鐓ф坊鍔犲埌ER鍥句腑 * - * @param attribute 涓氬姟绫诲瀷灞炴�� - * @param nodeVOList 鑺傜偣淇℃伅 - * @param btmTypeVO 涓氬姟绫诲瀷 + * @param attribute 涓氬姟绫诲瀷灞炴�� + * @param nodeVOList 鑺傜偣淇℃伅 + * @param btmTypeVO 涓氬姟绫诲瀷 * @param relationVOList 鍏崇郴淇℃伅 */ private void selectReferenceBtmType(OsBtmTypeAttributeVO attribute, OsBtmTypeVO btmTypeVO, - List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList) { + List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList) throws PLException { if (StringUtils.isNotBlank(attribute.getReferBtmTypeId())) { //鏄弬鐓х被鍨嬬殑 OsBtmTypeVO referenceBtmType = getBtmById(attribute.getReferBtmTypeId()); @@ -1258,14 +1692,14 @@ nodeVO.setKey(referenceBtmType.getId() + " " + referenceBtmType.getName()); List<OsERNodePropertyVO> items = new ArrayList<>(); - if(referenceBtmType.getId().equalsIgnoreCase(btmTypeVO.getId())){ + if (referenceBtmType.getId().equalsIgnoreCase(btmTypeVO.getId())) { //鍙傜収鑷繁鐨勫唴瀹� OsERRelationVO relationVO = new OsERRelationVO(); relationVO.setTo(referenceBtmType.getId() + " " + referenceBtmType.getName()); relationVO.setFrom(btmTypeVO.getId() + " " + btmTypeVO.getName()); relationVO.setToText("鑷弬鐓�"); relationVOList.add(relationVO); - }else { + } else { referenceBtmAttributes.forEach(attr -> { OsERNodePropertyVO nodePropertyVO = new OsERNodePropertyVO(); nodePropertyVO.setName(attr.getId() + " " + attr.getName()); @@ -1288,23 +1722,23 @@ /** * 鍔犺浇涓氬姟绫诲瀷鎵�鍏宠仈鐨勯摼鎺ョ被鍨� * - * @param nodeVOList 鑺傜偣淇℃伅 + * @param nodeVOList 鑺傜偣淇℃伅 * @param relationVOList 鍏崇郴鐨勪俊鎭� - * @param btmTypeVO 涓氬姟绫诲瀷 + * @param btmTypeVO 涓氬姟绫诲瀷 */ private void loadAllLinkTypeByBtmType(List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList, OsBtmTypeVO btmTypeVO) { Map<String, OsLinkTypeVO> linkTypeVOMap = linkTypeService.selectAllLinkMap(); Collection<OsLinkTypeVO> linkTypeVOS = linkTypeVOMap.values(); Set<OsLinkTypeVO> fromLinkTypeVOList = linkTypeVOS.stream().filter(link -> - Arrays.stream(link.getFromBtmType().split(",")).anyMatch(s->s.equalsIgnoreCase(btmTypeVO.getId())) + Arrays.stream(link.getFromBtmType().split(",")).anyMatch(s -> s.equalsIgnoreCase(btmTypeVO.getId())) ).collect(Collectors.toSet()); Set<OsLinkTypeVO> toLinkTypeList = linkTypeVOS.stream().filter(link -> - Arrays.stream(link.getToBtmType().split(",")).anyMatch(s->s.equalsIgnoreCase(btmTypeVO.getId()))).collect(Collectors.toSet()); + Arrays.stream(link.getToBtmType().split(",")).anyMatch(s -> s.equalsIgnoreCase(btmTypeVO.getId()))).collect(Collectors.toSet()); List<OsLinkTypeVO> linkTypeVOList = new ArrayList<>(); linkTypeVOList.addAll(fromLinkTypeVOList); linkTypeVOList.addAll(toLinkTypeList); if (!CollectionUtils.isEmpty(linkTypeVOList)) { - splicingLinkType2Json(nodeVOList, relationVOList,linkTypeVOList,btmTypeVO,false); + splicingLinkType2Json(nodeVOList, relationVOList, linkTypeVOList, btmTypeVO, false); } } @@ -1312,32 +1746,39 @@ /** * 灏嗛摼鎺ョ被鍨嬫嫾鎺ユ垚json * - * @param nodeVOList 鑺傜偣淇℃伅 - * @param relationVOList 鍏崇郴淇℃伅 - * @param linkTypeVOs 閾炬帴绫诲瀷 - * @param btmTypeVO 涓氬姟绫诲瀷鐨勬樉绀哄璞� - * @param used 鏄惁涓鸿浣跨敤 + * @param nodeVOList 鑺傜偣淇℃伅 + * @param relationVOList 鍏崇郴淇℃伅 + * @param linkTypeVOs 閾炬帴绫诲瀷 + * @param btmTypeVO 涓氬姟绫诲瀷鐨勬樉绀哄璞� + * @param used 鏄惁涓鸿浣跨敤 */ private void splicingLinkType2Json(List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList, - List<OsLinkTypeVO> linkTypeVOs,OsBtmTypeVO btmTypeVO,boolean used) { + List<OsLinkTypeVO> linkTypeVOs, OsBtmTypeVO btmTypeVO, boolean used) { linkTypeVOs.forEach(link -> { List<OsLinkTypeAttributeVO> attributeList = link.getAttributes(); - OsERNodeVO nodeVO= new OsERNodeVO(); + OsERNodeVO nodeVO = new OsERNodeVO(); nodeVO.setKey(link.getId() + " " + link.getName()); List<OsERNodePropertyVO> items = new ArrayList<>(); attributeList.forEach(attr -> { OsERNodePropertyVO nodePropertyVO = new OsERNodePropertyVO(); nodePropertyVO.setName(attr.getId() + " " + attr.getName()); nodePropertyVO.setKey("oid".equals(attr.getId().toLowerCase())); - if(StringUtils.isNotBlank(attr.getReferBtmTypeId())) { + if (StringUtils.isNotBlank(attr.getReferBtmTypeId())) { nodePropertyVO.setColor("#FEDD32FF"); - }else { + } else { nodePropertyVO.setColor("#1c446f"); } items.add(nodePropertyVO); //鍒ゆ柇鍙傜収 - if(!used) { - selectReferenceLinkType(attr, link, nodeVOList, relationVOList); + if (!used) { + try { + selectReferenceLinkType(attr, link, nodeVOList, relationVOList); + } catch (PLException e) { + e.printStackTrace(); + String exceptionMessage = "鏂摼鎺ョ被鍨嬬殑灞炴�ф槸涓嶆槸鍙傜収绫诲瀷鏃跺嚭鐜伴敊璇紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e); + logger.error(exceptionMessage); + throw new VciBaseException(exceptionMessage); + } } }); nodeVO.setItems(items); @@ -1348,26 +1789,26 @@ nodeVOList.add(nodeVO); - if(used){ + if (used) { relationVO.setText("琚紩鐢�"); } //濡傛灉褰撳墠鐨刦rom绔紝閭d箞灏辨樉绀簍o绔殑 //濡傛灉褰撳墠鐨勬槸to绔殑锛岄偅涔堝氨鏄剧ずfrom绔殑鍐呭 - if(Arrays.stream(link.getFromBtmType().split(",")).anyMatch(s->s.equalsIgnoreCase(btmTypeVO.getId()))){ + if (Arrays.stream(link.getFromBtmType().split(",")).anyMatch(s -> s.equalsIgnoreCase(btmTypeVO.getId()))) { //杩欎釜鏄痜rom绔� - if(!used) { - relationVO.setToText("from绔�"); - } + if (!used) { + relationVO.setToText("from绔�"); + } //鎵捐繖涓摼鎺ョ被鍨嬬殑to绔殑涓氬姟绫诲瀷 - link.getToBtmTypeVOS().stream().forEach(toBtm->{ - splicingBtmType2JsonForLink(nodeVOList,relationVOList,link,toBtm,true); - }); - }else{ - if(!used) { + link.getToBtmTypeVOS().stream().forEach(toBtm -> { + splicingBtmType2JsonForLink(nodeVOList, relationVOList, link, toBtm, true); + }); + } else { + if (!used) { relationVO.setToText("to绔�"); } - link.getFromBtmTypeVOS().stream().forEach(fromBtm->{ - splicingBtmType2JsonForLink(nodeVOList,relationVOList,link,fromBtm,false); + link.getFromBtmTypeVOS().stream().forEach(fromBtm -> { + splicingBtmType2JsonForLink(nodeVOList, relationVOList, link, fromBtm, false); }); } relationVOList.add(relationVO); @@ -1376,11 +1817,12 @@ /** * 閾炬帴绫诲瀷鍏抽敭鐨勪笟鍔$被鍨� - * @param nodeVOList 瀵硅薄鍒楄〃 + * + * @param nodeVOList 瀵硅薄鍒楄〃 * @param relationVOList 鍏宠仈鍏崇郴鍒楄〃 - * @param link 閾炬帴绫诲瀷 - * @param btmTypeVO 涓氬姟绫诲瀷 - * @param to 鏄惁涓簍o绔� + * @param link 閾炬帴绫诲瀷 + * @param btmTypeVO 涓氬姟绫诲瀷 + * @param to 鏄惁涓簍o绔� */ private void splicingBtmType2JsonForLink(List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList, OsLinkTypeVO link, OsBtmTypeVO btmTypeVO, boolean to) { OsERNodeVO nodeVO = new OsERNodeVO(); @@ -1398,7 +1840,7 @@ OsERRelationVO relationVO = new OsERRelationVO(); relationVO.setFrom(link.getId() + " " + link.getName()); relationVO.setTo(btmTypeVO.getId() + " " + btmTypeVO.getName()); - relationVO.setToText(to?"to绔�":"from绔�"); + relationVO.setToText(to ? "to绔�" : "from绔�"); relationVOList.add(relationVO); nodeVOList.add(nodeVO); } @@ -1406,12 +1848,12 @@ /** * 鍒ゆ柇閾炬帴绫诲瀷鐨勫睘鎬ф槸涓嶆槸鍙傜収绫诲瀷锛屽苟灏嗗弬鐓ф坊鍔犲埌ER鍥句腑 * - * @param attr 閾炬帴绫诲瀷鐨勫睘鎬� - * @param linkTypeVO 閾炬帴绫诲瀷鐨勫唴瀹� - * @param nodeVOList 鑺傜偣瀵硅薄 + * @param attr 閾炬帴绫诲瀷鐨勫睘鎬� + * @param linkTypeVO 閾炬帴绫诲瀷鐨勫唴瀹� + * @param nodeVOList 鑺傜偣瀵硅薄 * @param relationVOList 鍏崇郴瀵硅薄 */ - private void selectReferenceLinkType(OsLinkTypeAttributeVO attr, OsLinkTypeVO linkTypeVO,List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList) { + private void selectReferenceLinkType(OsLinkTypeAttributeVO attr, OsLinkTypeVO linkTypeVO, List<OsERNodeVO> nodeVOList, List<OsERRelationVO> relationVOList) throws PLException { if (StringUtils.isNotBlank(attr.getReferBtmTypeId())) { //鏄弬鐓х被鍨嬬殑 OsBtmTypeVO referenceBtmType = getBtmById(attr.getReferBtmTypeId()); @@ -1441,7 +1883,7 @@ /** * 灏佽鍒犻櫎鍏ㄩ儴绫诲瀷鐩稿叧鐨勬煡璇㈡柟娉曠殑鍐呴儴绫� */ - private class DeleteType{ + private class DeleteType { private List<String> exceptBts, exceptAbs, exceptEnums, exceptRev, exceptLCs, exceptStates; @@ -1452,20 +1894,21 @@ /** * 鑾峰彇闇�瑕佸垹闄ょ殑涓氬姟绫诲瀷 + * * @return */ public List<BizType> getDelBtList() throws PLException { List<BizType> list = new ArrayList<>(); BizType[] bts = platformClientUtil.getBtmService().getBizTypes(""); - for(BizType bt : bts){ + for (BizType bt : bts) { boolean exceptFlag = false; - for(String except : exceptBts){ - if(except.equalsIgnoreCase(bt.name)){ + for (String except : exceptBts) { + if (except.equalsIgnoreCase(bt.name)) { exceptFlag = true; break; } } - if(!exceptFlag){ + if (!exceptFlag) { list.add(bt); } } @@ -1474,6 +1917,7 @@ /** * 鑾峰彇闇�瑕佸垹闄ょ殑閾炬帴绫诲瀷 + * * @return */ public List<LinkType> getDelLtList() throws PLException { @@ -1483,6 +1927,7 @@ /** * 鑾峰彇寰呭垹闄ょ殑灞炴�� + * * @return */ public List<String> getDelAbList() { @@ -1495,26 +1940,26 @@ } //渚濇嵁淇濈暀鐨勭被鍨嬫瀯閫犱繚鐣欑殑灞炴�� exceptAbs = new ArrayList<String>(); - for(String except : exceptBts){ + for (String except : exceptBts) { String[] btmApNameArray = null; try { btmApNameArray = platformClientUtil.getBtmService().getAttributeNames(except); } catch (PLException e) { e.printStackTrace(); } - if(btmApNameArray != null){ - for(String abName : btmApNameArray){ - if(!exceptAbs.contains(abName)){ + if (btmApNameArray != null) { + for (String abName : btmApNameArray) { + if (!exceptAbs.contains(abName)) { exceptAbs.add(abName); } } } } //鏋勯�犲彲鍒犻櫎鐨勫睘鎬� - if(attribItems != null){ - for(AttributeDef ab : attribItems){ + if (attribItems != null) { + for (AttributeDef ab : attribItems) { String abName = ab.name; - if(!exceptAbs.contains(abName)){ + if (!exceptAbs.contains(abName)) { list.add(abName); } } @@ -1524,6 +1969,7 @@ /** * 鑾峰彇寰呭垹闄ょ殑鏋氫妇绫诲瀷 + * * @return */ public List<EnumType> getDelEnumList() { @@ -1533,15 +1979,15 @@ exceptEnums = new ArrayList<String>(); EnumType[] emItems = ClientServiceProvider.getOMDService().getEnumService().getEnumTypes("", 0, 0); AttributeDef[] abs = platformClientUtil.getAttributeService().getAttributeDefsByNames(exceptAbs.toArray(new String[0])); - for(AttributeDef ab : abs){ + for (AttributeDef ab : abs) { OtherInfo otherInfo = OtherInfo.getOtherInfoByText(ab.other); String enumName = otherInfo.getEnumName(); - if(enumName != null && !enumName.equals("") && !exceptEnums.contains(enumName)){ + if (enumName != null && !enumName.equals("") && !exceptEnums.contains(enumName)) { exceptEnums.add(enumName); } } - for(EnumType em : emItems){ - if(!exceptEnums.contains(em.name)){ + for (EnumType em : emItems) { + if (!exceptEnums.contains(em.name)) { list.add(em); } } @@ -1553,17 +1999,18 @@ /** * 鑾峰彇寰呭垹闄ょ殑鐢熷懡鍛ㄦ湡 + * * @return */ - public List<LifeCycle> getDelLCList(){ + public List<LifeCycle> getDelLCList() { List<LifeCycle> list = new ArrayList<LifeCycle>(); exceptLCs = new ArrayList<String>(); exceptStates = new ArrayList<String>(); - for(String btName : exceptBts){ + for (String btName : exceptBts) { try { BizType bt = platformClientUtil.getBtmService().getBizTypeByName(btName); String lcName = bt.lifeCycle; - if(lcName != null && !lcName.equals("") && !exceptLCs.contains(lcName)){ + if (lcName != null && !lcName.equals("") && !exceptLCs.contains(lcName)) { exceptLCs.add(lcName); } } catch (PLException e) { @@ -1577,15 +2024,15 @@ } catch (PLException e) { e.printStackTrace(); } - if(lcs != null){ - for(LifeCycle lc : lcs){ + if (lcs != null) { + for (LifeCycle lc : lcs) { String name = lc.name; - if(name != null && !name.equals("") && !exceptLCs.contains(name)){ + if (name != null && !name.equals("") && !exceptLCs.contains(name)) { list.add(lc); - }else{ + } else { //淇濈暀鐨勭姸鎬佹睜 Bound[] bounds = lc.bounds; - for(Bound bound : bounds){ + for (Bound bound : bounds) { String sName = bound.name; exceptStates.add(sName); } @@ -1597,9 +2044,10 @@ /** * 鑾峰彇寰呭垹闄ょ殑鐘舵�� + * * @return */ - public List<StatePool> getDelSPList(){ + public List<StatePool> getDelSPList() { List<StatePool> list = new ArrayList<StatePool>(); StatePool[] states = null; try { @@ -1607,10 +2055,10 @@ } catch (PLException e) { e.printStackTrace(); } - if(states != null){ - for(StatePool state : states){ + if (states != null) { + for (StatePool state : states) { String name = state.name; - if(name != null && !name.equals("") && !exceptStates.contains(name)){ + if (name != null && !name.equals("") && !exceptStates.contains(name)) { list.add(state); } } @@ -1620,16 +2068,17 @@ /** * 鑾峰彇寰呭垹闄ょ殑鐗堟湰瑙勫垯 + * * @return */ - public List<VersionRule> getDelVRList(){ + public List<VersionRule> getDelVRList() { List<VersionRule> list = new ArrayList<VersionRule>(); exceptRev = new ArrayList<String>(); - for(String btName : exceptBts){ + for (String btName : exceptBts) { try { BizType bt = platformClientUtil.getBtmService().getBizTypeByName(btName); String revName = bt.revRuleName; - if(revName != null && !revName.equals("") && !exceptRev.contains(revName)){ + if (revName != null && !revName.equals("") && !exceptRev.contains(revName)) { exceptRev.add(revName); } } catch (PLException e) { @@ -1642,10 +2091,10 @@ } catch (PLException e) { e.printStackTrace(); } - if(revs != null){ - for(VersionRule rev : revs){ + if (revs != null) { + for (VersionRule rev : revs) { String name = rev.name; - if(name != null && !name.equals("") && !exceptRev.contains(name)){ + if (name != null && !name.equals("") && !exceptRev.contains(name)) { list.add(rev); } } @@ -1655,4 +2104,41 @@ } + private class BtmDataFetcher { + + //涓氬姟绫诲瀷 + private Map<String, BizType> btmTypeVOMap = new HashMap<String, BizType>(); + + public BtmDataFetcher() { + initBtmDataFetcher(); + } + + private void initBtmDataFetcher(){ + try { + BizType[] bizTypes = platformClientUtil.getBtmService().getBizTypes(""); + //List<OsBtmTypeVO> osBtmTypeVOS = btmDO2VOs(Arrays.asList(bizTypes), null); + if(Func.isNotEmpty(bizTypes)){ + btmTypeVOMap = Arrays.stream(bizTypes).collect(Collectors.toMap(btm -> btm.name, btm -> btm)); + } + }catch (Exception e){ + e.printStackTrace(); + } + } + + /** + * 鑾峰彇涓氬姟绫诲瀷 + * @param id + * @return + */ + public OsBtmTypeVO getBtmType(String id) { + BizType bizType = btmTypeVOMap.get(id); + if(Func.isEmpty(bizType)){ + return null; + } + //鑾峰彇鐨勬椂鍊欐墠璧歏O瀵硅薄锛岃繖鏍烽伩鍏嶄竴娆℃�у叏閮˙tm杞琕O澶參鐨勯棶棰� + return btmDO2VO(bizType,null); + } + + } + } -- Gitblit v1.9.3