From 7f0570d20aac189f1b170942bd7100b281a1c824 Mon Sep 17 00:00:00 2001
From: ludc
Date: 星期三, 26 四月 2023 00:07:37 +0800
Subject: [PATCH] 代码整合，新增codefixedcontroller
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java | 1852 +++++++++++++++++++++++++++++------------------------------
1 files changed, 908 insertions(+), 944 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
index d67c98a..6547785 100644
--- 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
@@ -1,46 +1,54 @@
package com.vci.ubcs.code.service.impl;
-import com.vci.ubcs.code.dao.CodeClassifyDaoI;
-import com.vci.ubcs.code.dao.CodeClassifyTemplateDaoI;
-import com.vci.ubcs.code.model.CodeClassifyDO;
-import com.vci.ubcs.code.model.CodeClassifyTemplateDO;
-import com.vci.ubcs.code.service.CodeClassifyServiceI;
-import com.vci.ubcs.code.service.CodeDuckingServiceI;
-import com.vci.ubcs.code.service.CodeKeyAttrRepeatRuleServiceI;
-import com.vci.ubcs.code.service.CodeRuleServiceI;
-import com.vci.frameworkcore.lcstatuspck.FrameworkDataLCStatus;
-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.revision.bo.TreeWrapperOptions;
-import com.vci.starter.revision.service.RevisionModelUtil;
-import com.vci.starter.web.constant.QueryOptionConstant;
-import com.vci.starter.web.exception.VciBaseException;
-import com.vci.starter.web.pagemodel.*;
-import com.vci.starter.web.util.*;
-import com.vci.starter.web.wrapper.VciParentQueryOption;
-import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
-import com.vci.web.pageModel.BatchCBO;
-import com.vci.web.pageModel.OsAttributeVO;
-import com.vci.web.pageModel.OsBtmTypeAttributeVO;
-import com.vci.web.pageModel.OsBtmTypeVO;
-import com.vci.web.service.OsAttributeServiceI;
-import com.vci.web.service.OsBtmServiceI;
-import com.vci.web.service.WebBoServiceI;
-import org.apache.commons.lang.StringUtils;
-import org.apache.poi.hssf.util.HSSFColor;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
-import com.vci.ubcs.code.dto.CodeClassifyDTO;
+import com.alibaba.nacos.common.utils.StringUtils;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
+import com.vci.ubcs.starter.revision.model.TreeQueryObject;
+import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
+import com.vci.ubcs.code.entity.CodeClassify;
+import com.vci.ubcs.code.entity.CodeClstemplateEntity;
+import com.vci.ubcs.code.entity.CodeOsbtmtypeEntity;
+import com.vci.ubcs.code.entity.CodeOsbtmtypeattributeEntity;
+import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
+import com.vci.ubcs.code.mapper.CodeClassifyMapper;
+import com.vci.ubcs.code.mapper.CodeClstemplateMapper;
+import com.vci.ubcs.code.mapper.CodeOsbtmtypeMapper;
+import com.vci.ubcs.code.mapper.CodeOsbtmtypeattributeMapper;
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.CodeOsattributeVO;
+import com.vci.ubcs.code.vo.CodeOsbtmtypeVO;
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 org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
+import com.vci.ubcs.starter.revision.model.TreeQueryObject;
+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.service.RevisionModelUtil;
+import com.vci.ubcs.starter.util.LocalFileUtil;
+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 org.springblade.core.log.exception.ServiceException;
+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.mp.support.Condition;
+import org.springblade.core.secure.utils.AuthUtil;
+import org.springblade.core.tool.api.R;
+import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
@@ -49,976 +57,932 @@
import java.util.*;
import java.util.stream.Collectors;
-import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.*;
-import static com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant.*;
+import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
-/**
- * 涓婚搴撳垎绫绘湇鍔�
- * @author weidy
- * @date 2022-01-20
- */
@Service
-public class CodeClassifyServiceImpl implements CodeClassifyServiceI {
+public class CodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {
- /**
- * 鏃ュ織
- */
- private Logger logger = LoggerFactory.getLogger(getClass());
+ @Resource
+ private CodeClassifyMapper codeClassifyMapper;
- /**
- * 鏁版嵁鎿嶄綔灞�
- */
- @Resource
- private CodeClassifyDaoI codeClassifyMapper;
+ @Resource
+ private CodeClstemplateMapper codeClstemplateMapper;
- /**
- * 涓氬姟绫诲瀷鎿嶄綔鐨勬湇鍔�
- */
- @Autowired
- @Lazy
- private WebBoServiceI boService;
+ @Resource
+ private ICodeRuleService codeRuleService;
- /**
- * 瀵硅薄鐨勬搷浣�
- */
- @Autowired
- private RevisionModelUtil revisionModelUtil;
+ @Resource
+ private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
+ @Resource
+ CodeOsbtmtypeattributeMapper codeOsbtmtypeattributeMapper;
- /**
- * 瑙勫垯鐨勬湇鍔�
- */
- @Autowired
- private CodeRuleServiceI codeRuleService;
+ /**
+ * 鏃ュ織
+ */
+ private Logger logger = LoggerFactory.getLogger(getClass());
+ /**
+ * 瀵硅薄鐨勬搷浣�
+ */
+ @Resource
+ private RevisionModelUtil revisionModelUtil;
- /**
- * 鍏抽敭灞炴�х殑鏈嶅姟
- */
- @Autowired
- private CodeKeyAttrRepeatRuleServiceI keyAttrRepeatRuleService;
+ @Resource
+ private ICodeKeyattrrepeatService iCodeKeyattrrepeatService;
+ /**
+ * 涓婄骇鑺傜偣鐨勫睘鎬у悕绉�
+ */
+ public static final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
+ /**
+ * 浣跨敤鏌ヨ灏佽鍣ㄦ潵鏌ヨ
+ * @param wrapper 鏌ヨ灏佽鍣�
+ * @return 鏁版嵁瀵硅薄
+ */
+ @Override
+ public List<CodeClassify> selectByWrapper(Wrapper wrapper) {
+ return codeClassifyMapper.selectList(wrapper);
+ }
- /**
- * 鏁版嵁闆嗘垚
- */
- @Autowired
- private CodeDuckingServiceI codeDuckingServiceI;
+ @Override
+ public IPage<CodeClassifyVO> selectPlCodeClassifyPage(IPage<CodeClassifyVO> page, CodeClassifyVO plCodeClassify) {
+ return page.setRecords(codeClassifyMapper.selectPlCodeClassifyPage(page, plCodeClassify));
+ }
- /**
- * 涓氬姟绫诲瀷鐨勬湇鍔�
- */
- @Autowired
- private OsBtmServiceI btmService;
+ @Override
+ public R addSave(CodeClassify codeClassifyEntity) {
- /**
- * 灞炴�ф湇鍔�
- */
- @Autowired
- private OsAttributeServiceI attributeService;
+ if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
+ return R.fail("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
+ }
+ codeClassifyEntity.setCreator(AuthUtil.getUser().getUserName());
+ codeClassifyEntity.setCreateTime(new Date());
+ codeClassifyEntity.setTs(new Date());
+ codeClassifyEntity.setOwner(AuthUtil.getUser().getUserName());
+ codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
+ codeClassifyEntity.setLastModifyTime(new Date());
+ codeClassifyEntity.setRevisionSeq(1);
+ codeClassifyEntity.setVersionSeq(1);
+ int insertNumber = codeClassifyMapper.insert(codeClassifyEntity);
+ return R.status(SqlHelper.retBool(insertNumber));
+ }
- /**
- * 鏁版嵁鎿嶄綔灞�
- */
- @Resource
- private CodeClassifyTemplateDaoI codeClassifyTemplateMapper;
+ /**
+ * 淇敼涓婚搴撳垎绫�
+ * @param codeClassifyEntity 涓婚搴撳垎绫绘暟鎹紶杈撳璞�
+ * @return 鎵ц缁撴灉
+ */
+ @Override
+ public R editSave(CodeClassify codeClassifyEntity) {
+ if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
+ return R.fail("浼犲叆鏁版嵁涓嶈兘涓虹┖锛�");
+ }
+ //妫�鏌s
+ Map<String,Object> condition = new HashMap<>(2);
+ condition.put("oid",codeClassifyEntity.getOid());
+ condition.put("ts",codeClassifyEntity.getTs());
+ CodeClassify detail = codeClassifyMapper
+ .selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
+ if(detail == null){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
+ return R.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+ }
- /**
- * 涓婄骇鑺傜偣鐨勫睘鎬у悕绉�
- */
- public static final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
- /**
- * 鏌ヨ涓婚搴撳垎绫� 鏍�
- * @param treeQueryObject 鏍戞煡璇㈠璞�
- * @return 涓婚搴撳垎绫� 鏄剧ず鏍�
- * @throws VciBaseException 鏌ヨ鏉′欢涓嶇鍚堣姹傜殑鏃跺�欎細鎶涘嚭寮傚父
- */
- @Override
- public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) throws VciBaseException {
- List<CodeClassifyDO> doList =selectCodeClassifyDOByTree(treeQueryObject);
- List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
- TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME.toLowerCase(Locale.ROOT));
- 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;
- }
-
- /**
- * 涓婚搴撶殑鏍�
- *
- * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
- * @return 涓婚搴撴樉绀烘爲
- */
- @Override
- public List<Tree> treeTopCodeClassify(TreeQueryObject treeQueryObject) {
- if(treeQueryObject == null){
- treeQueryObject = new TreeQueryObject();
- }
- if(treeQueryObject.getConditionMap() == null){
- treeQueryObject.setConditionMap(new HashMap<>());
- }
- treeQueryObject.getConditionMap().put(PARENT_FIELD_NAME, QueryOptionConstant.ISNULL);
- return treeCodeClassify(treeQueryObject);
- }
-
- /**
- * 鏍规嵁鏍戝舰鏌ヨ瀵硅薄鏉ユ煡璇㈡暟鎹璞�
- *
- * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
- * @return 鏌ヨ缁撴灉,鏁版嵁瀵硅薄
- */
- @Override
- public List<CodeClassifyDO> 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 codeClassifyDOs 鏁版嵁瀵硅薄鍒楄〃
- * @return 鏄剧ず瀵硅薄
- * @throws VciBaseException 鍙傛暟涓虹┖鎴栬�呬笉瀛樺湪鐨勬椂鍊欎細鎶涘嚭寮傚父
- */
- @Override
- public List<CodeClassifyVO> codeClassifyDO2VOs(Collection<CodeClassifyDO> codeClassifyDOs) throws VciBaseException{
- List<CodeClassifyVO> voList = new ArrayList<CodeClassifyVO>();
- if(!CollectionUtils.isEmpty(codeClassifyDOs)){
- for(CodeClassifyDO s: codeClassifyDOs){
- CodeClassifyVO vo = codeClassifyDO2VO(s);
- if(vo != null){
- voList.add(vo);
- }
- }
- }
- return voList;
- }
-
- /**
- * 鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
- * @param codeClassifyDO 鏁版嵁瀵硅薄
- * @return 鏄剧ず瀵硅薄
- * @throws VciBaseException 鎷疯礉灞炴�у嚭閿欑殑鏃跺�欎細鎶涘嚭寮傚父
- */
- @Override
- public CodeClassifyVO codeClassifyDO2VO(CodeClassifyDO codeClassifyDO) throws VciBaseException{
- CodeClassifyVO vo = new CodeClassifyVO();
- if(codeClassifyDO != null){
- BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDO,vo);
- //濡傛灉鏈塴cstatus鐨勭被鐨勮瘽
- vo.setLcStatusText(FrameworkDataLCStatus.getTextByValue(vo.getLcStatus()));
- }
- return vo;
- }
-
- /**
- * 澧炲姞涓婚搴撳垎绫�
- * @param codeClassifyDTO 涓婚搴撳垎绫绘暟鎹紶杈撳璞�
- * @return 鎵ц缁撴灉
- * @throws VciBaseException 鍙傛暟涓虹┖锛屽敮涓�椤癸紝蹇呰緭椤逛笉閫氳繃鏃朵細鎶涘嚭寮傚父
- */
- @Override
- public CodeClassifyVO addSave(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
- VciBaseUtil.alertNotNull(codeClassifyDTO,"闇�瑕佹坊鍔犵殑鏁版嵁瀵硅薄");
- //灏咲TO杞崲涓篋O
- CodeClassifyDO codeClassifyDO = new CodeClassifyDO();
- BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,codeClassifyDO);
- if(StringUtils.isNotBlank(codeClassifyDO.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyDO.getBtmTypeId())){
- throw new VciBaseException("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
- }
- BatchCBO cbo_insert = codeClassifyMapper.insert(codeClassifyDO);
-
-// //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊
-// ClientBusinessObject[] clientBusinessObjects = cbo_insert.getCreateCboArray();
-// if(clientBusinessObjects.length!=0);
-// {
-// codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_ADD,FRAMEWORK_DATA_ENABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO.getOid(), DateUtils.addHours(new Date(),1));
-// }
-
- return codeClassifyDO2VO(codeClassifyDO);
- }
-
- /**
- * 淇敼涓婚搴撳垎绫�
- * @param codeClassifyDTO 涓婚搴撳垎绫绘暟鎹紶杈撳璞�
- * @return 鎵ц缁撴灉
- * @throws VciBaseException 鍙傛暟涓虹┖锛屽敮涓�椤癸紝蹇呰緭椤逛笉閫氳繃鏃朵細鎶涘嚭寮傚父
- */
- @Override
- public BaseResult editSave(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
- VciBaseUtil.alertNotNull(codeClassifyDTO,"鏁版嵁瀵硅薄",codeClassifyDTO.getOid(),"涓婚搴撳垎绫讳富閿�");
-
- //妫�鏌s
- CodeClassifyDO codeClassifyDOCopyFromDTO = new CodeClassifyDO();
- BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,codeClassifyDOCopyFromDTO);
- boolean tsBoolean = boService.checkTs(codeClassifyDOCopyFromDTO);
- if(!tsBoolean){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
- return BaseResult.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
- }
-
- //灏咲TO杞崲涓篋O
- CodeClassifyDO codeClassifyDO = selectByOid(codeClassifyDTO.getOid());
- revisionModelUtil.copyFromDTOIgnore(codeClassifyDTO,codeClassifyDO);
- if(StringUtils.isNotBlank(codeClassifyDO.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyDO.getBtmTypeId())){
- throw new VciBaseException("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
- }
- codeClassifyMapper.updateByPrimaryKey(codeClassifyDO);
+ if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
+ return R.fail("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
+ }
+ codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
+ codeClassifyEntity.setLastModifyTime(new Date());
+ int insertNumber = codeClassifyMapper.updateById(codeClassifyEntity);
// //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆傚彧鏈夊惎鐢ㄧ姸鎬佺殑鍒嗙被鎵嶆帹閫�
// 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(insertNumber));
+// return BaseResult.success(codeClassifyDO2VO(codeClassifyDO));
+ }
- return BaseResult.success(codeClassifyDO2VO(codeClassifyDO));
- }
+ /**
+ * 妫�鏌� 涓婚搴撳垎绫绘槸鍚﹀垹闄�
+ * @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 codeClassifyDTO 涓婚搴撳垎绫绘暟鎹紶杈撳璞★紝蹇呴』瑕佹湁oid鍜宼s灞炴��
- * @return 鎵ц缁撴灉 success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
- * @throws VciBaseException 鍙傛暟涓虹┖锛岃寮曠敤鏃舵姏鍑哄紓甯�
- */
-@Override
-public BaseResult checkIsCanDelete(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
- VciBaseUtil.alertNotNull(codeClassifyDTO,"鏁版嵁浼犺緭瀵硅薄",codeClassifyDTO.getOid(),"涓婚敭");
- CodeClassifyDO codeClassifyDO = selectByOid(codeClassifyDTO.getOid());
- return checkIsCanDeleteForDO(codeClassifyDTO,codeClassifyDO);
-}
+ /**
+ * 涓婚敭鏌ヨ鏁版嵁瀵硅薄
+ * @param oid 涓婚敭
+ * @return 鏁版嵁瀵硅薄
+ */
+ private CodeClassify selectByOid(String oid){
- /**
- * 鏍￠獙鏄惁鍙互鍒犻櫎锛屽鏋滃瓨鍦ㄤ笅绾э紝骞朵笖涓嬬骇鏈夋暟鎹紩鐢ㄥ垯涓嶈兘鍒犻櫎
- * @param codeClassifyDTO 鏁版嵁浼犺緭瀵硅薄
- * @param codeClassifyDO 鏁版嵁搴撲腑鐨勬暟鎹璞�
- * @return success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
- */
- private BaseResult checkIsCanDeleteForDO(CodeClassifyDTO codeClassifyDTO, CodeClassifyDO codeClassifyDO) {
- CodeClassifyDO tsDO = new CodeClassifyDO();
- BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,tsDO);
- boService.checkTs(tsDO);
- //鏍￠獙涓嬬骇鏄惁鏈夊紩鐢�
- if(checkChildIsLinked(codeClassifyDO.getOid())){
- return BaseResult.fail(DATA_CASCADE_LINKED_NOT_DELETE,new String[]{""});
- }
- return BaseResult.success(checkHasChild(codeClassifyDO.getOid()));
- }
- /**
- * 妫�鏌ユ槸鍚︽湁涓嬬骇鏄惁鍏宠仈浜嗘暟鎹�
- *
- * @param oid 涓婚敭
- * @return true 琛ㄧず鏈夊紩鐢紝false琛ㄧず娌℃湁寮曠敤
- * @throws VciBaseException 鍙傛暟涓虹┖鍜屾湁寮曠敤鐨勬椂鍊欎細鎶涘嚭寮傚父
- */
- @Override
- public boolean checkChildIsLinked(String oid) throws VciBaseException {
- VciBaseUtil.alertNotNull(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;
- }
+ CodeClassify codeClassifyEntity = codeClassifyMapper.selectById(oid.trim());
+ if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
+ throw new ServiceException("dataOidNotExist");//鏍规嵁涓婚敭id鏈煡鍒扮浉鍏虫暟鎹�
+ }
+ return codeClassifyEntity;
+ }
- /**
- * 鏍￠獙鏄惁鏈変笅绾ц妭鐐癸紝涓嶆牎楠屾槸鍚﹀叧鑱斾簡鏁版嵁
- *
- * @param oid 涓婚敭
- * @return true琛ㄧず鏈変笅绾э紝false琛ㄧず娌℃湁涓嬬骇
- * @throws VciBaseException 鍙傛暟閿欒锛屾垨鑰呮暟鎹笉瀛樺湪鐨勬椂鍊欎細鎶涘嚭寮傚父
- */
- @Override
- public boolean checkHasChild(String oid) throws VciBaseException {
- VciBaseUtil.alertNotNull(oid,"涓婚敭");
- return codeClassifyMapper.checkHasChild(oid.trim());
- }
+ /**
+ * 鏍￠獙鏄惁鍙互鍒犻櫎锛屽鏋滃瓨鍦ㄤ笅绾э紝骞朵笖涓嬬骇鏈夋暟鎹紩鐢ㄥ垯涓嶈兘鍒犻櫎
+ * @param codeClassifyEntity 鏁版嵁搴撲腑鐨勬暟鎹璞�
+ * @return success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
+ */
+ private R checkIsCanDeleteForDO(CodeClassify codeClassifyEntity) {
- /**
- * 鏍￠獙鏄惁琚紩鐢�
- * @param oid 涓婚敭
- * @throws VciBaseException 琚紩鐢ㄧ殑鏃跺�欎細鎶涘嚭寮傚父
- */
- private boolean checkIsLinked(String oid) throws VciBaseException{
- //TODO 娣诲姞闇�瑕佹牎楠屽紩鐢ㄧ殑鍦版柟
- return false;
- }
+ //妫�鏌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("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+// return R.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+ }
+ //鏍￠獙涓嬬骇鏄惁鏈夊紩鐢�
+ if(checkChildIsLinked(detail.getOid())){
+ return R.fail("dataCascadeLinkedNotDelete");
+ }
+ return R.data(checkHasChild(detail.getOid()));
+ }
- /**
- * 鍒犻櫎涓婚搴撳垎绫�
- * @param codeClassifyDTO 涓婚搴撳垎绫绘暟鎹紶杈撳璞★紝oid鍜宼s闇�瑕佷紶杈�
- * @return 鍒犻櫎缁撴灉鍙嶉锛氾細success锛氭垚鍔燂紝fail锛氬け璐�
- * @throws VciBaseException 鍙傛暟涓虹┖锛岃寮曠敤鏃舵姏鍑哄紓甯�
- */
- @Override
- public BaseResult deleteCodeClassify(CodeClassifyDTO codeClassifyDTO) throws VciBaseException{
- VciBaseUtil.alertNotNull(codeClassifyDTO,"涓婚搴撳垎绫绘暟鎹璞�",codeClassifyDTO.getOid(),"涓婚搴撳垎绫荤殑涓婚敭");
- CodeClassifyDO codeClassifyDO = selectByOid(codeClassifyDTO.getOid());
- BaseResult baseResult = checkIsCanDeleteForDO(codeClassifyDTO,codeClassifyDO);
+ /**
+ * 妫�鏌ユ槸鍚︽湁涓嬬骇鏄惁鍏宠仈浜嗘暟鎹�
+ *
+ * @param oid 涓婚敭
+ * @return true 琛ㄧず鏈夊紩鐢紝false琛ㄧず娌℃湁寮曠敤
+ */
+ @Override
+ public boolean checkChildIsLinked(String oid) {
- //鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
- VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateDO.class);
- queryWrapper.addQueryMap("codeClassifyOid",codeClassifyDTO.getOid());
- List<CodeClassifyTemplateDO> codeClassifyTemplateDOListHaveTemplate = codeClassifyTemplateMapper.selectByWrapper(queryWrapper);
- if(codeClassifyTemplateDOListHaveTemplate.size()>0){
- return BaseResult.fail("鍒嗙被鍏宠仈妯℃澘锛岃鍏堝垹闄�!");
- }
+ 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;
+ }
- //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
- //1銆佹煡璇㈣鍒犻櫎鐨勭埗绫绘暟鎹�
- List<CodeClassifyDO> deletes = new ArrayList<CodeClassifyDO>();
- deletes.add(codeClassifyDO);
+ /**
+ * 鏍￠獙鏄惁琚紩鐢�
+ * @param oid 涓婚敭
+ */
+ private boolean checkIsLinked(String oid) {
+ //TODO 娣诲姞闇�瑕佹牎楠屽紩鐢ㄧ殑鍦版柟
+ return false;
+ }
- if(baseResult.isSuccess()) {
- //鎵句笅绾х殑锛岃繖涓槸鍙互鍒犻櫎鐨勬椂鍊�
- Map<String,String> childrenOids = codeClassifyMapper.selectAllLevelChildOid(codeClassifyDO.getOid().trim());
- if (!CollectionUtils.isEmpty(childrenOids)) {
- Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids.keySet());
- for(Collection<String> s : childrenCollections){
-
- //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
- //2銆佹煡璇㈣鍒犻櫎鐨勫瓙绫绘暟鎹�
- List<CodeClassifyDO> codeClassifyDOList = codeClassifyMapper.selectByPrimaryKeyCollection(s);
- deletes.addAll(codeClassifyDOList);
-
- codeClassifyMapper.batchDeleteByOids(s);
- }
-
- }
- }else{
- return baseResult;
- }
-
- //鎵ц鍒犻櫎鎿嶄綔
- BatchCBO batchCBO = codeClassifyMapper.deleteByPrimaryKey(codeClassifyDO.getOid());
-
- //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�
- for (CodeClassifyDO codeClassifyDO1:deletes){
- //codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_DELETE,FRAMEWORK_DATA_DISABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO1.getOid(), DateUtils.addHours(new Date(),1));//杩欓噷鏄綋鍓嶆椂闂�
-
- //瀛樺偍瑕佸垹闄ょ殑鏁版嵁
- codeDuckingServiceI.cacheDeleteData(codeClassifyDO1.getOid(), codeClassifyDO1);
- }
- return (batchCBO!=null && batchCBO.getDeleteCbos() !=null &&batchCBO.getDeleteCbos().size() > 0)?BaseResult.successMsg(DELETE_SUCCESS):BaseResult.fail(DELETE_FAIL);
- }
-
- /**
- * 涓婚敭鑾峰彇涓婚搴撳垎绫�
- * @param oid 涓婚敭
- * @return 涓婚搴撳垎绫绘樉绀哄璞�
- * @throws VciBaseException 鍙傛暟涓虹┖锛屾暟鎹笉瀛樺湪鏃朵細鎶涘嚭寮傚父
- */
- @Override
- public CodeClassifyVO getObjectByOid(String oid) throws VciBaseException{
- return codeClassifyDO2VO(selectByOid(oid));
- }
-
- /**
- * 涓婚敭鏌ヨ鏁版嵁瀵硅薄
- * @param oid 涓婚敭
- * @return 鏁版嵁瀵硅薄
- * @throws VciBaseException 鍙傛暟涓虹┖锛屽苟涓旀暟鎹笉瀛樺湪鐨勬椂鍊欎細鎶涘嚭寮傚父
- */
- private CodeClassifyDO selectByOid(String oid) throws VciBaseException{
- VciBaseUtil.alertNotNull(oid,"涓婚敭");
- CodeClassifyDO codeClassifyDO = codeClassifyMapper.selectByPrimaryKey(oid.trim());
- if(codeClassifyDO == null || StringUtils.isBlank(codeClassifyDO.getOid())){
- throw new VciBaseException(DATA_OID_NOT_EXIST);
- }
- return codeClassifyDO;
- }
-
- /**
- * 涓婚敭鎵归噺鑾峰彇涓婚搴撳垎绫�
- * @param oidCollections 涓婚敭闆嗗悎锛屼絾鏄彈鎬ц兘褰卞搷锛屽缓璁竴娆℃煡璇笉瓒呰繃10000涓�
- * @return 涓婚搴撳垎绫绘樉绀哄璞�
- * @throws VciBaseException 鏌ヨ鍑虹幇寮傚父鏃朵細鎶涘嚭
- */
- @Override
- public Collection<CodeClassifyVO> listCodeClassifyByOids(Collection<String> oidCollections) throws VciBaseException{
- VciBaseUtil.alertNotNull(oidCollections,"鏁版嵁瀵硅薄涓婚敭闆嗗悎");
- List<CodeClassifyDO> codeClassifyDOList = listCodeClassifyDOByOidCollections(oidCollections);
- return codeClassifyDO2VOs(codeClassifyDOList);
- }
-
- /**
- * 浣跨敤涓婚敭闆嗗悎鏌ヨ鏁版嵁瀵硅薄
- * @param oidCollections 涓婚敭鐨勯泦鍚�
- * @return 鏁版嵁瀵硅薄鍒楄〃
- */
- private List<CodeClassifyDO> listCodeClassifyDOByOidCollections(Collection<String> oidCollections){
- List<CodeClassifyDO> codeClassifyDOList = new ArrayList<CodeClassifyDO>();
- if(!CollectionUtils.isEmpty(oidCollections)){
- Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
- for(Collection<String> oids: oidCollectionsList){
- List<CodeClassifyDO> tempDOList = codeClassifyMapper.selectByPrimaryKeyCollection(oids);
- if(!CollectionUtils.isEmpty(tempDOList)){
- codeClassifyDOList.addAll(tempDOList);
- }
- }
- }
- return codeClassifyDOList;
- }
+ @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) {
- /**
- * 鍙傜収鏍� 涓婚搴撳垎绫�
- * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
- * @return 涓婚搴撳垎绫绘樉绀烘爲
- * @throws VciBaseException 鏌ヨ鏉′欢鍜屽垎椤靛嚭閿欑殑鏃跺�欎細鎶涘嚭寮傚父
- */
- @Override
- public List<Tree> referTree(TreeQueryObject treeQueryObject) throws VciBaseException{
- 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);
- }
+ if(codeClassify == null || codeClassify.getOid() == null){
+ throw new ServiceException("浼犲叆鍙傛暟涓嶈兘涓虹┖锛�");
+ }
+ codeClassify = codeClassifyMapper.selectById(codeClassify.getOid());
- /**
- * 鍚敤銆佸仠鐢�
- * @param oid 涓婚敭
- * @param lcStatus 鐘舵��
- * @return 鎵ц缁撴灉
- */
- @Override
- public BaseResult updateLcStatus(String oid, String lcStatus){
+ R result = checkIsCanDeleteForDO(codeClassify);
- //鏌ヨ淇敼鍓峵s
- CodeClassifyDO codeClassifyDO_old = selectByOid(oid);//涓昏鏄负浜嗘煡璇s
+ //鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+ Map<String,Object> condition = new HashMap<>(2);
+ condition.put("codeClassifyOid",codeClassify.getOid());
+ List<CodeClstemplateEntity> codeClstemplateEntities = codeClstemplateMapper.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("鍒嗙被鍏宠仈妯℃澘锛岃鍏堝垹闄�!");
+ }
- //鍚敤銆佸仠鐢�
- int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
+ //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
+ //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);
+ }
+
+ }
+ }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){
+
+ //鏌ヨ淇敼鍓峵s
+ CodeClassify codeClassify = codeClassifyMapper.selectById(oid);//涓昏鏄负浜嗘煡璇s
+ codeClassify.setLcStatus(lcStatus);
+ codeClassify.setTs(new Date());
+ codeClassify.setLastModifyTime(new Date());
+ codeClassify.setLastModifier(AuthUtil.getUser().getUserName());
+ //鍚敤銆佸仠鐢�
+// int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
+ int count = codeClassifyMapper.updateById(codeClassify);
// //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
// if(u!=0) {
// codeDuckingServiceI.insertCache1(lcStatus,lcStatus,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, oid, codeClassifyDO_old.getTs());
// }
- BaseResult baseResult = u==0?BaseResult.error("淇敼澶辫触锛�"):BaseResult.success("淇敼鎴愬姛");
- return baseResult;
- }
+ return R.data(SqlHelper.retBool(count));
+ }
- /**
- * 浣跨敤鏌ヨ灏佽鍣ㄦ潵鏌ヨ
- * @param queryWrapper 鏌ヨ灏佽鍣�
- * @return 鏁版嵁瀵硅薄
- */
- @Override
- public List<CodeClassifyDO> selectByWrapper(VciQueryWrapperForDO queryWrapper) {
- return codeClassifyMapper.selectByWrapper(queryWrapper);
- }
+ /**
+ * 涓婚敭鎵归噺鑾峰彇涓婚搴撳垎绫�
+ * @param oidCollections 涓婚敭闆嗗悎锛屼絾鏄彈鎬ц兘褰卞搷锛屽缓璁竴娆℃煡璇笉瓒呰繃10000涓�
+ * @return 涓婚搴撳垎绫绘樉绀哄璞�
+ */
+ @Override
+ public Collection<CodeClassifyVO> listCodeClassifyByOids(Collection<String> oidCollections) {
+ VciBaseUtil.alertNotNull(oidCollections,"鏁版嵁瀵硅薄涓婚敭闆嗗悎");
+ List<CodeClassify> codeClassifyDOList = listCodeClassifyDOByOidCollections(oidCollections);
+ return codeClassifyDO2VOs(codeClassifyDOList);
+ }
- /**
- * 浣跨敤鍒嗙被涓婚敭鑾峰彇鍒嗙被鐩稿叧鐨勬墍鏈変俊鎭�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return 鍒嗙被涓婄骇锛屼笅绾х殑淇℃伅
- */
- @Override
- public CodeClassifyFullInfoBO getClassifyFullInfo(String codeClassifyOid) {
- VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
- CodeClassifyFullInfoBO fullInfo = new CodeClassifyFullInfoBO();
- CodeClassifyDO classifyDO = selectByOid(codeClassifyOid);
- //鏌ヨ涓婄骇
- fullInfo.setCurrentClassifyVO(codeClassifyDO2VO(classifyDO));
- fullInfo.setParentClassifyVOs(codeClassifyDO2VOs(codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid)));
- 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 CodeClassifyVO getTopClassifyVO(String codeClassifyOid) {
- VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
- List<CodeClassifyDO> classifyDOS = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
- if(!CollectionUtils.isEmpty(classifyDOS)){
- CodeClassifyDO classifyDO = classifyDOS.stream().filter(s -> StringUtils.isBlank(s.getParentCodeClassifyOid())).findFirst().orElseGet(() -> null);
- if(classifyDO!=null){
- return codeClassifyDO2VO(classifyDO);
- }
- }
- return null;
- }
+ /**
+ * 浣跨敤涓婚敭闆嗗悎鏌ヨ鏁版嵁瀵硅薄
+ * @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 codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return 涓暟
- */
- @Override
- public int countChildrenByClassifyOid(String codeClassifyOid) {
- Map<String,String> conditionMap = new HashMap<>();
- conditionMap.put("parentCodeClassifyOid",codeClassifyOid);
- return codeClassifyMapper.countByCondition(conditionMap).intValue();
- }
- /**
- * 鑾峰彇瀛愮骇鐨勪富棰樺簱鍒嗙被
- *
- * @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<CodeClassifyDO> classifyDOS = codeClassifyMapper.selectAllLevelChildHasPath(codeClassifyOid,fieldInPath,enable);
- if(!CollectionUtils.isEmpty(classifyDOS)){
- classifyDOS = classifyDOS.stream().filter(s->FRAMEWORK_DATA_ENABLED.equalsIgnoreCase(s.getLcStatus())).collect(Collectors.toList());
- }
- return codeClassifyDO2VOs(classifyDOS);
- }else{
- //鍙煡璇竴鏉★紝閭ath灏辨病蹇呰鏌ヨ浜�
- Map<String,String> conditionMap = new HashMap<>();
- conditionMap.put("parentcodeclassifyoid",codeClassifyOid);
- if (enable){
- conditionMap.put(VciQueryWrapperForDO.LC_STATUS_FIELD,FRAMEWORK_DATA_ENABLED);
- }
- return codeClassifyDO2VOs(codeClassifyMapper.selectByCondition(conditionMap,new PageHelper(-1)));
- }
- }
+ /**
+ * 鎵归噺鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+ * @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 codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return 鍒嗙被鐨勬樉绀哄璞�
- */
- @Override
- public List<CodeClassifyVO> listParentClassify(String codeClassifyOid){
- List<CodeClassifyDO> classifyDOS = codeClassifyMapper.listParentClassify(codeClassifyOid);
- return codeClassifyDO2VOs(classifyDOS);
- }
+ /**
+ * 鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+ * @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 oid 鍒嗙被涓婚敭
- * @return excel鏂囦欢璺緞
- */
- @Override
- public String exportClassify(String oid) {
- VciBaseUtil.alertNotNull(oid,"鍒嗙被鐨勪富閿�");
- CodeClassifyVO classifyVO = getObjectByOid(oid);
- classifyVO.setDataLevel(0);
- classifyVO.setPath(classifyVO.getId());
- List<CodeClassifyVO> codeClassifyVOS = listChildrenClassify(oid, true, "id", false);
- if(codeClassifyVOS ==null){
- codeClassifyVOS = new ArrayList<>();
- }
- codeClassifyVOS.add(classifyVO);
+ /**
+ * 鍙傜収鏍� 涓婚搴撳垎绫�
+ * @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);
+ }
- //鏌ヨ涓�涓嬭鍒欑殑缂栧彿锛屽拰鍏抽敭灞炴�ч噸澶嶈鍒�
- 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);
- 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 = keyAttrRepeatRuleService.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,"鎻忚堪"));
- 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(classifyVO.getOid())?vo.getPath():classifyVO.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 treeQueryObject 鏍戞煡璇㈠璞�
+ * @return 涓婚搴撳垎绫� 鏄剧ず鏍�
+ */
+ @Override
+ public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) {
+ List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyVOByTree(treeQueryObject.getParentOid());
+ List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
+ TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME.toLowerCase(Locale.ROOT));
+ 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;
+ }
- /**
- * 鍒涘缓瀵煎叆妯℃澘
- *
- * @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);
- }
- //鍘婚櫎鏁磋閮芥槸绌虹殑鎯呭喌
+// /**
+// * 鏍规嵁鏍戝舰鏌ヨ瀵硅薄鏉ユ煡璇㈡暟鎹璞�
+// *
+// * @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);
+// }
- if(CollectionUtils.isEmpty(poList)){
- throw new VciBaseException(ExcelLangCodeConstant.IMPORT_CONTENT_NULL,new String[]{});
- }
+ /**
+ * 瀵煎嚭鍒嗙被
+ *
+ * @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);
- poList = poList.stream().filter(s->!(StringUtils.isBlank(s.getId()) && StringUtils.isBlank(s.getName()) && StringUtils.isBlank(s.getPath()))).collect(Collectors.toList());
+ //鏌ヨ涓�涓嬭鍒欑殑缂栧彿锛屽拰鍏抽敭灞炴�ч噸澶嶈鍒�
+ 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,"鎻忚堪"));
+ 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;
+ }
- List<CodeClassifyDO> classifyDOList = 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(","))});
- }
+ /**
+ * 鑾峰彇瀛愮骇鐨勪富棰樺簱鍒嗙被
+ *
+ * @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);
+ if(!CollectionUtils.isEmpty(classifyDOS)){
+ classifyDOS = classifyDOS.stream().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));
+ }
+ }
- Map<String, CodeRuleVO> ruleVOMap = Optional.ofNullable(codeRuleService.listCodeRuleByIds(
- poList.stream().filter(s->StringUtils.isNotBlank(s.getCodeRuleId())).map(CodeClassifyPO::getCodeRuleId).collect(Collectors.toList()))
- ).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+ /**
+ * 鍒涘缓瀵煎叆妯℃澘
+ *
+ * @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;
+ }
- Map<String,CodeKeyAttrRepeatRuleVO> keyRuleVOMap =Optional.ofNullable(keyAttrRepeatRuleService.listCodeKeyAttrRepeatRuleByIds(
- poList.stream().filter(s->StringUtils.isNotBlank(s.getKeyRepeatRuleId())).map(CodeClassifyPO::getKeyRepeatRuleId).collect(Collectors.toList()))
- ).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
- Map<String, OsBtmTypeVO> btmVOMap = Optional.ofNullable(btmService.listBtmByIds(
- poList.stream().filter(s -> StringUtils.isNotBlank(s.getBtmTypeId())).map(CodeClassifyPO::getBtmTypeId).collect(Collectors.toList()))
- ).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+ /**
+ * 瀵煎叆鍒嗙被
+ *
+ * @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);
+ }
+ //鍘婚櫎鏁磋閮芥槸绌虹殑鎯呭喌
- Map<String/**璺緞**/,String/**涓婚敭**/> oidPathMap = new HashMap<>();
+ if(CollectionUtils.isEmpty(poList)){
+ throw new VciBaseException(ExcelLangCodeConstant.IMPORT_CONTENT_NULL,new String[]{});
+ }
- //鎴戜滑闇�瑕佹煡璇㈡墍鏈夊凡缁忓瓨鍦ㄧ殑鍒嗙被锛屼富瑕佹槸璺緞锛岀敤鏉ュ垽鏂垎绫荤殑鏁版嵁
- List<CodeClassifyDO> existClassifyDOs = codeClassifyMapper.selectAllLevelChildHasPath("", "id", false);
- Map<String/**璺緞**/, CodeClassifyDO/**宸茬粡瀛樺湪鐨勬暟鎹�**/> 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->{
- CodeClassifyDO classifyDO = new CodeClassifyDO();
- 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()});
- }
- classifyDO.setOid(VciBaseUtil.getPk());
- classifyDO.setId(po.getId());
- classifyDO.setName(po.getName());
- classifyDO.setDescription(po.getDescription());
- oidPathMap.put(po.getPath(),classifyDO.getOid());
- if(StringUtils.isNotBlank(po.getBtmTypeId())){
- OsBtmTypeVO typeVO = btmVOMap.get(po.getBtmTypeId().toLowerCase(Locale.ROOT));
- classifyDO.setBtmTypeId(typeVO.getId());
- classifyDO.setBtmTypeName(typeVO.getName());
- }
- if(StringUtils.isNotBlank(po.getCodeRuleId())){
- CodeRuleVO codeRuleVO = ruleVOMap.get(po.getCodeRuleId().toLowerCase(Locale.ROOT));
- classifyDO.setCodeRuleOid(codeRuleVO.getOid());
- }
- if(StringUtils.isNotBlank(po.getKeyRepeatRuleId())){
- CodeKeyAttrRepeatRuleVO repeatRuleVO = keyRuleVOMap.get(po.getKeyRepeatRuleId());
- classifyDO.setCodeKeyAttrRepeatOid(repeatRuleVO.getOid());
- }
- classifyDO.setLcStatus(po.getLcStatus());
- classifyDO.setPath(po.getPath());
- classifyDOList.add(classifyDO);
- });
- //瑕佺湅瀛樺湪鐨勶紝淇敼璺緞瀵瑰簲鐨勪富閿�
- 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<CodeClassifyDO> addClassifyDOList = new ArrayList<>();
- List<CodeClassifyDO> editClassifyDOList = new ArrayList<>();
- classifyDOList.stream().forEach(classifyDO->{
+ poList = poList.stream().filter(s->!(StringUtils.isBlank(s.getId()) && StringUtils.isBlank(s.getName()) && StringUtils.isBlank(s.getPath()))).collect(Collectors.toList());
- //瑕佺湅涓婄骇鏄笉鏄瓨鍦ㄥ摝
- 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())){
- //涓嶆槸椤剁骇鐨勬椂鍊欙紝瑕佽缃笂绾х殑涓婚敭
+ 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.listCodeRuleByOids(ruleOids)
+ ).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
- 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()));
- CodeClassifyDO classifyDOInDB = pathDOMap.get(classifyDO.getPath());
- 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.batchUpdate(classifyDOs.stream().collect(Collectors.toList()));
- });
- }
- if(!CollectionUtils.isEmpty(addClassifyDOList)){
- revisionModelUtil.wrapperForBatchAdd(addClassifyDOList);
- VciBaseUtil.switchCollectionForOracleIn(addClassifyDOList).stream().forEach(classifyDOs->{
- codeClassifyMapper.batchInsert(classifyDOs.stream().collect(Collectors.toList()));
- });
- }
+ 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.getKeyRepeatRuleId()))
+ .map(CodeClassifyPO::getBtmTypeId).collect(Collectors.toList());
+ Map<String, CodeOsbtmtypeEntity> btmVOMap = Optional.ofNullable(btmOids.size()==0 ? null: codeOsbtmtypeMapper.selectBatchIds(btmOids)
+ ).orElse(new ArrayList<>()).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<>();
- /**
- * 鑾峰彇鍒嗙被鍏宠仈鐨勫睘鎬�
- *
- * @param baseQueryObject 鏌ヨ瀵硅薄锛屽繀椤绘湁codeClassifyOid锛屾敮鎸乮d鍜宯ame涓ょ鏌ヨ鏉′欢
- * @return 灞炴�х殑淇℃伅锛屽寘鍚粯璁ょ殑灞炴��
- */
- @Override
- public DataGrid<OsAttributeVO> listClassifyLinkAttr(BaseQueryObject baseQueryObject) {
- if(baseQueryObject == null){
- baseQueryObject = new BaseQueryObject();
- }
- if(baseQueryObject.getConditionMap() == null){
- baseQueryObject.setConditionMap(new HashMap<>());
- }
- String classifyOid = baseQueryObject.getConditionMap().getOrDefault("codeClassifyOid","");
- String id = baseQueryObject.getConditionMap().getOrDefault("id","");
- String name = baseQueryObject.getConditionMap().getOrDefault("name","");
- if(StringUtils.isBlank(classifyOid)){
- return new DataGrid<>();
- }
- CodeClassifyVO topClassifyVO = getTopClassifyVO(classifyOid);
- if(topClassifyVO == null || StringUtils.isBlank(topClassifyVO.getBtmtypeid())){
- return new DataGrid<>();
- }
- List<OsBtmTypeAttributeVO> unDefaultAttributes = btmService.listAttributeByBtmId(topClassifyVO.getBtmtypeid());
- List<OsAttributeVO> attributeVOS = new ArrayList<>();
- if(!CollectionUtils.isEmpty(unDefaultAttributes)){
- unDefaultAttributes.stream().forEach(attr->{
- OsAttributeVO attributeVO = new OsAttributeVO();
- BeanUtil.convert(attr,attributeVO);
- attributeVO.setAttributeDataType(attr.getAttrDataType());
- attributeVO.setAttrLength(attr.getAttributeLength());
- attributeVO.setBtmTypeId(attr.getReferBtmTypeId());
- attributeVO.setBtmTypeName(attr.getReferBtmTypeName());
- boolean add = true;
- if(StringUtils.isNotBlank(id) && !attributeVO.getId().contains(id.replace("*",""))){
- add = false;
- }
- if(StringUtils.isNotBlank(name) && !attributeVO.getId().contains(name.replace("*",""))){
- add = false;
- }
- if(add){
- attributeVOS.add(attributeVO);
- }
- });
- }
- if(!CollectionUtils.isEmpty(attributeService.getDefaultAttributeVOs())){
- attributeService.getDefaultAttributeVOs().stream().forEach(attr->{
- boolean add = true;
- if(StringUtils.isNotBlank(id) && !attr.getId().contains(id.replace("*",""))){
- add = false;
- }
- if(StringUtils.isNotBlank(name) && !attr.getId().contains(name.replace("*",""))){
- add = false;
- }
- if(add){
- attributeVOS.add(attr);
- }
- });
- }
- DataGrid<OsAttributeVO> dataGrid = new DataGrid<>();
- dataGrid.setData(attributeVOS);
- dataGrid.setTotal(attributeVOS.size());
- return dataGrid;
- }
+ //鎴戜滑闇�瑕佹煡璇㈡墍鏈夊凡缁忓瓨鍦ㄧ殑鍒嗙被锛屼富瑕佹槸璺緞锛岀敤鏉ュ垽鏂垎绫荤殑鏁版嵁
+ List<CodeClassify> existClassifyDOs = codeClassifyMapper.selectAllLevelChildHasPath("");
+ 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())){
+ CodeOsbtmtypeVO typeVO = (CodeOsbtmtypeVO)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->{
- /**
- * 浣跨敤缂栧彿鐨勮矾寰勮幏鍙栧璞�
- *
- * @param idPath 缂栧彿鐨勮矾寰勶紝涓�瀹氳浠庢渶椤跺眰鑺傜偣寮�濮嬶紝鏍煎紡涓簒xx/yyy/zz 杩欐牱
- * @return 鍒嗙被鐨勬樉绀哄璞�
- */
- @Override
- public CodeClassifyVO getObjectByIdPath(String idPath) {
- CodeClassifyDO classifyDO = codeClassifyMapper.selectByFieldPath(idPath, VciQueryWrapperForDO.ID_FIELD);
- return codeClassifyDO2VO(classifyDO);
- }
- /**
- * 浣跨敤缂栧彿鐨勮矾寰勮幏鍙栧璞�
- *
- * @param clsfNamePath 缂栧彿鐨勮矾寰勶紝涓�瀹氳浠庢渶椤跺眰鑺傜偣寮�濮嬶紝鏍煎紡涓簒xx/yyy/zz 杩欐牱
- * @return 鍒嗙被鐨勬樉绀哄璞�
- */
- @Override
- public CodeClassifyVO getObjectByClsfNamePath(String clsfNamePath){
- CodeClassifyDO classifyDO = codeClassifyMapper.selectByFieldPath(clsfNamePath, "name");
- return codeClassifyDO2VO(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())){
+ //涓嶆槸椤剁骇鐨勬椂鍊欙紝瑕佽缃笂绾х殑涓婚敭
- /***
- * 鏍规嵁涓婄骇鑺傜偣鑾峰彇涓嬬骇鑺傜偣浠ｅ彿璺緞鍜屽悕绉拌矾寰�
- * @param codeClassifyId
- * @param enable
- * @return
- */
- @Override
- public List<CodeClassifyVO> getIdPathToNamePathByParentId(String codeClassifyId,boolean enable){
+ 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(AuthUtil.getUser().getUserName());
+ classifyDO.setCreator(AuthUtil.getUser().getUserName());
+ classifyDO.setLastModifier(AuthUtil.getUser().getUserName());
+ classifyDO.setLastModifyTime(new Date());
+ codeClassifyMapper.insert(classifyDO);
+ }
+// codeClassifyMapper.batchInsert(classifyDOs.stream().collect(Collectors.toList()));
+ });
+ }
- List<CodeClassifyDO> classifyDOs= codeClassifyMapper.getIdPathToNamePathByParentId(codeClassifyId,enable);
- return codeClassifyDO2VOs(classifyDOs);
+ }
- }
+ /**
+ * 鑾峰彇鍒嗙被鍏宠仈鐨勫睘鎬�
+ *
+ * @param baseQueryObject 鏌ヨ瀵硅薄锛屽繀椤绘湁codeClassifyOid锛屾敮鎸乮d鍜宯ame涓ょ鏌ヨ鏉′欢
+ * @return 灞炴�х殑淇℃伅锛屽寘鍚粯璁ょ殑灞炴��
+ */
+ @Override
+ public DataGrid<CodeOsattributeVO> listClassifyLinkAttr(BaseQueryObject baseQueryObject) {
+ if(baseQueryObject == null){
+ baseQueryObject = new BaseQueryObject();
+ }
+ if(baseQueryObject.getConditionMap() == null){
+ baseQueryObject.setConditionMap(new HashMap<>());
+ }
+ String classifyOid = baseQueryObject.getConditionMap().getOrDefault("codeClassifyOid","");
+ String id = baseQueryObject.getConditionMap().getOrDefault("id","");
+ String name = baseQueryObject.getConditionMap().getOrDefault("name","");
+ if(StringUtils.isBlank(classifyOid)){
+ 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());
+
+ List<CodeOsbtmtypeattributeEntity> unDefaultAttributes = codeOsbtmtypeattributeMapper.selectByMap(condition);
+// List<OsBtmTypeAttributeVO> unDefaultAttributes = btmService. (topClassifyVO.getBtmtypeid());
+ List<CodeOsattributeVO> attributeVOS = new ArrayList<>();
+ if(!CollectionUtils.isEmpty(unDefaultAttributes)){
+ unDefaultAttributes.stream().forEach(attr->{
+ CodeOsattributeVO attributeVO = new CodeOsattributeVO();
+ BeanUtils.copyProperties(attr,attributeVO);
+ attributeVO.setAttributedatatype(attr.getAttrdatatype());
+ attributeVO.setAttrlength(Short.valueOf(attr.getAttributelength()));
+ attributeVO.setBtmtypeid(attr.getReferbtmtypeid());
+ attributeVO.setBtmtypename(attr.getReferbtmtypename());
+ boolean add = true;
+ if(StringUtils.isNotBlank(id) && !attributeVO.getId().contains(id.replace("*",""))){
+ add = false;
+ }
+ if(StringUtils.isNotBlank(name) && !attributeVO.getId().contains(name.replace("*",""))){
+ add = false;
+ }
+ if(add){
+ attributeVOS.add(attributeVO);
+ }
+ });
+ }
+// if(!CollectionUtils.isEmpty(attributeService.getDefaultAttributeVOs())){
+// attributeService.getDefaultAttributeVOs().stream().forEach(attr->{
+// boolean add = true;
+// if(StringUtils.isNotBlank(id) && !attr.getId().contains(id.replace("*",""))){
+// add = false;
+// }
+// if(StringUtils.isNotBlank(name) && !attr.getId().contains(name.replace("*",""))){
+// add = false;
+// }
+// if(add){
+// attributeVOS.add(attr);
+// }
+// });
+// }
+ DataGrid<CodeOsattributeVO> 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->{
+ oidLevelMap.put(cbo.get("OID").toString(),cbo.get("LEVEL").toString());
+ });
+ if(CollectionUtils.isEmpty(oidLevelMap)){
+ return new ArrayList<>();
+ }
+
+ //浣跨敤涓婚敭鏌ヨ涓�涓�
+ List<CodeClassify> classifyDOS = codeClassifyMapper.selectBatchIds(oidLevelMap.keySet());
+ if(!CollectionUtils.isEmpty(classifyDOS)){
+ classifyDOS.stream().forEach(classifyDO->{
+ classifyDO.setDataLevel(VciBaseUtil.getInt(oidLevelMap.getOrDefault(classifyDO.getOid(),"0")));
+ });
+ }
+ return classifyDOS;
+ }
+
+ /**
+ * 浣跨敤缂栧彿鐨勮矾寰勮幏鍙栧璞�
+ *
+ * @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.selectById(idPathValues.get(0).get("oid").toString());
+ }
+ return codeClassifyDO2VO(classifyDO);
+ }
+
+ /**
+ * 涓婚搴撶殑鏍�
+ *
+ * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+ * @return 涓婚搴撴樉绀烘爲
+ */
+ @Override
+ public List<Tree> treeTopCodeClassify(TreeQueryObject treeQueryObject) {
+ if(treeQueryObject == null){
+ treeQueryObject = new TreeQueryObject();
+ }
+ if(treeQueryObject.getConditionMap() == null){
+ treeQueryObject.setConditionMap(new HashMap<>());
+ }
+ treeQueryObject.getConditionMap().put(PARENT_FIELD_NAME, "=null");
+ return treeCodeClassify(treeQueryObject);
+ }
+
}
-
--
Gitblit v1.9.3