From bd945fa9dd9d4edabf1d4284fd626f6727c76c27 Mon Sep 17 00:00:00 2001
From: 田源 <lastanimals@163.com>
Date: 星期二, 12 十二月 2023 10:01:22 +0800
Subject: [PATCH] 整合代码
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java | 1454 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,454 insertions(+), 0 deletions(-)
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java
new file mode 100644
index 0000000..bd645df
--- /dev/null
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java
@@ -0,0 +1,1454 @@
+package com.vci.ubcs.code.service.impl;
+
+import com.alibaba.nacos.common.utils.StringUtils;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
+import com.sun.org.apache.bcel.internal.generic.NEW;
+import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
+import com.vci.ubcs.code.entity.*;
+import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
+import com.vci.ubcs.code.mapper.*;
+import com.vci.ubcs.code.po.CodeClassifyPO;
+import com.vci.ubcs.code.service.ICodeClassifyService;
+import com.vci.ubcs.code.service.ICodeKeyAttrRepeatService;
+import com.vci.ubcs.code.service.ICodeRuleService;
+import com.vci.ubcs.code.vo.pagemodel.CodeAllCodeVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeKeyAttrRepeatRuleVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
+import com.vci.ubcs.omd.cache.EnumCache;
+import com.vci.ubcs.omd.enums.EnumEnum;
+import com.vci.ubcs.omd.feign.IBtmTypeClient;
+import com.vci.ubcs.omd.vo.BtmTypeAttributeVO;
+import com.vci.ubcs.omd.feign.IBtmTypeClient;
+import com.vci.ubcs.omd.vo.BtmTypeVO;
+import com.vci.ubcs.starter.bo.WriteExcelData;
+import com.vci.ubcs.starter.exception.VciBaseException;
+import com.vci.ubcs.starter.poi.bo.ReadExcelOption;
+import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
+import com.vci.ubcs.starter.poi.constant.ExcelLangCodeConstant;
+import com.vci.ubcs.starter.poi.util.ExcelUtil;
+import com.vci.ubcs.starter.revision.model.TreeQueryObject;
+import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
+import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
+import com.vci.ubcs.starter.util.BladeTreeQueryObject;
+import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
+import com.vci.ubcs.starter.util.LocalFileUtil;
+import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
+import com.vci.ubcs.starter.web.pagemodel.BaseQueryObject;
+import com.vci.ubcs.starter.web.pagemodel.DataGrid;
+import com.vci.ubcs.starter.web.pagemodel.Tree;
+import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
+import com.vci.ubcs.starter.web.util.LangBaseUtil;
+import com.vci.ubcs.starter.web.util.VciBaseUtil;
+import com.vci.ubcs.system.cache.NacosConfigCache;
+import org.apache.poi.hssf.util.HSSFColor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springblade.core.cache.utils.CacheUtil;
+import org.springblade.core.launch.constant.AppConstant;
+import org.springblade.core.log.exception.ServiceException;
+import org.springblade.core.mp.support.Condition;
+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.BeanUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
+
+import javax.annotation.Resource;
+import java.awt.event.ItemEvent;
+import java.io.File;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
+import static com.vci.ubcs.starter.web.util.VciBaseUtil.getTableName;
+
+@Service
+public class CodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {
+
+ @Resource
+ private CodeClassifyMapper codeClassifyMapper;
+
+ @Resource
+ private CodeClassifyTemplateMapper codeClassifyTemplateMapper;
+
+ @Resource
+ private ICodeRuleService codeRuleService;
+
+ @Resource
+ private IBtmTypeClient btmTypeClient;
+
+ @Resource
+ private CommonsMapper commonsMapper;
+
+ /**
+ * 鏃ュ織
+ */
+ private Logger logger = LoggerFactory.getLogger(getClass());
+ /**
+ * 瀵硅薄鐨勬搷浣�
+ */
+ @Resource
+ private RevisionModelUtil revisionModelUtil;
+
+ @Resource
+ private ICodeKeyAttrRepeatService iCodeKeyattrrepeatService;
+
+ @Resource
+ private CodeAllCodeMapper codeAllCodeMapper;
+
+ @Resource
+ private CodeSerialValueMapper codeSerialValueMapper;
+
+ @Resource
+ private CodeBasicSecMapper codeBasicSecMapper;
+ /**
+ * 涓婄骇鑺傜偣鐨勫睘鎬у悕绉�
+ */
+ public static final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
+ /**
+ * 浣跨敤鏌ヨ灏佽鍣ㄦ潵鏌ヨ
+ * @param wrapper 鏌ヨ灏佽鍣�
+ * @return 鏁版嵁瀵硅薄
+ */
+ @Override
+ public List<CodeClassify> selectByWrapper(Wrapper wrapper) {
+ return codeClassifyMapper.selectList(wrapper);
+ }
+
+ /**
+ * 鏌ヨ
+ * @param wrapper 鏌ヨ灏佽鍣�
+ * @return
+ */
+ @Override
+ public List<String> select1(Wrapper wrapper) {
+
+ return codeClassifyMapper.selectObjs(wrapper);
+ }
+
+ @Override
+ public IPage<CodeClassifyVO> selectPlCodeClassifyPage(IPage<CodeClassifyVO> page, CodeClassifyVO plCodeClassify) {
+ return page.setRecords(codeClassifyMapper.selectPlCodeClassifyPage(page, plCodeClassify,AuthUtil.getTenantId()
+ .equals(
+ NacosConfigCache
+ .getAdminUserInfo()
+ .getTenantId()
+ ) ? null:AuthUtil.getTenantId()));
+ }
+
+ /**
+ * 涓婚搴撳畾涔夎〃 鏂板
+ * @param
+ */
+ @Override
+ public R addSave(CodeClassify codeClassifyEntity) {
+ try {
+ VciBaseUtil.alertNotNull(codeClassifyEntity.getId(),"涓婚搴撶紪鍙蜂笉鑳戒负绌猴紒",codeClassifyEntity.getName(),"涓婚搴撳悕绉颁笉鑳戒负绌猴紒");
+ }catch (VciBaseException e){
+ return R.fail(e.getMessage());
+ }
+ if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
+ return R.fail("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
+ }
+ if(StringUtils.isEmpty(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isBlank(codeClassifyEntity.getBtmTypeId())){
+ return R.fail("涓婚搴撳叧鑱旂殑涓氬姟绫诲瀷涓嶈兘涓虹┖锛�");
+ }
+ QueryWrapper<CodeClassify> classifyQueryWrapper = new QueryWrapper<>();
+ classifyQueryWrapper.eq("parentCodeClassifyOid",codeClassifyEntity.getParentCodeClassifyOid());
+ classifyQueryWrapper.eq("id",codeClassifyEntity.getId());
+ List<CodeClassify> codeClassifyList = baseMapper.selectList(classifyQueryWrapper);
+ if(codeClassifyList.size()!=0){
+ return R.fail("褰撳墠鍒嗙被涓嬩笉鍏佽鍒嗙被缂栧彿閲嶅锛岃妫�鏌ワ紒锛侊紒");
+ }
+ if(Func.isNotEmpty(codeClassifyEntity.getParentCodeClassifyOid())){
+ CodeClassify codeClassify = baseMapper.selectOne(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getOid, codeClassifyEntity.getParentCodeClassifyOid()));
+ codeClassifyEntity.setBtmTypeId(codeClassify.getBtmTypeId());
+ codeClassifyEntity.setBtmTypeName(codeClassify.getBtmTypeName());
+ }
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeClassifyEntity, MdmBtmTypeConstant.CODE_CLASSIFY);
+ codeClassifyEntity.setLcStatus(FRAMEWORK_DATA_ENABLED);
+ int insertNumber = codeClassifyMapper.insert(codeClassifyEntity);
+ return R.status(SqlHelper.retBool(insertNumber));
+ }
+
+ /**
+ * 淇敼涓婚搴撳垎绫�
+ * @param codeClassifyEntity 涓婚搴撳垎绫绘暟鎹紶杈撳璞�
+ * @return 鎵ц缁撴灉
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public R editSave(CodeClassify codeClassifyEntity) {
+ if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
+ return R.fail("浼犲叆鏁版嵁涓嶈兘涓虹┖锛�");
+ }
+ //妫�鏌s
+ CodeClassify detail = codeClassifyMapper.selectById(codeClassifyEntity.getOid());
+ if(!detail.getTs().toString().equals(codeClassifyEntity.getTs().toString())){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
+ return R.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+ }
+
+ if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
+ return R.fail("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
+ }
+ // codeClassifyEntity.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
+ codeClassifyEntity.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
+ codeClassifyEntity.setLastModifyTime(new Date());
+ codeClassifyEntity.setTs(new Date());
+ int updateEntity = codeClassifyMapper.updateById(codeClassifyEntity);
+ // 濡傛灉涓嶆槸鍙跺瓙缁撶偣锛屽垯闇�瑕佷慨鏀瑰叾涓嬫墍鏈夌殑瀛愬垎绫伙紝鏄惁鍙備笌鍏抽敭灞炴�ф牎楠岀殑鍊�
+ String oid = codeClassifyEntity.getOid();
+ List<CodeClassify> codeClassifies = codeClassifyMapper.selectStartWithCurrentOid(oid);
+ int updateAttr = 0;
+ // 涓嶄负绌哄氨闇�瑕佽褰撳墠鍒嗙被涓嬫墍鏈夊瓙鍒嗙被鐨刬sParticipateCheck
+ if(!codeClassifies.isEmpty()){
+ List<String> oids = codeClassifies.stream().map(CodeClassify::getOid).collect(Collectors.toList());
+ LambdaUpdateWrapper<CodeClassify> updateWrapper = Wrappers.<CodeClassify>update()
+ .lambda().in(CodeClassify::getOid, oids)
+ .set(CodeClassify::getIsParticipateCheck, codeClassifyEntity.getIsParticipateCheck());
+ // 鐖跺垎绫荤殑涓氬姟绫诲瀷鍋氫簡鏇存敼锛屾墍鏈夊瓙鍒嗙被鐨勯兘寰楄繘琛屾洿鏀�
+ if(!codeClassifyEntity.getBtmTypeId().equals(detail.getBtmTypeId())){
+ updateWrapper.set(CodeClassify::getBtmTypeId,codeClassifyEntity.getBtmTypeId())
+ .set(CodeClassify::getBtmTypeName,codeClassifyEntity.getBtmTypeName());
+ }
+ updateAttr = codeClassifyMapper.update(null,updateWrapper);
+
+ }
+
+// //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆傚彧鏈夊惎鐢ㄧ姸鎬佺殑鍒嗙被鎵嶆帹閫�
+// if(FRAMEWORK_DATA_ENABLED.equals(codeClassifyDO.getLcStatus()));
+// {
+// codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_EDIT,FRAMEWORK_DATA_ENABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO.getOid(), codeClassifyDTO.getTs());
+// }
+ return R.status(SqlHelper.retBool(updateAttr) & SqlHelper.retBool(updateEntity));
+ }
+
+ /**
+ * 妫�鏌� 涓婚搴撳垎绫绘槸鍚﹀垹闄�
+ * @param codeClassifyEntity 涓婚搴撳垎绫绘暟鎹紶杈撳璞★紝蹇呴』瑕佹湁oid鍜宼s灞炴��
+ * @return 鎵ц缁撴灉 success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
+ */
+ @Override
+ public R checkIsCanDelete(CodeClassify codeClassifyEntity) {
+ if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
+ return R.fail("浼犲叆鏁版嵁涓嶈兘涓虹┖锛�");
+ }
+ CodeClassify codeClassifyNew = selectByOid(codeClassifyEntity.getOid());
+ if(codeClassifyNew == null){
+ return R.fail("鏈煡璇㈠埌鐩稿叧鏁版嵁锛�");
+ }
+ codeClassifyNew.setTs(codeClassifyEntity.getTs());
+ return checkIsCanDeleteForDO(codeClassifyEntity);
+ }
+
+ /**
+ * 涓婚敭鏌ヨ鏁版嵁瀵硅薄
+ * @param oid 涓婚敭
+ * @return 鏁版嵁瀵硅薄
+ */
+ private CodeClassify selectByOid(String oid){
+ List<CodeClassify> codeClassifyEntityList = codeClassifyMapper.selectClassifyByKeyAndReseRel("'" + oid.trim() + "'");
+ if (codeClassifyEntityList.isEmpty() || codeClassifyEntityList.get(0) == null || StringUtils.isBlank(codeClassifyEntityList.get(0).getOid())) {
+ throw new ServiceException("dataOidNotExist");//鏍规嵁涓婚敭id鏈煡鍒扮浉鍏虫暟鎹�
+ }
+ return codeClassifyEntityList.get(0);
+ }
+
+ /**
+ * 鏍￠獙鏄惁鍙互鍒犻櫎锛屽鏋滃瓨鍦ㄤ笅绾э紝骞朵笖涓嬬骇鏈夋暟鎹紩鐢ㄥ垯涓嶈兘鍒犻櫎
+ * @param codeClassifyEntity 鏁版嵁搴撲腑鐨勬暟鎹璞�
+ * @return success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
+ */
+ private R checkIsCanDeleteForDO(CodeClassify codeClassifyEntity) {
+
+ //妫�鏌s
+// Map<String,Object> condition = new HashMap<>(2);
+// condition.put("oid",codeClassifyEntity.getOid());
+// condition.put("ts",codeClassifyEntity.getTs());
+ CodeClassify detail = codeClassifyMapper.selectOne(Condition.getQueryWrapper(codeClassifyEntity));
+// .selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
+ if(detail == null){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
+ throw new ServiceException("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+ }
+ //鏍￠獙涓嬬骇鏄惁鏈夊紩鐢�
+ if(checkChildIsLinked(detail.getOid())){
+ return R.fail("dataCascadeLinkedNotDelete");
+ }
+ if(checkHasChild(detail.getOid())){
+ return R.fail("姝ゆ暟鎹湁涓嬬骇锛屾棤娉曡繘琛屽垹闄わ紒");
+ }
+ return R.status(!checkHasChild(detail.getOid()));
+ }
+
+ /**
+ * 妫�鏌ユ槸鍚︽湁涓嬬骇鏄惁鍏宠仈浜嗘暟鎹�
+ *
+ * @param oid 涓婚敭
+ * @return true 琛ㄧず鏈夊紩鐢紝false琛ㄧず娌℃湁寮曠敤
+ */
+ @Override
+ public boolean checkChildIsLinked(String oid) {
+
+ Map<String,String> childOids = codeClassifyMapper.selectAllLevelChildOid(oid.trim());
+ if(!CollectionUtils.isEmpty(childOids)){
+ for(String childOid: childOids.keySet()){
+ if(!checkIsLinked(childOid)){
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * 鏍￠獙鏄惁琚紩鐢�
+ * @param oid 涓婚敭
+ */
+ private boolean checkIsLinked(String oid) {
+ //TODO 娣诲姞闇�瑕佹牎楠屽紩鐢ㄧ殑鍦版柟
+ return false;
+ }
+
+ @Override
+ public boolean checkHasChild(String oid) {
+ if(StringUtils.isBlank(oid)){
+ throw new ServiceException("oid涓嶈兘涓虹┖锛�");
+ }
+ return codeClassifyMapper.checkHasChild(oid.trim());
+ }
+
+ /**
+ * 鍒犻櫎涓婚搴撳垎绫�
+ * @param codeClassify 涓婚搴撳垎绫绘暟鎹紶杈撳璞★紝oid鍜宼s闇�瑕佷紶杈�
+ * @return 鍒犻櫎缁撴灉鍙嶉锛氾細success锛氭垚鍔燂紝fail锛氬け璐�
+ */
+ @Override
+ public R deleteCodeClassify(CodeClassify codeClassify) {
+
+ if(codeClassify == null || codeClassify.getOid() == null){
+ throw new ServiceException("浼犲叆鍙傛暟涓嶈兘涓虹┖锛�");
+ }
+ codeClassify = codeClassifyMapper.selectById(codeClassify.getOid());
+
+ R result = checkIsCanDeleteForDO(codeClassify);
+
+ //鍏堟鏌ユ槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+ Map<String,Object> condition = new HashMap<>(2);
+ condition.put("codeClassifyOid",codeClassify.getOid());
+ List<CodeClassifyTemplate> codeClstemplateEntities = codeClassifyTemplateMapper.selectByMap(condition);
+// VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateDO.class);
+// queryWrapper.addQueryMap("codeClassifyOid",codeClassifyDTO.getOid());
+// List<CodeClassifyTemplateDO> codeClassifyTemplateDOListHaveTemplate = codeClassifyTemplateMapper.selectByWrapper(queryWrapper);
+ if(codeClstemplateEntities.size()>0){
+ return R.fail("鍒嗙被鍏宠仈妯℃澘锛岃鍏堝垹闄�!");
+ }
+
+ //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
+ //1銆佹煡璇㈣鍒犻櫎鐨勭埗绫绘暟鎹�
+ List<CodeClassify> deletes = new ArrayList<CodeClassify>();
+ deletes.add(codeClassify);
+
+ if(result.isSuccess()) {
+ //鎵句笅绾х殑锛岃繖涓槸鍙互鍒犻櫎鐨勬椂鍊�
+ Map<String,String> childrenOids = codeClassifyMapper.selectAllLevelChildOid(codeClassify.getOid().trim());
+ if (!CollectionUtils.isEmpty(childrenOids)) {
+ Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids.keySet());
+ for(Collection<String> s : childrenCollections){
+
+ //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
+ //2銆佹煡璇㈣鍒犻櫎鐨勫瓙绫绘暟鎹�
+ List<CodeClassify> codeClassifyDOList = codeClassifyMapper.selectBatchIds(s);
+ deletes.addAll(codeClassifyDOList);
+// codeClassifyMapper.deleteBatchIds(s);
+ baseMapper.deleteBatchIds(s);
+ }
+
+ }
+ }else{
+ return result;
+ }
+
+ //鎵ц鍒犻櫎鎿嶄綔
+ int deleteCount = codeClassifyMapper.deleteById(codeClassify.getOid());
+
+ //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�
+ for (CodeClassify codeClassifyTemp:deletes){
+ //codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_DELETE,FRAMEWORK_DATA_DISABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO1.getOid(), DateUtils.addHours(new Date(),1));//杩欓噷鏄綋鍓嶆椂闂�
+
+ //瀛樺偍瑕佸垹闄ょ殑鏁版嵁
+// CacheUtil.put();
+ CacheUtil.put("ubcs:code", "bean:id:", codeClassifyTemp.getOid(), codeClassifyTemp);
+// codeDuckingServiceI.cacheDeleteData(codeClassifyTemp.getOid(), codeClassifyTemp);
+ }
+ return R.data(deleteCount>0);
+// return null;
+ }
+
+ /**
+ * 鍚敤銆佸仠鐢�
+ * @param oid 涓婚敭
+ * @param lcStatus 鐘舵��
+ * @return 鎵ц缁撴灉
+ */
+ @Override
+ public R updateLcStatus(String oid, String lcStatus){
+
+ List<CodeClassify> classifyList = codeClassifyMapper.selectStartWithCurrentOid(oid);
+ Date now = new Date();
+ // String userId = String.valueOf(AuthUtil.getUserId());
+ String account = AuthUtil.getUserAccount();
+ classifyList = classifyList.stream().map(s -> {
+ s.setLcStatus(lcStatus);
+ s.setTs(now);
+ s.setLastModifier(account);
+ s.setLastModifyTime(now);
+ return s;
+ }).collect(Collectors.toList());
+// //鏌ヨ淇敼鍓峵s
+// CodeClassify codeClassify = codeClassifyMapper.selectById(oid);//涓昏鏄负浜嗘煡璇s
+// codeClassify.setLcStatus(lcStatus);
+// codeClassify.setTs(new Date());
+// codeClassify.setLastModifyTime(new Date());
+// codeClassify.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
+ //鍚敤銆佸仠鐢�
+// int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
+// int count = codeClassifyMapper.updateById(codeClassify);
+ codeClassifyMapper.batchUpdateLcStatus(classifyList);
+// //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
+// if(u!=0) {
+// codeDuckingServiceI.insertCache1(lcStatus,lcStatus,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, oid, codeClassifyDO_old.getTs());
+// }
+// return R.data(SqlHelper.retBool(count));
+ return R.success("");
+ }
+
+ /**
+ * 涓婚敭鎵归噺鑾峰彇涓婚搴撳垎绫�
+ * @param oidCollections 涓婚敭闆嗗悎锛屼絾鏄彈鎬ц兘褰卞搷锛屽缓璁竴娆℃煡璇笉瓒呰繃10000涓�
+ * @return 涓婚搴撳垎绫绘樉绀哄璞�
+ */
+ @Override
+ public Collection<CodeClassifyVO> listCodeClassifyByOids(Collection<String> oidCollections) {
+ VciBaseUtil.alertNotNull(oidCollections,"鏁版嵁瀵硅薄涓婚敭闆嗗悎");
+ List<CodeClassify> codeClassifyDOList = listCodeClassifyDOByOidCollections(oidCollections);
+ return codeClassifyDO2VOs(codeClassifyDOList);
+ }
+
+ /**
+ * 浣跨敤涓婚敭闆嗗悎鏌ヨ鏁版嵁瀵硅薄
+ * @param oidCollections 涓婚敭鐨勯泦鍚�
+ * @return 鏁版嵁瀵硅薄鍒楄〃
+ */
+ private List<CodeClassify> listCodeClassifyDOByOidCollections(Collection<String> oidCollections){
+ List<CodeClassify> codeClassifyList = new ArrayList<CodeClassify>();
+ if(!CollectionUtils.isEmpty(oidCollections)){
+ Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
+ for(Collection<String> oids: oidCollectionsList){
+ List<CodeClassify> tempDOList = codeClassifyMapper.selectBatchIds(oids);
+ if(!CollectionUtils.isEmpty(tempDOList)){
+ codeClassifyList.addAll(tempDOList);
+ }
+ }
+ }
+ return codeClassifyList;
+ }
+
+ /**
+ * 鎵归噺鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+ * @param codeClassifys 鏁版嵁瀵硅薄鍒楄〃
+ * @return 鏄剧ず瀵硅薄
+ */
+ @Override
+ public List<CodeClassifyVO> codeClassifyDO2VOs(Collection<CodeClassify> codeClassifys) {
+ List<CodeClassifyVO> voList = new ArrayList<CodeClassifyVO>();
+ if(!CollectionUtils.isEmpty(codeClassifys)){
+ for(CodeClassify s: codeClassifys){
+ CodeClassifyVO vo = codeClassifyDO2VO(s);
+ if(vo != null){
+ voList.add(vo);
+ }
+ }
+ }
+ return voList;
+ }
+
+ /**
+ * 鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+ * @param codeClassify 鏁版嵁瀵硅薄
+ * @return 鏄剧ず瀵硅薄
+ */
+ @Override
+ public CodeClassifyVO codeClassifyDO2VO(CodeClassify codeClassify) {
+ CodeClassifyVO vo = new CodeClassifyVO();
+ if(codeClassify != null){
+ BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassify,vo);
+ //濡傛灉鏈塴cstatus鐨勭被鐨勮瘽
+ vo.setLcStatusText(FrameworkDataLCStatus.getTextByValue(vo.getLcStatus()));
+ }
+ return vo;
+ }
+
+ /**
+ * 鍙傜収鏍� 涓婚搴撳垎绫�
+ * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+ * @return 涓婚搴撳垎绫绘樉绀烘爲
+ */
+ @Override
+ public List<Tree> referTree(TreeQueryObject treeQueryObject) {
+ if(treeQueryObject == null){
+ treeQueryObject = new TreeQueryObject();
+ }
+ if(treeQueryObject.getConditionMap() == null){
+ treeQueryObject.setConditionMap(new HashMap<>());
+ }
+ if(treeQueryObject.getConditionMap().containsKey(LC_STATUS)) {
+ treeQueryObject.getConditionMap().remove(LC_STATUS);
+ }
+ if(treeQueryObject.getExtandParamsMap() ==null || !treeQueryObject.getExtandParamsMap().containsKey(REFER_SHOW_DISABLED_QUERY_KEY)) {
+ }
+ treeQueryObject.getConditionMap().put(LC_STATUS, FRAMEWORK_DATA_ENABLED);
+ return treeCodeClassify(treeQueryObject);
+ }
+
+ /**
+ * 涓婚敭鏌ヨ鏁版嵁瀵硅薄,鍏宠仈鏌ヨ
+ * @param oid 涓婚敭
+ * @return 鏁版嵁瀵硅薄
+ */
+ private CodeClassify selectByOidRel(String oid){
+
+ List<CodeClassify> codeClassifyList = codeClassifyMapper.selectClassifyByKeyAndReseRel("'"+oid.trim()+"'");
+// CodeClassify codeClassifyEntity = (CodeClassify) codeClassifyList;
+ if(codeClassifyList.size() == 0 ){
+ throw new ServiceException("dataNotExist");//鏍规嵁涓婚敭id鏈煡鍒扮浉鍏虫暟鎹�
+ }
+// if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
+// throw new ServiceException("dataOidNotExist");//鏍规嵁涓婚敭id鏈煡鍒扮浉鍏虫暟鎹�
+// }
+ return codeClassifyList.get(0);
+ }
+
+ /**
+ * 鏌ヨ涓婚搴撳垎绫� 鏍�
+ * @param treeQueryObject 鏍戞煡璇㈠璞�
+ * @return 涓婚搴撳垎绫� 鏄剧ず鏍�
+ */
+ @Override
+ public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) {
+ List<CodeClassify> doList = null;
+ String id = null;
+ String lcStatus = null;
+ if(!Objects.isNull(treeQueryObject.getConditionMap())){
+ id = treeQueryObject.getConditionMap().getOrDefault("id",null);
+ lcStatus = treeQueryObject.getConditionMap().getOrDefault("lcStatus",null);
+ }
+ if(StringUtils.isNotBlank(id) || StringUtils.isNotBlank(lcStatus) ){
+ //String tableName = this.getTableName(treeQueryObject.getConditionMap().get("btmTypeId"),treeQueryObject.getConditionMap().get("id"), treeQueryObject.getConditionMap().get("lcStatus"));
+ doList = codeClassifyMapper
+ .selectCodeClassifyDOByTree(
+ treeQueryObject.getConditionMap().get("id"),
+ treeQueryObject.getConditionMap().get("lcStatus"),
+ treeQueryObject.getParentOid(),
+ VciBaseUtil.checkAdminTenant() ? null:AuthUtil.getTenantId()
+ /*tableName*/
+ );
+ }else{
+ // 鍙鍓嶇浼氫紶鍙傛暟杩囨潵灏变笉浼氬嚭鐜拌蛋杩欏彞鐨勬儏鍐碉紝鎵�浠ユ煡璇㈡�绘暟娌″湪杩欏効娣诲姞
+ doList =codeClassifyMapper.selectCodeClassifyVOByTree(
+ treeQueryObject.getParentOid(),
+ VciBaseUtil.checkAdminTenant() ? null:AuthUtil.getTenantId()
+ );
+ }
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
+ TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
+ treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
+ List<Tree> tree= revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyVO s) ->{
+ //鍙互鍦ㄨ繖閲屽鐞嗘爲鑺傜偣鐨勬樉绀�
+ return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
+ .getLcStatus()) ? (" 銆愬仠鐢ㄣ�� ") : "");
+ });
+
+ Iterator var6 = tree.listIterator();
+ while(var6.hasNext()){
+ Tree trees = (Tree) var6.next();
+ boolean checkHasChild=codeClassifyMapper.checkHasChild(trees.getOid());
+ if(checkHasChild){
+ trees.setLeaf(false);
+ }else{
+ trees.setLeaf(true);
+ }
+ }
+ return tree;
+ }
+
+ /**
+ * 鍒嗙被鍔犺浇鏃惰幏鍙栦笟鍔＄被鍨媔d锛屾嫾鎺ヤ笟鍔＄被鍨嬭〃鍚�
+ * @return
+ */
+ private String getTableName(String btmTypeId,String id,String lcStatus){
+ if(Func.isNotEmpty(btmTypeId)){
+ return VciBaseUtil.getTableName(btmTypeId,true);
+ }
+ LambdaQueryWrapper<CodeClassify> wrapper = Wrappers.<CodeClassify>query()
+ .lambda().select(CodeClassify::getBtmTypeId)
+ .eq(CodeClassify::getLcStatus, lcStatus)
+ .isNotNull(CodeClassify::getBtmTypeId)
+ .last("limit 1")
+ .eq(CodeClassify::getId,id).isNull(CodeClassify::getParentCodeClassifyOid);
+
+ CodeClassify codeClassify = codeClassifyMapper.selectOne(wrapper);
+ if(Func.isEmpty(codeClassify) || Func.isEmpty(codeClassify.getBtmTypeId())){
+ throw new ServiceException("鏌ヨ涓绘暟鎹�绘暟鏃讹紝鏈幏鍙栧埌涓氬姟绫诲瀷ID锛�");
+ }
+ return VciBaseUtil.getTableName(codeClassify.getBtmTypeId(),true);
+ }
+
+ /**
+ * 鏍规嵁鏍戝舰鏌ヨ瀵硅薄鏉ユ煡璇㈡暟鎹璞�
+ *
+ * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+ * @return 鏌ヨ缁撴灉,鏁版嵁瀵硅薄
+ */
+ @Override
+ public List<CodeClassifyVO> selectCodeClassifyDOByTree(TreeQueryObject treeQueryObject) {
+ List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyVOByTree(treeQueryObject.getParentOid(),AuthUtil.getTenantId());
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
+ return voList;
+ }
+
+ /***
+ *
+ * @param parentOid
+ * @return
+ */
+ @Override
+ public List<CodeClassifyVO> selectCodeClassifyVOByParentId(String parentOid) {
+ List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyDOByParentId(parentOid,AuthUtil.getTenantId());
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
+ return voList;
+ }
+
+ /**
+ * 鏍规嵁搴撹妭鐐瑰悕绉拌幏鍙栧垎绫�
+ * @param libName
+ * @return
+ */
+ @Override
+ public List<CodeClassifyVO> getRMLibByName(String libName) {
+ List<String> libNameList=new ArrayList<>();
+ if(StringUtils.isNotBlank(libName)){
+ libNameList=VciBaseUtil.str2List(libName);
+ }
+ List<CodeClassify> doList =codeClassifyMapper.getRMLibByName(libNameList,"Enabled",AuthUtil.getTenantId()
+ .equals(
+ NacosConfigCache
+ .getAdminUserInfo()
+ .getTenantId()
+ ) ? null:AuthUtil.getTenantId());
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
+ return voList;
+ }
+
+ /***
+ * 鏍规嵁oid鑾峰彇涓嬮潰鎵�鏈夌殑鍒嗙被淇℃伅
+ * @param oid
+ * @return
+ */
+ public List<CodeClassifyVO> selectAllClassifyByOid(String oid, String fieldInPath){
+ List<CodeClassify> codeClassifyList=codeClassifyMapper.selectAllClassifyByOid(oid,AuthUtil.getTenantId(),fieldInPath);
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(codeClassifyList);
+ return voList;
+
+ }
+
+ /**
+ * 鏍规嵁椤跺眰鑺傜偣oid鏌ヨ鎵�鏈夐櫎褰撳墠鑺傜偣浠ュ鎵�鏈変笉鍙備笌鏍￠獙鐨勫垎绫籵id
+ * @param topOid
+ * @param currentOid
+ * @return
+ */
+ @Override
+ public String selectLeafByParentClassifyOid(String topOid, String currentOid) {
+ List<CodeClassify> codeClassifies = codeClassifyMapper.selectLeafByParentClassifyOid(topOid, currentOid);
+ if(codeClassifies.isEmpty()){
+ return "";
+ }
+ String oids = codeClassifies.stream().map(CodeClassify::getOid).collect(Collectors.joining(","));
+ return oids;
+ }
+
+ /**
+ * 娴佹按渚濊禆鐢熸垚
+ */
+ @Override
+ public R flowingDependencyGen(String classifyOid) {
+
+ //鏌ヨ姝ゅ垎绫讳笅闈㈢殑鎵�鏈夊垎绫�
+ List<CodeClassify> codeClassifyList=codeClassifyMapper.selectAllClassifyByOid(classifyOid,AuthUtil.getTenantId(),null);
+ //鏌ヨ鐮佸�艰〃锛岃幏鍙栨渶澶ф祦姘�
+ List<CodeAllCode> codeAllCodeVOS = codeAllCodeMapper.selectGroupByClassify("'" + codeClassifyList.stream()
+ .map(classfiy -> classfiy.getOid()).collect(Collectors.joining("','")) + "'","'${sav}'");
+ //寰�娴佹按琛ㄩ噷闈㈠姞鏁版嵁锛屾湁鍒欐洿鏂帮紝鏃犲垯娣诲姞鏁版嵁銆�
+ for (CodeAllCode codeAllCodeVO : codeAllCodeVOS) {
+ QueryWrapper<CodeBasicSec> secWrapper = new QueryWrapper<>();
+ secWrapper.eq("PKCODERULE",codeAllCodeVO.getCodeRuleOid());
+ secWrapper.eq("SECTYPE","codeserialsec");
+ List<CodeBasicSec> codeBasicSecs = codeBasicSecMapper.selectList(secWrapper);
+ if(codeBasicSecs.size() == 0 ){
+ throw new ServiceException("鏍规嵁鐮佸�糏D锛�" + codeAllCodeVO.getCodeRuleOid() + ",鐮佹绫诲瀷涓烘祦姘寸爜娈�(codeserialsec),鍦ㄥ熀纭�鐮佹涓湭鎵惧埌鐩稿叧鏁版嵁锛�");
+ }
+ QueryWrapper<CodeSerialValue> wrapper = new QueryWrapper<>();
+ wrapper.eq("codeRuleOid",codeAllCodeVO.getCodeRuleOid());
+ wrapper.eq("serialUnit",codeAllCodeVO.getSerialUnit());
+ wrapper.eq("codeSecOid",codeBasicSecs.get(0).getOid());
+ List<CodeSerialValue> codeSerialValues = codeSerialValueMapper.selectList(wrapper);
+ if(codeSerialValues.size() == 0){
+ CodeSerialValue newSerialValue = new CodeSerialValue();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(newSerialValue,"codeserialvalue");
+ newSerialValue.setCodeRuleOid(codeAllCodeVO.getCodeRuleOid());
+ newSerialValue.setCodeSecOid(codeBasicSecs.get(0).getOid());
+ newSerialValue.setSerialUnit(codeAllCodeVO.getSerialUnit());
+ newSerialValue.setMaxSerial(codeAllCodeVO.getUnFillSerial());
+ newSerialValue.setLctid("defaultLC");
+ newSerialValue.setLcStatus("Exist");
+ codeSerialValueMapper.insert(newSerialValue);
+ }else{
+ codeSerialValues.get(0).setMaxSerial(codeAllCodeVO.getUnFillSerial());
+ codeSerialValues.get(0).setLastModifyTime(new Date());
+ codeSerialValues.get(0).setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
+ codeSerialValues.get(0).setTs(new Date());
+ codeSerialValueMapper.updateById(codeSerialValues.get(0));
+ }
+ }
+ return R.success("鎿嶄綔鎴愬姛锛�");
+ }
+
+ /***
+ * 鏍规嵁鍒嗙被鎻忚堪澶囨敞鍜屽簱鑺傜偣鏌ヨ鍒嗙被淇℃伅
+ * @param desc
+ * @param codeLibName
+ * @return
+ */
+ @Override
+ public List<CodeClassifyVO> getRMTypeByDescAndLib(String desc, String codeLibName) {
+ List<CodeClassify> doList =codeClassifyMapper.getRMTypeByDesc(desc,"Enabled",AuthUtil.getTenantId());
+ if (CollectionUtils.isEmpty(doList)) {
+ return new LinkedList<CodeClassifyVO>();
+ }
+ CodeClassify codeClassify=doList.get(0);
+ List<CodeClassify> codeClassifyList=codeClassifyMapper.selectAllParenClassifytByOid(codeClassify.getOid(),AuthUtil.getTenantId());
+ CodeClassify currentLib = codeClassifyList.get(codeClassifyList.size() - 1);
+ if (!currentLib.getName().equals(codeLibName)) {
+ return new ArrayList<>();
+ }
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(codeClassifyList);
+ return voList;
+ }
+
+ /**
+ * 浣跨敤缂栧彿鐨勮矾寰勮幏鍙栧璞�
+ *
+ * @param fieldPath 缂栧彿鐨勮矾寰勶紝涓�瀹氳浠庢渶椤跺眰鑺傜偣寮�濮嬶紝鏍煎紡涓簒xx/yyy/zz 杩欐牱
+ * @return 鍒嗙被鐨勬樉绀哄璞�
+ */
+ @Override
+ public CodeClassifyVO getObjectByClsfNamePath(String fieldPath){
+ CodeClassifyVO codeClassifyVO=new CodeClassifyVO();
+ List<CodeClassify> classifyList = codeClassifyMapper.selectByFieldNamePath(fieldPath,"name");
+ if(classifyList.size()>0){
+ codeClassifyVO=codeClassifyDO2VO(classifyList.get(0));
+ }
+ return codeClassifyVO;
+ }
+ /***
+ * 鏍规嵁涓婄骇鑺傜偣鑾峰彇涓嬬骇鑺傜偣浠ｅ彿璺緞鍜屽悕绉拌矾寰�
+ * @param classifyId
+ * @param enable
+ * @return
+ */
+ @Override
+ public List<CodeClassifyVO> getIdPathToNamePathByParentId(String classifyId, boolean enable) {
+ List<CodeClassify> doList= codeClassifyMapper.getIdPathToNamePathByParentId(classifyId);
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
+ return voList;
+ }
+
+ // /**
+// * 鏍规嵁鏍戝舰鏌ヨ瀵硅薄鏉ユ煡璇㈡暟鎹璞�
+// *
+// * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+// * @return 鏌ヨ缁撴灉,鏁版嵁瀵硅薄
+// */
+// @Override
+// public List<CodeClassifyVO> selectCodeClassifyDOByTree(TreeQueryObject treeQueryObject) {
+// VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null,CodeClassifyDO.class);
+// VciParentQueryOption parentQueryOption = new VciParentQueryOption();
+// parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
+// queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
+// if(StringUtils.isBlank(treeQueryObject.getSort())) {
+// PageHelper pageHelper = new PageHelper(-1);
+// pageHelper.addDefaultAsc("id");
+// queryWrapperForDO.setPageHelper(pageHelper);
+// }
+// return codeClassifyMapper.selectByWrapper(queryWrapperForDO);
+// }
+
+ /**
+ * 瀵煎嚭鍒嗙被
+ *
+ * @param oid 鍒嗙被涓婚敭
+ * @return excel鏂囦欢璺緞
+ */
+ @Override
+ public String exportClassify(String oid) {
+ VciBaseUtil.alertNotNull(oid,"鍒嗙被鐨勪富閿�");
+ CodeClassify codeClassify = codeClassifyMapper.selectById(oid);
+ codeClassify.setDataLevel(0);
+ codeClassify.setPath(codeClassify.getId());
+ List<CodeClassifyVO> codeClassifyVOS = listChildrenClassify(oid, true, "id", false);
+ if(codeClassifyVOS ==null){
+ codeClassifyVOS = new ArrayList<>();
+ }
+ CodeClassifyVO codeClassifyVO = new CodeClassifyVO();
+ BeanUtils.copyProperties(codeClassify,codeClassifyVO);
+ codeClassifyVOS.add(codeClassifyVO);
+
+ //鏌ヨ涓�涓嬭鍒欑殑缂栧彿锛屽拰鍏抽敭灞炴�ч噸澶嶈鍒�
+ List<String> codeRuleOids = codeClassifyVOS.stream().filter(s -> StringUtils.isNotBlank(s.getCodeRuleOid())).map(CodeClassifyVO::getCodeRuleOid).collect(Collectors.toList());
+ Map<String, CodeRuleVO> ruleVOMap = new HashMap<>();
+ if(!CollectionUtils.isEmpty(codeRuleOids)){
+ VciBaseUtil.switchCollectionForOracleIn(codeRuleOids).stream().forEach(ruleOids->{
+ Collection<CodeRuleVO> ruleVOS = codeRuleService.listCodeRuleByOids(ruleOids);
+ // Collection<CodeRuleVO> ruleVOS = null;
+ ruleVOMap.putAll( Optional.ofNullable(ruleVOS).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t)));
+ });
+ }
+ //鎵惧叧閿睘鎬ц鍒�
+ List<String> keyRuleOids = codeClassifyVOS.stream().filter(s -> StringUtils.isNotBlank(s.getCodeKeyAttrRepeatOid())).map(CodeClassifyVO::getCodeKeyAttrRepeatOid).collect(Collectors.toList());
+ Map<String, CodeKeyAttrRepeatRuleVO> keyRuleVOMap = new HashMap<>();
+ if(!CollectionUtils.isEmpty(keyRuleOids)){
+ VciBaseUtil.switchCollectionForOracleIn(keyRuleOids).stream().forEach(ruleOids->{
+ Collection<CodeKeyAttrRepeatRuleVO> ruleVOS = iCodeKeyattrrepeatService.listCodeKeyAttrRepeatRuleByOids(ruleOids);
+ keyRuleVOMap.putAll( Optional.ofNullable(ruleVOS).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t)));
+ });
+ }
+ //ok,鍐檈xcel
+ String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + "瀵煎嚭鍒嗙被.xls";
+ try {
+ new File(excelName).createNewFile();
+ } catch (Throwable e) {
+ throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
+ }
+ List<WriteExcelData> excelDataList = new ArrayList<>();
+ excelDataList.add(new WriteExcelData(0,0,"鍒嗙被缂栧彿"));
+ excelDataList.add(new WriteExcelData(0,1,"鍒嗙被鍚嶇О"));
+ excelDataList.add(new WriteExcelData(0,2,"涓氬姟绫诲瀷缂栧彿"));
+ excelDataList.add(new WriteExcelData(0,3,"涓氬姟绫诲瀷鍚嶇О"));
+ excelDataList.add(new WriteExcelData(0,4,"缂栫爜瑙勫垯缂栧彿"));
+ excelDataList.add(new WriteExcelData(0,5,"缂栫爜瑙勫垯鍚嶇О"));
+ excelDataList.add(new WriteExcelData(0,6,"鏌ラ噸瑙勫垯缂栧彿"));
+ excelDataList.add(new WriteExcelData(0,7,"鏌ラ噸瑙勫垯鍚嶇О"));
+ excelDataList.add(new WriteExcelData(0,8,"鍒嗙被璺緞"));
+ excelDataList.add(new WriteExcelData(0,9,"鐘舵��"));
+ excelDataList.add(new WriteExcelData(0,10,"鍒嗙被灞傜骇"));
+ excelDataList.add(new WriteExcelData(0,11,"鎻忚堪"));
+ codeClassifyVOS = codeClassifyVOS.stream().sorted(Comparator.comparing(CodeClassifyVO::getDataLevel)).collect(Collectors.toList());
+ for (int i = 0; i < codeClassifyVOS.size(); i++) {
+ CodeClassifyVO vo = codeClassifyVOS.get(i);
+ excelDataList.add(new WriteExcelData(i+1,0,vo.getId()));
+ excelDataList.add(new WriteExcelData(i+1,1,vo.getName()));
+ excelDataList.add(new WriteExcelData(i+1,2,vo.getBtmTypeId()));
+ excelDataList.add(new WriteExcelData(i+1,3,vo.getBtmTypeName()));
+ excelDataList.add(new WriteExcelData(i+1,4, StringUtils.isNotBlank(vo.getCodeRuleOid())?ruleVOMap.getOrDefault(vo.getCodeRuleOid(),new CodeRuleVO()).getId():""));
+ excelDataList.add(new WriteExcelData(i+1,5, StringUtils.isNotBlank(vo.getCodeRuleOid())?ruleVOMap.getOrDefault(vo.getCodeRuleOid(),new CodeRuleVO()).getName():""));
+ excelDataList.add(new WriteExcelData(i+1,6, StringUtils.isNotBlank(vo.getCodeKeyAttrRepeatOid())?keyRuleVOMap.getOrDefault(vo.getCodeKeyAttrRepeatOid(),new CodeKeyAttrRepeatRuleVO()).getId():""));
+ excelDataList.add(new WriteExcelData(i+1,7, StringUtils.isNotBlank(vo.getCodeKeyAttrRepeatOid())?keyRuleVOMap.getOrDefault(vo.getCodeKeyAttrRepeatOid(),new CodeKeyAttrRepeatRuleVO()).getName():""));
+ excelDataList.add(new WriteExcelData(i+1,8,vo.getOid().equalsIgnoreCase(codeClassify.getOid())?vo.getPath():codeClassify.getPath() + vo.getPath()));
+ excelDataList.add(new WriteExcelData(i+1,9,FrameworkDataLCStatus.getTextByValue(vo.getLcStatus())));
+ excelDataList.add(new WriteExcelData(i+1,10,vo.getDataLevel()));
+ excelDataList.add(new WriteExcelData(i+1,11,vo.getDescription()));
+ }
+ WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
+ ExcelUtil.writeDataToFile(excelName, excelOption);
+ return excelName;
+ }
+
+ /**
+ * 鑾峰彇瀛愮骇鐨勪富棰樺簱鍒嗙被
+ *
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @param allLevel 鏄惁鎵�鏈夌殑灞傜骇
+ * @param fieldInPath 鍦ㄨ矾寰勪腑鐨勫瓧娈�
+ * @param enable 鏄惁鍙樉绀哄惎鐢�
+ * @return 鍒嗙被鐨勬樉绀哄璞�
+ */
+ @Override
+ public List<CodeClassifyVO> listChildrenClassify(String codeClassifyOid, boolean allLevel, String fieldInPath, boolean enable) {
+ if(allLevel){
+ List<CodeClassify> classifyDOS = codeClassifyMapper.selectAllLevelChildHasPath(codeClassifyOid,fieldInPath,AuthUtil.getTenantId());
+ if(!CollectionUtils.isEmpty(classifyDOS)){
+ classifyDOS = classifyDOS.parallelStream().filter(s->FRAMEWORK_DATA_ENABLED.equalsIgnoreCase(s.getLcStatus())).collect(Collectors.toList());
+ }
+ return codeClassifyDO2VOs(classifyDOS);
+ }else{
+ //鍙煡璇竴鏉★紝閭ath灏辨病蹇呰鏌ヨ浜�
+ Map<String,Object> conditionMap = new HashMap<>();
+ conditionMap.put("parentcodeclassifyoid",codeClassifyOid);
+ if (enable){
+ conditionMap.put("lcstatus",FRAMEWORK_DATA_ENABLED);
+ }
+ return codeClassifyDO2VOs(codeClassifyMapper.selectByMap(conditionMap));
+ }
+ }
+
+ /**
+ * 鍒涘缓瀵煎叆妯℃澘
+ *
+ * @return excel鏂囦欢璺緞
+ */
+ @Override
+ public String createImportExcel() {
+ //ok,鍐檈xcel
+ String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + "鍒嗙被瀵煎叆妯℃澘.xls";
+ try {
+ new File(excelName).createNewFile();
+ } catch (Throwable e) {
+ throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
+ }
+ List<WriteExcelData> excelDataList = new ArrayList<>();
+ WriteExcelData excelData = new WriteExcelData(0, 0, "鍒嗙被缂栧彿");
+ excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+ excelDataList.add(excelData);
+ WriteExcelData excelData1 = new WriteExcelData(0, 1, "鍒嗙被鍚嶇О");
+ excelData1.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+ excelDataList.add(excelData1);
+ excelDataList.add(new WriteExcelData(0,2,"涓氬姟绫诲瀷缂栧彿"));
+ excelDataList.add(new WriteExcelData(0,3,"缂栫爜瑙勫垯缂栧彿"));
+ excelDataList.add(new WriteExcelData(0,4,"鏌ラ噸瑙勫垯缂栧彿"));
+ WriteExcelData excelData2 = new WriteExcelData(0, 5, "鍒嗙被璺緞");
+ excelData2.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+ excelDataList.add(excelData2);
+ excelDataList.add(new WriteExcelData(0,6,"鐘舵��"));
+ WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
+ ExcelUtil.writeDataToFile(excelName, excelOption);
+ return excelName;
+ }
+
+ /**
+ * 瀵煎叆鍒嗙被
+ *
+ * @param file1 鏂囦欢鐨勪俊鎭�
+ * @return 閿欒鏂囦欢鐨勫湴鍧�
+ */
+ @Override
+ public void importClassify(File file1) {
+ VciBaseUtil.alertNotNull(file1,"excel鏂囦欢");
+ if(!file1.exists()){
+ throw new VciBaseException("瀵煎叆鐨別xcel鏂囦欢涓嶅瓨鍦�,{0}",new String[]{file1.getPath()});
+ }
+ ReadExcelOption excelOption = new ReadExcelOption();
+ List<CodeClassifyPO> poList = null;
+ try{
+ poList = ExcelUtil.readDataObjectFromExcel(file1,CodeClassifyPO.class,excelOption,(value,po,fieldName)->{
+ po.setLcStatus(FrameworkDataLCStatus.getValueByText(po.getLcStatusText()));
+ if(StringUtils.isBlank(po.getLcStatusText())){
+ po.setLcStatus(FrameworkDataLCStatus.ENABLED.getValue());
+ }
+ });
+ }catch (Exception e){
+ if(logger.isErrorEnabled()){
+ logger.error("璇诲彇excel鍐呭鐨勬椂鍊欏嚭鐜颁簡閿欒",e);
+ }
+ throw new VciBaseException(LangBaseUtil.getErrorMsg(e),new String[]{},e);
+ }
+ //鍘婚櫎鏁磋閮芥槸绌虹殑鎯呭喌
+
+ if(CollectionUtils.isEmpty(poList)){
+ throw new VciBaseException(ExcelLangCodeConstant.IMPORT_CONTENT_NULL,new String[]{});
+ }
+
+ poList = poList.stream().filter(s->!(StringUtils.isBlank(s.getId()) && StringUtils.isBlank(s.getName()) && StringUtils.isBlank(s.getPath()))).collect(Collectors.toList());
+
+ List<CodeClassify> codeClassify = new ArrayList<>();
+ //鐪嬬湅璺緞鏄惁鏈夐噸澶�
+ Map<String/**璺緞**/, Long/**涓暟**/> pathCountMap = poList.stream().filter(s->StringUtils.isNotBlank(s.getPath())).collect(Collectors.groupingBy(s -> s.getPath(), Collectors.counting()));
+ List<String> repeatPaths = Optional.ofNullable(pathCountMap).orElse(new HashMap<>()).entrySet().stream().filter(entry -> entry.getValue() > 1).map(entry -> entry.getKey()).collect(Collectors.toList());
+ if(!CollectionUtils.isEmpty(repeatPaths)){
+ //鏈夐噸澶嶇殑鍐呭
+ List<String> rowIndexList = new ArrayList<>();
+ poList.stream().forEach(po->{
+ if(repeatPaths.contains(po.getPath())){
+ rowIndexList.add(po.getRowIndex());
+ }
+ });
+ throw new VciBaseException("璺緞鏈夐噸澶�,{0}",new String[]{rowIndexList.stream().collect(Collectors.joining(","))});
+ }
+ //缂栧彿鑾峰彇涓氬姟绫诲瀷鏈嶅姟
+ List<String> ruleOids = poList.stream().filter(
+ s -> StringUtils.isNotBlank(s.getCodeRuleId()))
+ .map(CodeClassifyPO::getCodeRuleId)
+ .collect(Collectors.toList());
+ Map<String, CodeRuleVO> ruleVOMap = Optional.ofNullable(ruleOids.size()==0 ? null:codeRuleService.listCodeRuleByIds(ruleOids,true)
+ ).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+
+ List<String> keyOids = poList.stream().filter(s -> StringUtils.isNotBlank(s.getKeyRepeatRuleId()))
+ .map(CodeClassifyPO::getKeyRepeatRuleId).collect(Collectors.toList());
+ Map<String,CodeKeyAttrRepeatRuleVO> keyRuleVOMap =Optional.ofNullable(keyOids.size()==0 ? null: iCodeKeyattrrepeatService.listCodeKeyAttrRepeatRuleByOids(keyOids)
+ ).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+
+ List<String> btmOids = poList.stream().filter(s -> StringUtils.isNotBlank(s.getBtmTypeId()))
+ .map(CodeClassifyPO::getBtmTypeId).collect(Collectors.toList());
+ Map<String, BtmTypeVO> btmVOMap = Optional
+ .ofNullable(btmOids.size()==0 ? null: btmTypeClient.selectByIdCollection(btmOids).getData())
+ .orElse(new ArrayList<BtmTypeVO>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+ // Map<String, CodeOsbtmtypeVO> btmVOMap = null;
+ Map<String/**璺緞**/,String/**涓婚敭**/> oidPathMap = new HashMap<>();
+
+ //鎴戜滑闇�瑕佹煡璇㈡墍鏈夊凡缁忓瓨鍦ㄧ殑鍒嗙被锛屼富瑕佹槸璺緞锛岀敤鏉ュ垽鏂垎绫荤殑鏁版嵁
+ List<CodeClassify> existClassifyDOs = codeClassifyMapper.selectAllLevelChildHasPath("",null,AuthUtil.getTenantId());
+ Map<String/**璺緞**/, CodeClassify/**宸茬粡瀛樺湪鐨勬暟鎹�**/> pathDOMap = Optional.ofNullable(existClassifyDOs).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> {
+ String path = s.getPath();
+ if(StringUtils.isNotBlank(path) && path.startsWith("#")){
+ return path.substring(1);
+ }
+ return path;
+ }, t -> t));
+ poList.stream().forEach(po->{
+ CodeClassify classify = new CodeClassify();
+ VciBaseUtil.alertNotNull(po.getId(),"鍒嗙被缂栧彿",po.getName(),"鍒嗙被鍚嶇О",po.getPath(),"鍒嗙被璺緞");
+ if(StringUtils.isNotBlank(po.getBtmTypeId()) && !btmVOMap.containsKey(po.getBtmTypeId().toLowerCase(Locale.ROOT))){
+ throw new VciBaseException("绗瑊0}琛岀殑涓氬姟绫诲瀷{1}鍦ㄧ郴缁熶腑涓嶅瓨鍦�",new String[]{String.valueOf(VciBaseUtil.getInt(po.getRowIndex())+1),po.getBtmTypeId()});
+ }
+ if(StringUtils.isNotBlank(po.getCodeRuleId()) && !ruleVOMap.containsKey(po.getCodeRuleId().toLowerCase(Locale.ROOT))){
+ throw new VciBaseException("绗瑊0}琛岀殑缂栫爜瑙勫垯{1}鍦ㄧ郴缁熶腑涓嶅瓨鍦�",new String[]{String.valueOf(po.getRowIndex()+1),po.getCodeRuleId()});
+ }
+ if(StringUtils.isNotBlank(po.getKeyRepeatRuleId()) && !keyRuleVOMap.containsKey(po.getKeyRepeatRuleId().toLowerCase(Locale.ROOT))){
+ throw new VciBaseException("绗瑊0}琛岀殑鍏抽敭灞炴�ф煡閲嶈鍒檣1}鍦ㄧ郴缁熶腑涓嶅瓨鍦�",new String[]{String.valueOf(po.getRowIndex()+1),po.getKeyRepeatRuleId()});
+ }
+ classify.setOid(VciBaseUtil.getPk());
+ classify.setId(po.getId());
+ classify.setName(po.getName());
+ classify.setDescription(po.getDescription());
+ oidPathMap.put(po.getPath(),classify.getOid());
+ if(StringUtils.isNotBlank(po.getBtmTypeId())){
+ BtmTypeVO typeVO = (BtmTypeVO)btmVOMap.get(po.getBtmTypeId().toLowerCase(Locale.ROOT));
+ classify.setBtmTypeId(typeVO.getId());
+ classify.setBtmTypeName(typeVO.getName());
+ }
+ if(StringUtils.isNotBlank(po.getCodeRuleId())){
+ CodeRuleVO codeRuleVO = ruleVOMap.get(po.getCodeRuleId().toLowerCase(Locale.ROOT));
+ classify.setCodeRuleOid(codeRuleVO.getOid());
+ }
+ if(StringUtils.isNotBlank(po.getKeyRepeatRuleId())){
+ CodeKeyAttrRepeatRuleVO repeatRuleVO = keyRuleVOMap.get(po.getKeyRepeatRuleId());
+ classify.setCodeKeyAttrRepeatOid(repeatRuleVO.getOid());
+ }
+ classify.setLcStatus(po.getLcStatus());
+ classify.setPath(po.getPath());
+ codeClassify.add(classify);
+ });
+ //瑕佺湅瀛樺湪鐨勶紝淇敼璺緞瀵瑰簲鐨勪富閿�
+ Map<String/**璺緞**/,String/**涓婚敭**/> catchedOidPathMap = new HashMap<>();
+ if(!CollectionUtils.isEmpty(oidPathMap)){
+ oidPathMap.forEach((path,oid)->{
+ if(pathDOMap.containsKey(path)){
+ //璇存槑瀛樺湪
+ catchedOidPathMap.put(path,pathDOMap.get(path).getOid());
+ }else{
+ catchedOidPathMap.put(path,oid);
+ }
+ });
+ }
+ List<CodeClassify> addClassifyDOList = new ArrayList<>();
+ List<CodeClassify> editClassifyDOList = new ArrayList<>();
+ codeClassify.stream().forEach(classifyDO->{
+
+ //瑕佺湅涓婄骇鏄笉鏄瓨鍦ㄥ摝
+ String parentPath = classifyDO.getPath();
+ if(parentPath.contains("#")) {
+ parentPath = parentPath.substring(0, parentPath.lastIndexOf("#"));
+ }
+ if((!catchedOidPathMap.containsKey(parentPath) && !pathDOMap.containsKey(parentPath) )&& !classifyDO.getPath().equalsIgnoreCase(classifyDO.getId())){
+ throw new VciBaseException("鍒嗙被缂栧彿[{0}],鍒嗙被鍚嶇О[{1}]锛岃矾寰勪负[{2}]鐨勪笂绾у垎绫诲湪绯荤粺涓紝鍦ㄦ湰娆″鍏ョ殑鏁版嵁鍜岀郴缁熶腑鍧囨病鏈夋壘鍒�",new String[]{classifyDO.getId(),classifyDO.getName(),classifyDO.getPath()});
+ }
+ if (!classifyDO.getPath().equalsIgnoreCase(classifyDO.getId())){
+ //涓嶆槸椤剁骇鐨勬椂鍊欙紝瑕佽缃笂绾х殑涓婚敭
+
+ classifyDO.setParentCodeClassifyOid(catchedOidPathMap.containsKey(parentPath)?catchedOidPathMap.get(parentPath):pathDOMap.get(parentPath).getOid());
+ }
+ if(classifyDO.getPath().equalsIgnoreCase(classifyDO.getId()) && StringUtils.isBlank(classifyDO.getBtmTypeId())){
+ throw new VciBaseException("鍒嗙被缂栧彿[{0}],鍒嗙被鍚嶇О[{1}]锛屾槸椤跺眰鍒嗙被锛岄渶瑕佽缃笟鍔＄被鍨嬬紪鍙�",new String[]{classifyDO.getId(),classifyDO.getName()});
+ }
+ if(pathDOMap.containsKey(classifyDO.getPath())){
+ //瀛樺湪锛岄渶瑕佷慨鏀瑰璞�
+ classifyDO.setOid(catchedOidPathMap.get(classifyDO.getPath()));
+ CodeClassify classifyDOInDB = pathDOMap.get(classifyDO.getPath());
+ classifyDOInDB.setOid(classifyDO.getOid());
+ classifyDOInDB.setId(classifyDO.getId());
+ classifyDOInDB.setName(classifyDO.getName());
+ classifyDOInDB.setDescription(classifyDO.getDescription());
+ classifyDOInDB.setBtmTypeId(classifyDO.getBtmTypeId());
+ classifyDOInDB.setBtmTypeName(classifyDO.getBtmTypeName());
+ classifyDOInDB.setCodeRuleOid(classifyDO.getCodeRuleOid());
+ classifyDOInDB.setCodeRuleOidName(classifyDO.getCodeRuleOidName());
+ classifyDOInDB.setParentCodeClassifyOid(classifyDO.getParentCodeClassifyOid());
+ classifyDOInDB.setCodeKeyAttrRepeatOid(classifyDO.getCodeKeyAttrRepeatOid());
+ classifyDOInDB.setCodeKeyAttrRepeatOidName(classifyDO.getCodeKeyAttrRepeatOidName());
+ if(classifyDOInDB.getOrderNum() == null){
+ classifyDOInDB.setOrderNum(0);
+ }
+ editClassifyDOList.add(classifyDOInDB);
+ }else{
+ //鏄柊鐨勶紝鐩存帴娣诲姞灏辫浜�
+ //鍒ゆ柇鍙锋�庝箞澶勭悊?
+ classifyDO.setOrderNum(0);
+ addClassifyDOList.add(classifyDO);
+ }
+ });
+ if(!CollectionUtils.isEmpty(editClassifyDOList)){
+ VciBaseUtil.switchCollectionForOracleIn(editClassifyDOList).stream().forEach(
+// classifyDOs->{codeClassifyMapper..updateById(classifyDOs.stream().collect(Collectors.toList()));
+ classifyDos->{
+ for (CodeClassify classifyDo : classifyDos) {
+ codeClassifyMapper.updateById(classifyDo);
+ }
+// }
+ });
+ }
+ if(!CollectionUtils.isEmpty(addClassifyDOList)){
+// revisionModelUtil.wrapperForBatchAdd(addClassifyDOList);
+ VciBaseUtil.switchCollectionForOracleIn(addClassifyDOList).stream().forEach(classifyDOs->{
+ for (CodeClassify classifyDO : classifyDOs) {
+ classifyDO.setCreateTime(new Date());
+ classifyDO.setTs(new Date());
+ classifyDO.setBtmname("codeclassify");
+ classifyDO.setLcStatus("Enabled");
+ classifyDO.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
+ // classifyDO.setCreator(String.valueOf(AuthUtil.getUser().getUserId()));
+ // classifyDO.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
+ classifyDO.setCreator(String.valueOf(AuthUtil.getUser().getAccount()));
+ classifyDO.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
+ classifyDO.setLastModifyTime(new Date());
+ codeClassifyMapper.insert(classifyDO);
+ }
+// codeClassifyMapper.batchInsert(classifyDOs.stream().collect(Collectors.toList()));
+ });
+ }
+
+ }
+
+ /**
+ * 鑾峰彇鍒嗙被鍏宠仈鐨勫睘鎬�
+ *
+ * @param baseQueryObject 鏌ヨ瀵硅薄锛屽繀椤绘湁codeClassifyOid锛屾敮鎸乮d鍜宯ame涓ょ鏌ヨ鏉′欢
+ * @return 灞炴�х殑淇℃伅锛屽寘鍚粯璁ょ殑灞炴��
+ */
+ @Override
+ public DataGrid<BtmTypeAttributeVO> listClassifyLinkAttr(BaseQueryObject baseQueryObject) throws ServiceException{
+ if(baseQueryObject == null){
+ baseQueryObject = new BaseQueryObject();
+ }
+ if(baseQueryObject.getConditionMap() == null){
+ baseQueryObject.setConditionMap(new HashMap<>());
+ }
+ String classifyOid = baseQueryObject.getConditionMap().getOrDefault("codeClassifyOid","");
+ String btmTypeOid = baseQueryObject.getConditionMap().getOrDefault("btmTypeOid","");
+ String id = baseQueryObject.getConditionMap().getOrDefault("id","");
+ String name = baseQueryObject.getConditionMap().getOrDefault("name","");
+ if(StringUtils.isBlank(classifyOid)){
+ return new DataGrid<>();
+ }
+ if(StringUtils.isBlank(btmTypeOid)){
+ return new DataGrid<>();
+ }
+ CodeClassifyVO topClassifyVO = getTopClassifyVO(classifyOid);
+ if(topClassifyVO == null || StringUtils.isBlank(topClassifyVO.getBtmTypeId())){
+ return new DataGrid<>();
+ }
+
+ Map<String,Object> condition = new HashMap<>(1);
+ condition.put("pkbtmtype",topClassifyVO.getBtmTypeId());
+ R<BtmTypeVO> btmTypeDetail = btmTypeClient.getDetail(btmTypeOid);
+ if(!btmTypeDetail.isSuccess()){
+ throw new ServiceException("涓氬姟绫诲瀷feign鎺ュ彛璋冪敤鍑洪敊");
+ }
+ List<BtmTypeAttributeVO> unDefaultAttributes = btmTypeDetail.getData().getAttributes();
+ // List<CodeOsbtmtypeattributeEntity> unDefaultAttributes = codeOsbtmtypeattributeMapper.selectByMap(condition);
+ // List<OsBtmTypeAttributeVO> unDefaultAttributes = btmService. (topClassifyVO.getBtmtypeid());
+ List<BtmTypeAttributeVO> attributeVOS = new ArrayList<>();
+ if(!CollectionUtils.isEmpty(unDefaultAttributes)){
+ unDefaultAttributes.stream().forEach(attr->{
+ BtmTypeAttributeVO attributeVO = new BtmTypeAttributeVO();
+ BeanUtils.copyProperties(attr,attributeVO);
+ attributeVO.setAttrDataType(attr.getAttrDataType());
+ attributeVO.setAttributeLength(attr.getAttributeLength());
+ attributeVO.setBtmTypeId(btmTypeDetail.getData().getId());
+ attributeVO.setBtmname(btmTypeDetail.getData().getName());
+ attributeVO.setAttrDataTypeText(EnumCache.getValue(EnumEnum.VCI_FIELD_TYPE,attr.getAttrDataType()));
+ boolean add = true;
+ if(StringUtils.isNotBlank(id) && !attributeVO.getId().contains(id.replace("*",""))){
+ add = false;
+ }
+ if(StringUtils.isNotBlank(name) && !attributeVO.getName().contains(name.replace("*",""))){
+ add = false;
+ }
+ if(add){
+ attributeVOS.add(attributeVO);
+ }
+ });
+ }
+ R<BtmTypeVO> btmTypeVOR = btmTypeClient.getDefaultAttrByBtmId(topClassifyVO.getBtmTypeId());
+ if(!btmTypeVOR.isSuccess()){
+ throw new ServiceException("涓氬姟绫诲瀷feign鎺ュ彛璋冪敤鍑洪敊");
+ }
+ List<BtmTypeAttributeVO> defaultAttrVOS = btmTypeVOR.getData().getAttributes();
+
+ // 鍙栦袱涓泦鍚堝樊闆�
+ List<String> ids = unDefaultAttributes.stream().map(BtmTypeAttributeVO::getId).collect(Collectors.toList());
+ defaultAttrVOS.forEach(item->{
+ if(!ids.contains(item.getId())){
+ BtmTypeAttributeVO attributeVO = new BtmTypeAttributeVO();
+ BeanUtils.copyProperties(item,attributeVO);
+ attributeVO.setAttrDataType(item.getAttrDataType());
+ attributeVO.setAttributeLength(item.getAttributeLength());
+ attributeVO.setBtmTypeId(btmTypeDetail.getData().getId());
+ attributeVO.setBtmname(btmTypeDetail.getData().getName());
+ attributeVO.setAttrDataTypeText(EnumCache.getValue(EnumEnum.VCI_FIELD_TYPE,item.getAttrDataType()));
+ boolean add = true;
+ if(StringUtils.isNotBlank(id) && !item.getId().contains(id.replace("*",""))){
+ add = false;
+ }
+ if(StringUtils.isNotBlank(name) && !item.getName().contains(name.replace("*",""))){
+ add = false;
+ }
+ if(add){
+ attributeVOS.add(attributeVO);
+ }
+ }
+ });
+
+ DataGrid<BtmTypeAttributeVO> dataGrid = new DataGrid<>();
+ dataGrid.setData(attributeVOS);
+ dataGrid.setTotal(attributeVOS.size());
+ return dataGrid;
+ }
+
+ /**
+ * 鑾峰彇褰撳墠鍒嗙被鐨勯《灞傚垎绫�
+ *
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @return 椤跺眰鍒嗙被鐨勪俊鎭�
+ */
+ @Override
+ public CodeClassifyVO getTopClassifyVO(String codeClassifyOid) {
+ VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+
+// List<Map<String,Object>> classifyDOS = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
+ List<CodeClassify> classifyDOS = selectAllLevelParentByOid(codeClassifyOid);
+
+ if(!CollectionUtils.isEmpty(classifyDOS)){
+ CodeClassify classifyDO = classifyDOS.stream().filter(s -> StringUtils.isBlank(s.getParentCodeClassifyOid())).findFirst().orElseGet(() -> null);
+ if(classifyDO!=null){
+ return codeClassifyDO2VO(classifyDO);
+ }
+ }
+ return null;
+ }
+
+ /**
+ * 鑾峰彇褰撳墠鍒嗙被鐨勬墍鏈変笂绾у垎绫伙紙鍚湰娆℃煡璇㈠眰绾у彿锛�
+ * @param oid 涓婚敭
+ * @return 鎵�鏈夌殑涓婄骇
+ */
+ @Override
+ public List<CodeClassify> selectAllLevelParentByOid(String oid){
+ // String sql = "select oid,level from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY) + " start with oid= :oid connect by prior PARENTCODECLASSIFYOID = oid ";
+ // Map< String,String> conditionMap = new HashMap< String,String>();
+ // conditionMap.put("oid",oid);
+
+ List<Map<String,Object>> cbos = codeClassifyMapper.selectAllLevelParentByOid(oid);
+ Map<String,String> oidLevelMap = new HashMap<>();
+ Optional.ofNullable(cbos).orElseGet(()->new ArrayList<>()).stream().forEach(cbo->{
+ // 鐢╧ey鍙杕ap鍊煎苟涓斾笉鍖哄垎澶у皬鍐�
+ oidLevelMap.put(cbo.getOrDefault("OID",cbo.get("oid")).toString(),cbo.get("LEVEL").toString());
+ });
+ if(CollectionUtils.isEmpty(oidLevelMap)){
+ return new ArrayList<>();
+ }
+
+ //浣跨敤涓婚敭鏌ヨ涓�涓�
+ String oids = "";
+ for (String s : oidLevelMap.keySet()) {
+ oids += "'"+s+"',";
+ }
+ List<CodeClassify> classifyDOS = codeClassifyMapper.selectClassifyByKeyAndReseRel(oids.substring(0,oids.length()-1));
+ if(!CollectionUtils.isEmpty(classifyDOS)){
+ classifyDOS.stream().forEach(classifyDO->{
+ classifyDO.setDataLevel(VciBaseUtil.getInt(oidLevelMap.getOrDefault(classifyDO.getOid(),"0")));
+ classifyDO.setLcStatusText(EnumCache.getValue("codeLcstatus",classifyDO.getLcStatus()));
+ });
+ }
+ return classifyDOS;
+ }
+
+ /**
+ * 涓婚敭鑾峰彇涓婚搴撳垎绫�
+ * @param oid 涓婚敭
+ * @return 涓婚搴撳垎绫绘樉绀哄璞�
+ * @throws VciBaseException 鍙傛暟涓虹┖锛屾暟鎹笉瀛樺湪鏃朵細鎶涘嚭寮傚父
+ */
+ @Override
+ public CodeClassifyVO getObjectByOid(String oid) throws VciBaseException{
+ return codeClassifyDO2VO(selectByOid(oid));
+ }
+
+ /**
+ * 浣跨敤缂栧彿鐨勮矾寰勮幏鍙栧璞�
+ *
+ * @param idPath 缂栧彿鐨勮矾寰勶紝涓�瀹氳浠庢渶椤跺眰鑺傜偣寮�濮嬶紝鏍煎紡涓簒xx/yyy/zz 杩欐牱
+ * @return 鍒嗙被鐨勬樉绀哄璞�
+ */
+ @Override
+ public CodeClassifyVO getObjectByIdPath(String idPath) {
+ List<Map<String, Object>> idPathValues = codeClassifyMapper.selectByFieldPath("#" + idPath);
+ CodeClassify classifyDO = null;
+ if (idPathValues != null){
+ classifyDO = codeClassifyMapper.selectByIdRel(idPathValues.get(0).get("OID").toString());
+ }
+ return codeClassifyDO2VO(classifyDO);
+ }
+
+ /**
+ * 涓婚搴撶殑鏍�,宸茶仈璋冧笟鍔＄被鍨嬫煡璇eign
+ * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+ * @return 涓婚搴撴樉绀烘爲
+ */
+ @Override
+ public List<Tree> treeTopCodeClassify(TreeQueryObject treeQueryObject) {
+ if(treeQueryObject == null){
+ treeQueryObject = new TreeQueryObject();
+ }
+ if(treeQueryObject.getConditionMap() == null){
+ treeQueryObject.setConditionMap(new HashMap<String,String>());
+ }
+ treeQueryObject.getConditionMap().put(PARENT_FIELD_NAME, "=null");
+ List<Tree> trees = treeCodeClassify(treeQueryObject);
+ treeQueryObject.getConditionMap().put("domain", AppConstant.APPLICATION_NAME_CODE);
+ BaseQueryObject baseQueryObject = new BaseQueryObject();
+ baseQueryObject.setConditionMap(treeQueryObject.getConditionMap());
+ List<BtmTypeVO> btmTypeVOS = btmTypeClient.getRef(baseQueryObject).getData();
+ if(Func.isEmpty(btmTypeVOS) || Func.isEmpty(trees)){
+ return null;
+ }
+ List<Tree> treeList = trees.stream().filter(tree -> !CollectionUtils.isEmpty(btmTypeVOS.stream().filter(btmType -> {
+ if(Objects.equals(tree.getAttributes().get("btmTypeId"), btmType.getId())){
+ tree.getAttributes().put("btmTypeOid",btmType.getOid());
+ return true;
+ }
+ return false;
+ }).collect(Collectors.toList())))
+ .collect(Collectors.toList());
+ return treeList;
+ }
+
+ /**
+ * 鑾峰彇杩欎釜鍒嗙被涓嬬殑涓氬姟绫诲瀷锛屽綋鍓嶆病鏈夊氨鑾峰彇涓婄骇鐨勭涓�涓笟鍔＄被鍨�
+ * @param oid 褰撳墠鍒嗙被鐨刼id
+ * @return oid,id,name,btmtypeid,btmtypename锛屾病鏈夊氨杩斿洖null
+ */
+ @Override
+ public CodeClassify selectBtmOrParentBtm(String oid){
+ List<CodeClassify> oidList = selectAllLevelParents(oid);
+ return oidList.size()==0?null:oidList.get(0);
+ }
+
+ /**
+ * 鑾峰彇鎵�鏈夊眰绾т笂绾у叧鑱斾笟鍔＄被鍨嬫暟鎹�
+ * @param oid 褰撳墠鍒嗙被鐨刼id
+ * @return oid,id,name,btmtypeid,btmtypename
+ */
+ @Override
+ public List<CodeClassify> selectAllLevelParents(String oid){
+// String sql = "select oid,id,name,btmtypeid,btmtypename from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY) + " where btmtypeid is not null start with oid= :oid connect by prior PARENTCODECLASSIFYOID=oid ";
+// Map< String,String> conditionMap = new HashMap< String,String>();
+// conditionMap.put("oid",oid);
+// List<Map> dataList = boService.queryBySqlForMap(sql,conditionMap);
+ List<Map<String, Object>> dataList = codeClassifyMapper.selectAllLevelParents(oid);
+ List<CodeClassify> oidList = new ArrayList<CodeClassify>();
+ if(!CollectionUtils.isEmpty(dataList)){
+ for(Map data:dataList){
+ CodeClassify codeClassifyDO = new CodeClassify();
+ codeClassifyDO.setOid(VciBaseUtil.getStringValueFromObject(data.get("OID")));
+ codeClassifyDO.setId(VciBaseUtil.getStringValueFromObject(data.get("ID")));
+ codeClassifyDO.setName(VciBaseUtil.getStringValueFromObject(data.get("NAME")));
+ codeClassifyDO.setBtmTypeId(VciBaseUtil.getStringValueFromObject(data.get("BTMTYPEID")));
+ codeClassifyDO.setBtmTypeName(VciBaseUtil.getStringValueFromObject(data.get("BTMTYPENAME")));
+ oidList.add(codeClassifyDO);
+ }
+ }
+ return oidList;
+ }
+
+ /**
+ * 浣跨敤鍒嗙被涓婚敭鑾峰彇鍒嗙被鐩稿叧鐨勬墍鏈変俊鎭�
+ *
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @return 鍒嗙被涓婄骇锛屼笅绾х殑淇℃伅
+ */
+ @Override
+ public CodeClassifyFullInfoBO getClassifyFullInfo(String codeClassifyOid) {
+ VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+ CodeClassifyFullInfoBO fullInfo = new CodeClassifyFullInfoBO();
+ CodeClassify classifyDO = selectByOidRel(codeClassifyOid);
+ //鏌ヨ涓婄骇
+ fullInfo.setCurrentClassifyVO(codeClassifyDO2VO(classifyDO));
+// List<Map<String, Object>> maps = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
+// List<Map<String, Object>> maps = selectAllLevelParentByOid(codeClassifyOid);
+ List<CodeClassify> codeClassifyList = selectAllLevelParentByOid(codeClassifyOid);
+// for (Map<String, Object> map : maps) {
+// CodeClassify codeClassify = new CodeClassify();
+// codeClassify.setOid(String.valueOf(map.get("OID")));
+// codeClassify.setDataLevel((Integer) map.get("LEVEL"));
+// codeClassifyList.add(codeClassify);
+// }
+
+ fullInfo.setParentClassifyVOs(codeClassifyDO2VOs(codeClassifyList));
+ if(!CollectionUtils.isEmpty(fullInfo.getParentClassifyVOs())){
+ fullInfo.setTopClassifyVO(fullInfo.getParentClassifyVOs().stream().filter(s->StringUtils.isBlank(s.getParentCodeClassifyOid())).findFirst().orElseGet(()->null));
+ }
+ return fullInfo;
+ }
+
+ /**
+ * 缁熻瀛愯妭鐐圭殑涓暟
+ *
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @return 涓暟
+ */
+ @Override
+ public int countChildrenByClassifyOid(String codeClassifyOid) {
+// Map<String,String> conditionMap = new HashMap<>();
+// conditionMap.put("parentCodeClassifyOid",codeClassifyOid);
+ QueryWrapper<CodeClassify> wrapper = new QueryWrapper<>();
+ wrapper.eq("parentCodeClassifyOid",codeClassifyOid);
+ return codeClassifyMapper.selectCount(wrapper).intValue();
+ }
+
+
+
+}
--
Gitblit v1.9.3