From 4494a005613728c9dc22d018bca42ef5d3ebcf69 Mon Sep 17 00:00:00 2001
From: xiejun <xiejun@vci-tech.com>
Date: 星期二, 14 一月 2025 20:41:47 +0800
Subject: [PATCH] 产品型号集成，类型转换，人员组织加日志，申请接口引用码段值校验
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClstemplateServiceImpl.java | 1138 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,133 insertions(+), 5 deletions(-)
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClstemplateServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClstemplateServiceImpl.java
index 6cb26c3..1b87d97 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClstemplateServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClstemplateServiceImpl.java
@@ -16,13 +16,54 @@
*/
package com.vci.ubcs.code.service.impl;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.vci.ubcs.code.entity.CodeClstemplateEntity;
-import com.vci.ubcs.code.mapper.CodeClstemplateMapper;
+import com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant;
+import com.vci.ubcs.code.dto.CodeClassifyTemplateDTO;
+import com.vci.ubcs.code.entity.*;
+import com.vci.ubcs.code.enumpack.CodeClassifyTemplateLC;
+import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
+import com.vci.ubcs.code.mapper.*;
+import com.vci.ubcs.code.service.ICodeClassifyProcessTempService;
+import com.vci.ubcs.code.service.ICodeClassifyService;
+import com.vci.ubcs.code.service.ICodeClassifyTemplateAttrService;
import com.vci.ubcs.code.service.ICodeClstemplateService;
-import com.vci.ubcs.code.vo.CodeClstemplateVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
+import com.vci.ubcs.common.constant.CommonConstant;
+import com.vci.ubcs.flow.core.entity.ProcessTemplate;
+import com.vci.ubcs.flow.core.feign.IFlowClient;
+import com.vci.ubcs.starter.exception.VciBaseException;
+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.DefaultAttrAssimtUtil;
+import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
+import com.vci.ubcs.starter.web.pagemodel.DataGrid;
+import com.vci.ubcs.starter.web.pagemodel.PageHelper;
+import com.vci.ubcs.starter.web.pagemodel.Tree;
+import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
+import com.vci.ubcs.starter.web.util.VciBaseUtil;
+import net.logstash.logback.encoder.org.apache.commons.lang3.StringUtils;
+import org.springblade.core.mp.support.Condition;
+import org.springblade.core.mp.support.Query;
+import org.springblade.core.secure.utils.AuthUtil;
+import org.springblade.core.tool.api.R;
+import org.springblade.core.tool.utils.Func;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cglib.beans.BeanMap;
+import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
+import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.*;
+import static com.vci.ubcs.code.service.impl.CodeClassifyServiceImpl.PARENT_FIELD_NAME;
/**
* 缂栫爜搴撳畾涔�-妯℃澘绠＄悊 鏈嶅姟瀹炵幇绫�
@@ -31,10 +72,1097 @@
* @since 2023-04-10
*/
@Service
-public class CodeClstemplateServiceImpl extends ServiceImpl<CodeClstemplateMapper, CodeClstemplateEntity> implements ICodeClstemplateService {
+public class CodeClstemplateServiceImpl extends ServiceImpl<CodeClassifyTemplateMapper, CodeClassifyTemplate> implements ICodeClstemplateService {
+
+ /**
+ * 妯℃澘灞炴�х殑鏈嶅姟
+ */
+ @Lazy
+ @Autowired(required = false)
+ ICodeClassifyTemplateAttrService codeClstempattrService;
+
+ /**
+ * 瀵硅薄鐨勬搷浣�
+ */
+ @Autowired(required = false)
+ private RevisionModelUtil revisionModelUtil;
+
+ @Autowired(required = false)
+ private CodeClassifyTemplateAttrMapper codeClstempattrMapper;
+ @Autowired(required = false)
+ private CodeTempphaseServiceImpl codeTempphaseServiceImpl;
+ @Autowired(required = false)
+ private CodeClassifyTemplateButtonServiceImpl codeTempbuttonServiceImpl;
+ @Autowired(required = false)
+ private ICodeClassifyProcessTempService codeClsflowtempServiceImpl;
+ // @Autowired(required = false)
+// private CodeClsflowtempMapper codeClsflowtempMapper;
+ @Autowired(required = false)
+ private CodeTemplatePhaseMapper codeTempphaseMapper;
+ @Autowired(required = false)
+ private CodeClassifyTemplateButtonMapper codeTempbuttonMapper;
+ @Autowired(required = false)
+ private CodePhaseAttrMapper codePhaseattrMapper;
+ @Autowired(required = false)
+ private CodeClassifyMapper codeClassifyMapper;
+ @Autowired(required = false)
+ private ICodeClassifyService codeClassifyService;
+ @Autowired(required = false)
+ private CodeClassifyTemplateMapper codeClassifyTemplateMapper;
+ @Autowired(required = false)
+ private CodePhaseAttrServiceImpl codePhaseattrServiceImpl;
+ @Autowired(required = false)
+ private IFlowClient iFlowClient;
@Override
- public IPage<CodeClstemplateVO> selectPlCodeClstemplatePage(IPage<CodeClstemplateVO> page, CodeClstemplateVO plCodeClstemplate) {
+ public IPage<CodeClassifyTemplateVO> selectPlCodeClstemplatePage(IPage<CodeClassifyTemplateVO> page, CodeClassifyTemplateVO plCodeClstemplate) {
return page.setRecords(baseMapper.selectPlCodeClstemplatePage(page, plCodeClstemplate));
}
+
+ /**
+ * 鏌ヨ鍒嗙被妯℃澘瀵硅薄 鏍�
+ * @param treeQueryObject 鏍戞煡璇㈠璞�
+ * @return 鍒嗙被妯℃澘瀵硅薄 鏄剧ず鏍�
+ */
+ @Override
+ public List<Tree> treeCodeClassifyTemplate(TreeQueryObject treeQueryObject) {
+ List<CodeClassifyTemplate> doList =selectCodeClassifyTemplateDOByTree(treeQueryObject);
+
+ List<CodeClassifyTemplateVO> voList = codeClassifyTemplateDO2VOs(doList);
+ TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
+ treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
+ return revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyTemplateVO s) ->{
+ //鍙互鍦ㄨ繖閲屽鐞嗘爲鑺傜偣鐨勬樉绀�
+ return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
+ .getLcStatus()) ? (" 銆愬仠鐢ㄣ�� ") : "");
+ });
+ }
+
+ /**
+ * 鏍规嵁鏍戝舰鏌ヨ瀵硅薄鏉ユ煡璇㈡暟鎹璞�
+ *
+ * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+ * @return 鏌ヨ缁撴灉,鏁版嵁瀵硅薄
+ */
+ @Override
+ public List<CodeClassifyTemplate> selectCodeClassifyTemplateDOByTree(TreeQueryObject treeQueryObject) {
+// VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null,CodeClassifyTemplateDO.class);
+// VciParentQueryOption parentQueryOption = new VciParentQueryOption();
+// parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
+// queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
+// CodeClstemplateEntity codeClstemplateEntity = new CodeClstemplateEntity();
+// codeClstemplateEntity.set
+ return baseMapper.selectCodeClassifyTemplateDOByTree(
+ treeQueryObject.getConditionMap().get("codeclassifyoid"),
+ treeQueryObject.getConditionMap().get("lcStatus"));
+// return baseMapper.selectList(Condition.getQueryWrapper(codeClstemplateEntity));
+// return codeClassifyTemplateMapper.selectByWrapper(queryWrapperForDO);
+ }
+
+ /**
+ * 鎵归噺鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+ * @param codeClassifyTemplateDOs 鏁版嵁瀵硅薄鍒楄〃
+ * @return 鏄剧ず瀵硅薄
+ */
+ @Override
+ public List<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplate> codeClassifyTemplateDOs) {
+ return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOs,false);
+ }
+
+ /**
+ * 鎵归噺鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+ * @param codeClassifyTemplateDOs 鏁版嵁瀵硅薄鍒楄〃
+ * @param hasAttr 鏄惁鍖呭惈灞炴��
+ * @return 鏄剧ず瀵硅薄
+ */
+ @Override
+ public List<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplate> codeClassifyTemplateDOs, boolean hasAttr) {
+ List<CodeClassifyTemplateVO> voList = new ArrayList<CodeClassifyTemplateVO>();
+ if(!CollectionUtils.isEmpty(codeClassifyTemplateDOs)){
+ for(CodeClassifyTemplate s: codeClassifyTemplateDOs){
+ CodeClassifyTemplateVO vo = codeClassifyTemplateDO2VO(s);
+ if(vo != null){
+ voList.add(vo);
+ }
+ }
+ }
+ if(hasAttr){
+ //涓�涓垎绫婚噷闈㈡�讳笉鑳借秴杩�1000涓敓鏁堢殑鐗堟湰鍚э紒锛侊紒
+ VciBaseUtil.switchCollectionForOracleIn(voList.stream().map(CodeClassifyTemplateVO::getOid).collect(Collectors.toList())).forEach(tempOids->{
+ List<CodeClassifyTemplateAttrVO> attrVOList = codeClstempattrService.listCodeClassifyTemplateAttrByTemplateOids(tempOids);
+
+ if(!CollectionUtils.isEmpty(attrVOList)){
+ Map<String, List<CodeClassifyTemplateAttrVO>> attrVOMap = attrVOList.stream().collect(Collectors.groupingBy(s -> s.getClassifyTemplateOid()));
+
+ voList.stream().forEach(templateVO->{
+ if(attrVOMap.containsKey(templateVO.getOid())){
+ List<CodeClassifyTemplateAttrVO> codeClstempattrVO = new ArrayList<>();
+ for (CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO : attrVOMap.get(templateVO.getOid())) {
+ codeClstempattrVO.add(codeClassifyTemplateAttrVO);
+ }
+ templateVO.setAttributes(codeClstempattrVO);
+ }
+ });
+ }
+ });
+
+ }
+ return voList;
+ }
+ /**
+ * 鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+ * @param codeClassifyTemplateDO 鏁版嵁瀵硅薄
+ * @return 鏄剧ず瀵硅薄
+ */
+ @Override
+ public CodeClassifyTemplateVO codeClassifyTemplateDO2VO(CodeClassifyTemplate codeClassifyTemplateDO) {
+ CodeClassifyTemplateVO vo = new CodeClassifyTemplateVO();
+ if(codeClassifyTemplateDO != null){
+ BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDO,vo);
+ //濡傛灉鏈塴cstatus鐨勭被鐨勮瘽
+ vo.setLcStatusText(CodeClassifyTemplateLC.getTextByValue(vo.getLcStatus()));
+
+ }
+ return vo;
+ }
+
+ /**
+ * 妫�鏌� 鍒嗙被妯℃澘瀵硅薄鏄惁鍒犻櫎
+ * @param codeClstemplateDTO 鍒嗙被妯℃澘瀵硅薄鏁版嵁浼犺緭瀵硅薄锛屽繀椤昏鏈塷id鍜宼s灞炴��
+ * @return 鎵ц缁撴灉 success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
+ */
+ @Override
+ public R checkIsCanDelete(CodeClassifyTemplateDTO codeClstemplateDTO) {
+ VciBaseUtil.alertNotNull(codeClstemplateDTO,"鏁版嵁浼犺緭瀵硅薄",codeClstemplateDTO.getOid(),"涓婚敭");
+ CodeClassifyTemplate codeClassifyTemplate = baseMapper.selectById(codeClstemplateDTO.getOid());
+ return checkIsCanDeleteForDO(codeClstemplateDTO, codeClassifyTemplate);
+ }
+
+ /**
+ * 鏍￠獙鏄惁鍙互鍒犻櫎锛屽鏋滃瓨鍦ㄤ笅绾э紝骞朵笖涓嬬骇鏈夋暟鎹紩鐢ㄥ垯涓嶈兘鍒犻櫎
+ * @param codeClstemplateDTO 鏁版嵁浼犺緭瀵硅薄
+ * @param codeClassifyTemplate 鏁版嵁搴撲腑鐨勬暟鎹璞�
+ * @return success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
+ */
+ private R checkIsCanDeleteForDO(CodeClassifyTemplateDTO codeClstemplateDTO, CodeClassifyTemplate codeClassifyTemplate) {
+ CodeClassifyTemplate codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplate();
+ BeanUtilForVCI.copyPropertiesIgnoreCase(codeClstemplateDTO,codeClassifyTemplateDOCopyFromDTO);
+
+ //妫�鏌s
+// Map<String,Object> condition = new HashMap<>(2);
+// condition.put("oid",codeClstemplateDTO.getOid());
+// condition.put("ts",codeClstemplateDTO.getTs());
+ CodeClassifyTemplate detail = baseMapper
+ .selectById(codeClstemplateDTO.getOid());
+
+ if(!detail.getTs().toString().equals(codeClstemplateDTO.getTs().toString())){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
+ return R.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+ }
+ //鏍￠獙涓嬬骇鏄惁鏈夊紩鐢�
+ if(checkChildIsLinked(codeClassifyTemplate.getOid())){
+ return R.fail(DATA_CASCADE_LINKED_NOT_DELETE);
+ }
+ return R.success(String.valueOf(checkHasChild(codeClassifyTemplate.getOid())));
+ }
+
+ /**
+ * 妫�鏌ユ槸鍚︽湁涓嬬骇鏄惁鍏宠仈浜嗘暟鎹�
+ *
+ * @param oid 涓婚敭
+ * @return true 琛ㄧず鏈夊紩鐢紝false琛ㄧず娌℃湁寮曠敤
+ */
+ @Override
+ public boolean checkChildIsLinked(String oid) {
+ VciBaseUtil.alertNotNull(oid,"涓婚敭");
+ List<String> childOids = baseMapper.selectAllLevelChildOid(oid.trim());
+ if(!CollectionUtils.isEmpty(childOids)){
+ for(String childOid: childOids){
+ if(!checkIsLinked(childOid)){
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * 鏍￠獙鏄惁琚紩鐢�
+ * @param oid 涓婚敭
+ */
+ private boolean checkIsLinked(String oid){
+ //TODO 娣诲姞闇�瑕佹牎楠屽紩鐢ㄧ殑鍦版柟
+ return false;
+ }
+
+ /**
+ * 鏍￠獙鏄惁鏈変笅绾ц妭鐐癸紝涓嶆牎楠屾槸鍚﹀叧鑱斾簡鏁版嵁
+ *
+ * @param oid 涓婚敭
+ * @return true琛ㄧず鏈変笅绾э紝false琛ㄧず娌℃湁涓嬬骇
+ */
+ @Override
+ public boolean checkHasChild(String oid) {
+ VciBaseUtil.alertNotNull(oid,"涓婚敭");
+ return baseMapper.countAllLevelChildOid(oid.trim()) > 0;
+ }
+
+
+ /**
+ * 鍒犻櫎鍒嗙被妯℃澘瀵硅薄
+ * @param codeClstemplateDTO 鍒嗙被妯℃澘瀵硅薄鏁版嵁浼犺緭瀵硅薄锛宱id鍜宼s闇�瑕佷紶杈�
+ * @return 鍒犻櫎缁撴灉鍙嶉锛氾細success锛氭垚鍔燂紝fail锛氬け璐�
+ */
+ @Transactional
+ @Override
+ public R deleteCodeClassifyTemplate(CodeClassifyTemplateDTO codeClstemplateDTO) {
+ checkIsCanDelete(codeClstemplateDTO);
+ VciBaseUtil.alertNotNull(codeClstemplateDTO,"鍒嗙被妯℃澘瀵硅薄鏁版嵁瀵硅薄",codeClstemplateDTO.getOid(),"鍒嗙被妯℃澘瀵硅薄鐨勪富閿�");
+
+ CodeClassifyTemplate codeClassifyTemplateDO = baseMapper.selectById(codeClstemplateDTO.getOid());
+
+ //鍙湁缂栬緫涓墠鑳藉垹
+ if(!CodeClassifyTemplateLC.EDITING.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
+ return R.fail("鍙湁缂栬緫涓殑锛屾ā鏉挎墠鑳藉垹闄わ紒");
+ }
+ R baseResult = checkIsCanDeleteForDO(codeClstemplateDTO,codeClassifyTemplateDO);
+
+ //妯℃澘oid
+ String templateOid = codeClstemplateDTO.getOid();
+
+ int updateCount = 0;
+
+// WebUtil.setPersistence(false);//涓嶆墽琛屼繚瀛�
+// BatchCBO batchCBO = new BatchCBO();
+
+ if(baseResult.isSuccess()) {
+ //鎵句笅绾х殑锛岃繖涓槸鍙互鍒犻櫎鐨勬椂鍊�
+ List<String> childrenOids = baseMapper.selectAllLevelChildOid(codeClassifyTemplateDO.getOid().trim());
+ if (!CollectionUtils.isEmpty(childrenOids)) {
+ Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids);
+ for (Collection<String> s : childrenCollections) {
+ updateCount += baseMapper.deleteBatchIds(s);
+
+// batchCBO.copyFromOther(batchCBOi);
+ }
+ }
+ }else{
+ return baseResult;
+ }
+ //鎵ц鍒犻櫎鎿嶄綔
+
+ updateCount += baseMapper.deleteById(codeClassifyTemplateDO.getOid());
+// batchCBO.copyFromOther(batchCBO_delete);
+
+ //鍒犻櫎妯℃澘灞炴��
+// VciQueryWrapperForDO templateQueryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
+// templateQueryWrapper.addQueryMap("classifyTemplateOid",templateOid);
+ List<CodeClassifyTemplateAttr> codeClstempattrEntityList = codeClstempattrMapper.selectRefByOid(templateOid);
+
+ if(!CollectionUtils.isEmpty(codeClstempattrEntityList)) {
+ List<String> templateAttrOids = new ArrayList<String>();
+ for (CodeClassifyTemplateAttr codeClstempattrEntity:codeClstempattrEntityList){
+ templateAttrOids.add(codeClstempattrEntity.getOid());
+ }
+
+ updateCount += codeClstempattrMapper.deleteBatchIds(templateAttrOids);
+// batchCBO.copyFromOther(batchCBO_templateAttr_delete);
+ }
+
+ //璋冪敤妯℃澘闃舵鏂规硶
+ updateCount += codeTempphaseServiceImpl.codeTemplateDeleteTrigger(templateOid);
+
+ //璋冪敤妯℃澘鎸夐挳鏂规硶
+ updateCount += codeTempbuttonServiceImpl.codeTemplateDeleteTrigger(templateOid);
+
+ //璋冪敤妯℃澘娴佺▼鏂规硶
+ updateCount += codeClsflowtempServiceImpl.codeTemplateDeleteTrigger(templateOid);
+
+ return updateCount > 0?R.success(DELETE_SUCCESS):R.fail(DELETE_FAIL);
+ }
+
+
+ /**
+ * 涓婚敭鑾峰彇鍒嗙被妯℃澘瀵硅薄
+ * @param oid 涓婚敭
+ * @return 鍒嗙被妯℃澘瀵硅薄鏄剧ず瀵硅薄
+ */
+ @Override
+ public CodeClassifyTemplateVO getObjectByOid(String oid) {
+ return codeClassifyTemplateDO2VO(selectByOid(oid));
+ }
+
+ @Override
+ public Collection<CodeClassifyTemplateVO> listCodeClassifyTemplateByOids(List<String> oidCollections) {
+ VciBaseUtil.alertNotNull(oidCollections,"鏁版嵁瀵硅薄涓婚敭闆嗗悎");
+ List<CodeClassifyTemplate> codeClassifyTemplateDOList = listCodeClassifyTemplateDOByOidCollections(oidCollections);
+ return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOList);
+ }
+
+ /**
+ * 鍙傜収鏍� 鍒嗙被妯℃澘瀵硅薄
+ * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+ * @return 鍒嗙被妯℃澘瀵硅薄鏄剧ず鏍�
+ */
+ @Transactional
+ @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);
+ }
+ treeQueryObject.getConditionMap().put(LC_STATUS,CodeClassifyTemplateLC.RELEASED.getValue());
+ return treeCodeClassifyTemplate(treeQueryObject);
+ }
+
+ /**
+ * 浣跨敤涓婚敭闆嗗悎鏌ヨ鏁版嵁瀵硅薄
+ * @param oidCollections 涓婚敭鐨勯泦鍚�
+ * @return 鏁版嵁瀵硅薄鍒楄〃
+ */
+ private List<CodeClassifyTemplate> listCodeClassifyTemplateDOByOidCollections(Collection<String> oidCollections){
+ List<CodeClassifyTemplate> codeClassifyTemplateDOList = new ArrayList<CodeClassifyTemplate>();
+ if(!CollectionUtils.isEmpty(oidCollections)){
+ Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
+ for(Collection<String> oids: oidCollectionsList){
+ List<CodeClassifyTemplate> tempDOList = baseMapper.selectBatchIds(oids); //codeClassifyTemplateMapper.selectByPrimaryKeyCollection(oids);
+ if(!CollectionUtils.isEmpty(tempDOList)){
+ codeClassifyTemplateDOList.addAll(tempDOList);
+ }
+ }
+ }
+ return codeClassifyTemplateDOList;
+ }
+
+ /**
+ * 涓婚敭鏌ヨ鏁版嵁瀵硅薄
+ * @param oid 涓婚敭
+ * @return 鏁版嵁瀵硅薄
+ */
+ private CodeClassifyTemplate selectByOid(String oid) {
+ VciBaseUtil.alertNotNull(oid,"涓婚敭");
+ CodeClassifyTemplate codeClassifyTemplate = baseMapper.selectById(oid.trim());
+ if(codeClassifyTemplate == null || StringUtils.isBlank(codeClassifyTemplate.getOid())){
+ throw new VciBaseException(DATA_OID_NOT_EXIST);
+ }
+ return codeClassifyTemplate;
+ }
+
+ /**
+ * 鍚敤銆佸仠鐢�
+ * @param oid
+ * @param lcStatus
+ * @return
+ */
+ @Transactional
+ @Override
+ public R updateLcStatus( String oid, String lcStatus){
+ CodeClassifyTemplate codeClassifyTemplateDO = baseMapper.selectById(oid);
+ //鍋滅敤鐨勬椂鍊欙紝楠岃瘉妯℃澘鏄惁涓哄凡鍙戝竷
+ if(CodeClassifyTemplateLC.DISABLED.getValue().equals(lcStatus)){
+ if(!CodeClassifyTemplateLC.RELEASED.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
+ return R.fail("妯℃澘鏈惎鐢紝涓嶈兘鍋滅敤锛�");
+ }
+ }
+
+ if(lcStatus.equals(CodeClassifyTemplateLC.RELEASED.getValue())){
+ QueryWrapper<CodeClassify> classifyQueryWrapper = new QueryWrapper<>();
+ classifyQueryWrapper.eq("oid",codeClassifyTemplateDO.getCodeClassifyOid());
+ classifyQueryWrapper.eq("lcstatus","Enabled");
+ List<CodeClassify> codeClassifyList = codeClassifyService.selectByWrapper(classifyQueryWrapper);
+ if(codeClassifyList.size()==0){
+ return R.fail("鏌ヨ鍒版墍灞炲垎绫绘湭鍚敤锛岃鍏堣繘琛屽惎鐢紒锛侊紒");
+ }
+ }
+
+ //鍚敤銆佸仠鐢�
+ codeClassifyTemplateDO.setLcStatus(lcStatus);
+ int u = baseMapper.updateById(codeClassifyTemplateDO);
+ return u==0?R.fail("淇敼澶辫触锛�"):R.success("淇敼鎴愬姛");
+ }
+
+ /**
+ * 鍗囩増
+ * @param codeClassifyDTO
+ */
+ @Transactional
+ @Override
+ public R Upgrade(CodeClassifyTemplateDTO codeClassifyDTO) {
+
+ //鏃х殑妯℃澘oid
+ String templateOldOid = codeClassifyDTO.getOid();
+ //鍙湁宸插彂甯冪殑鎵嶈兘鍗囩増
+ CodeClassifyTemplate codeClassifyTemplateDOOld = baseMapper.selectById(templateOldOid);
+ if(!FRAMEWORK_RELEASE_RELEASED.equals(codeClassifyTemplateDOOld.getLcStatus())){
+ return R.fail("璇ユā鏉挎湭鍙戝竷锛屼笉鑳藉崌鐗堬紒");
+ }
+
+ //闇�瑕佹柊澧炵殑鍗囩骇妯℃澘
+ CodeClassifyTemplate codeCls_template = baseMapper.selectById(templateOldOid);
+ CodeClassifyTemplate codeCls_template_insert = new CodeClassifyTemplate();
+ codeCls_template_insert.setOid(VciBaseUtil.getPk());
+ codeCls_template_insert.setRevisionOid(VciBaseUtil.getPk());
+ codeCls_template_insert.setNameOid(codeCls_template.getNameOid());
+ codeCls_template_insert.setBtmname(codeCls_template.getBtmname());
+ codeCls_template_insert.setLastR(String.valueOf(1));
+ codeCls_template_insert.setFirstR(String.valueOf(0));
+ codeCls_template_insert.setFirstV(String.valueOf(1));
+ codeCls_template_insert.setLastV(String.valueOf(1));
+// codeCls_template_insert.setCreator(String.valueOf(AuthUtil.getUser().getUserId()));
+ codeCls_template_insert.setCreator(String.valueOf(AuthUtil.getUser().getAccount()));
+ codeCls_template_insert.setCreateTime(new Date());
+ codeCls_template_insert.setTs(new Date());
+ // codeCls_template_insert.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
+ codeCls_template_insert.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
+ codeCls_template_insert.setLastModifyTime(new Date());
+ codeCls_template_insert.setRevisionRule(codeCls_template.getRevisionRule());
+ codeCls_template_insert.setVersionRule(codeCls_template.getVersionRule());
+ codeCls_template_insert.setBtmTypeId(codeCls_template.getBtmTypeId());
+ codeCls_template_insert.setBtmTypeName(codeCls_template.getBtmTypeName());
+ codeCls_template_insert.setCodeClassifyOid(codeCls_template.getCodeClassifyOid());
+ codeCls_template_insert.setCodeClassifyOidName(codeCls_template.getCodeClassifyOidName());
+ Map rvObj = baseMapper.getNextRevision(codeCls_template.getNameOid());
+ codeCls_template_insert.setRevisionSeq(Integer.parseInt(rvObj.get("REVISIONSEQ").toString()));
+ codeCls_template_insert.setRevisionValue(rvObj.get("REVISIONVAL").toString());
+ codeCls_template_insert.setVersionSeq(Integer.parseInt(rvObj.get("VERSIONSEQ").toString()));
+ codeCls_template_insert.setVersionValue(rvObj.get("VERSIONVAL").toString());
+ codeCls_template_insert.setLctid(codeCls_template.getLctid());
+ codeCls_template_insert.setLcStatus("Editing");
+ codeCls_template_insert.setId(codeCls_template.getId());
+ codeCls_template_insert.setName(codeCls_template.getName());
+ codeCls_template_insert.setDescription(codeCls_template.getDescription());
+ codeCls_template_insert.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
+ codeCls_template_insert.setCopyFromVersion(codeCls_template.getOid());
+ int insertCount = baseMapper.insert(codeCls_template_insert);
+ codeCls_template.setLastR("0");
+ codeCls_template.setLastModifyTime(new Date());
+ // codeCls_template.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
+ codeCls_template.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
+ baseMapper.updateById(codeCls_template);
+ //鍗囩増杩囧悗鐨勬ā鏉縪id
+ String templateNewOid = codeCls_template_insert.getOid();
+
+ //闇�瑕佸鍒剁殑妯℃澘灞炴��
+ //鏌ヨ鑰佹ā鏉夸笅杈圭殑鎵�鏈夊睘鎬э紝璧嬪�兼柊妯℃澘oid
+ Map<String,Object> condition = new HashMap<>(1);
+ condition.put("classifyTemplateOid",templateOldOid);
+ List<CodeClassifyTemplateAttr> codeClstempattrEntities = codeClstempattrMapper.selectByMap(condition);
+ for (CodeClassifyTemplateAttr codeClassifyTemplateAttrDO :codeClstempattrEntities){
+ codeClassifyTemplateAttrDO.setOid(VciBaseUtil.getPk());
+ codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
+ codeClstempattrMapper.insert(codeClassifyTemplateAttrDO);
+ }
+
+ //澶嶅埗妯℃澘娴佺▼
+ List<ProcessTemplate> codeClassifyProcessTempDOList = copyTemplateProcess(templateOldOid,templateNewOid);
+ //澶嶅埗妯℃澘闃舵锛岄樁娈靛睘鎬�
+ Map phase_attrMap = copyTemplatePhase_attr(templateOldOid,templateNewOid);
+
+ List<CodeTemplatePhase> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhase>)phase_attrMap.get("phase");//妯℃澘闃舵
+ List<CodePhaseAttr> codePhaseAttrDOList = (ArrayList<CodePhaseAttr>)phase_attrMap.get("phaseAttr");//闃舵灞炴��
+
+ //澶嶅埗妯℃澘鎸夐挳
+ List<CodeClassifyTemplateButton> codeClassifyTemplateButtonDOList = copyTemplateButton(templateOldOid,templateNewOid);
+
+ //淇濆瓨妯℃澘娴佺▼
+ if(!CollectionUtils.isEmpty(codeClassifyProcessTempDOList)) {
+ iFlowClient.processBatchSave(codeClassifyProcessTempDOList);
+ }
+ //妯℃澘闃舵
+ if(!CollectionUtils.isEmpty(codeClassifyPhaseDOList)) {
+ codeTempphaseServiceImpl.saveBatch(codeClassifyPhaseDOList);
+ }
+
+ //妯℃澘闃舵灞炴��
+ if(!CollectionUtils.isEmpty(codePhaseAttrDOList)) {
+ codePhaseattrServiceImpl.saveBatch(codePhaseAttrDOList);
+ }
+// //妯℃澘鎸夐挳
+ if(!CollectionUtils.isEmpty(codeClassifyTemplateButtonDOList)) {
+ codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList);
+ }
+ return R.success("鍗囩増鎴愬姛锛�");
+ }
+
+ @Override
+ @Transactional
+ public R copyTemplate(CodeClassifyTemplateDTO codeClassifyDTO) {
+ //鏃х殑妯℃澘oid
+ String oldOid = codeClassifyDTO.getOid();
+ //鏂扮殑妯℃澘oid
+ String newOid = VciBaseUtil.getPk();
+ //鍒嗙被oid,澶嶅埗杩囨潵鐨勬柊鐨勫垎绫籵id
+ String codeClassifyOid = codeClassifyDTO.getCodeclassifyoid();
+
+ QueryWrapper<CodeClassifyTemplate> wrapper = new QueryWrapper<>();
+ wrapper.eq("CODECLASSIFYOID",codeClassifyOid);
+ Long aLong = baseMapper.selectCount(wrapper);
+ if(aLong > 0){
+ return R.fail("璇ュ垎绫讳笅宸叉湁瀛愭ā鐗堬紝鏃犳硶杩涜澶嶅埗鎿嶄綔锛屼粎鑳借繘琛屽崌鐗堟搷浣滐紒");
+ }
+
+ //澶嶅埗妯℃澘
+ CodeClassifyTemplate codeClassifyTemplateDO_old = baseMapper.selectById(oldOid);//鏃фā鏉�
+
+ //楠岃瘉锛屼笟鍔＄被鍨嬫槸涓嶆槸涓�鑷�
+ CodeClassify codeClassifyDO_old = codeClassifyService.selectBtmOrParentBtm(codeClassifyTemplateDO_old.getCodeClassifyOid());
+ if(codeClassifyDO_old==null){
+ return R.fail("澶嶅埗鐨勬ā鏉挎墍灞炲垎绫讳互鍙婁笂绾ф病鏈変笟鍔＄被鍨嬶紝璇烽噸鏂伴�夋嫨!");
+ }
+
+ //鎵惧綋鍓嶅垎绫讳笅鐨勪笟鍔＄被鍨�
+ CodeClassify codeClassifyDO_new = codeClassifyService.selectBtmOrParentBtm(codeClassifyOid);
+ if(codeClassifyDO_new==null){
+ return R.fail("褰撳墠鍒嗙被娌℃湁涓氬姟绫诲瀷锛岃閲嶆柊閫夋嫨!");
+ }
+
+ if(!codeClassifyDO_old.getBtmTypeId().equals(codeClassifyDO_new.getBtmTypeId())){
+ return R.fail("閫夋嫨鐨勫垎绫诲拰褰撳墠鍒嗙被涓氬姟绫诲瀷涓嶄竴鑷达紝璇烽噸鏂伴�夋嫨!");
+ }
+
+ codeClassifyTemplateDO_old.setId(codeClassifyDTO.getId());//鑻辨枃鍚嶇О
+ codeClassifyTemplateDO_old.setName(codeClassifyDTO.getName());//涓枃鍚嶇О
+ codeClassifyTemplateDO_old.setDescription(codeClassifyDTO.getDescription());//鎻忚堪
+ codeClassifyTemplateDO_old.setCodeClassifyOid(codeClassifyOid);//鍒嗙被oid
+ codeClassifyTemplateDO_old.setOid(newOid);
+ codeClassifyTemplateDO_old.setTs(new Date());
+ codeClassifyTemplateDO_old.setCreateTime(new Date());
+ codeClassifyTemplateDO_old.setLastModifyTime(new Date());
+ // 澶嶅埗鐨勬ā鏉跨敓鍛藉懆鏈熸敼涓虹紪杈戜腑
+ codeClassifyTemplateDO_old.setLcStatus(FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_EDITING);
+ List<CodeClassifyTemplate> codeClassifyTemplateDOList = new ArrayList<>();
+ codeClassifyTemplateDOList.add(codeClassifyTemplateDO_old);
+
+ //澶嶅埗妯℃澘灞炴��
+ List<CodeClassifyTemplateAttr> codeClassifyTemplateAttrDOList = copyTemplateAttr(oldOid,newOid);
+
+ //澶嶅埗妯℃澘娴佺▼
+ List<ProcessTemplate> codeClassifyProcessTempDOList = copyTemplateProcess(oldOid,newOid);
+
+ //澶嶅埗妯℃澘闃舵锛岄樁娈靛睘鎬�
+ Map phase_attrMap = copyTemplatePhase_attr(oldOid,newOid);
+
+ List<CodeTemplatePhase> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhase>)phase_attrMap.get("phase");//妯℃澘闃舵
+ List<CodePhaseAttr> codePhaseAttrDOList = (ArrayList<CodePhaseAttr>)phase_attrMap.get("phaseAttr");//闃舵灞炴��
+
+ //澶嶅埗妯℃澘鎸夐挳
+ List<CodeClassifyTemplateButton> codeClassifyTemplateButtonDOList = copyTemplateButton(oldOid,newOid);
+
+// baseMapper.insert(codeClassifyTemplateDOList);
+ this.saveBatch(codeClassifyTemplateDOList);
+ codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList);
+ iFlowClient.processBatchSave(codeClassifyProcessTempDOList);
+ codeClstempattrService.saveBatch(codeClassifyTemplateAttrDOList);
+ codeTempphaseServiceImpl.saveBatch(codeClassifyPhaseDOList);
+ codePhaseattrServiceImpl.saveBatch(codePhaseAttrDOList);
+ //涓�璧蜂繚瀛樻暟鎹�
+// WebUtil.setPersistence(false);//涓嶆墽琛屼繚瀛�
+// //淇濆瓨妯℃澘
+// BatchCBO batchCBOTemplate = codeClassifyTemplateMapper.batchInsert(codeClassifyTemplateDOList);
+// //淇濆瓨妯℃澘灞炴��
+// if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrDOList)) {
+// BatchCBO batchCBOTemplateAttr = codeClassifyTemplateAttrDaoI.batchInsert(codeClassifyTemplateAttrDOList);
+// batchCBOTemplate.copyFromOther(batchCBOTemplateAttr);
+// }
+//
+// //淇濆瓨妯℃澘娴佺▼
+// if(!CollectionUtils.isEmpty(codeClassifyProcessTempDOList)) {
+// BatchCBO batchCBOTemplateProcessAttr = codeClassifyProcessTempDaoI.batchInsert(codeClassifyProcessTempDOList);
+// batchCBOTemplate.copyFromOther(batchCBOTemplateProcessAttr);
+// }
+//
+// //妯℃澘闃舵
+// if(!CollectionUtils.isEmpty(codeClassifyPhaseDOList)) {
+// BatchCBO batchCBOTemplatePhaseAttr = codeTemplatePhaseDaoI.batchInsert(codeClassifyPhaseDOList);
+// batchCBOTemplate.copyFromOther(batchCBOTemplatePhaseAttr);
+// }
+//
+// //妯℃澘闃舵灞炴��
+// if(!CollectionUtils.isEmpty(codePhaseAttrDOList)) {
+// BatchCBO batchCBOTemplatePhaseAttrAttr = codePhaseAttrDaoI.batchInsert(codePhaseAttrDOList);
+// batchCBOTemplate.copyFromOther(batchCBOTemplatePhaseAttrAttr);
+// }
+//
+// //妯℃澘鎸夐挳
+// if(!CollectionUtils.isEmpty(codeClassifyTemplateButtonDOList)) {
+// BatchCBO batchCBOTemplateButtonAttr = codeClassifyTemplateButtonDaoI.batchInsert(codeClassifyTemplateButtonDOList);
+// batchCBOTemplate.copyFromOther(batchCBOTemplateButtonAttr);
+// }
+//
+//
+// WebUtil.setPersistence(true);//鎵ц淇濆瓨
+//
+// boService.persistenceBatch(batchCBOTemplate);//涓�璧锋墽琛屼繚瀛�
+ return R.success("澶嶅埗鎴愬姛锛�");
+ }
+
+
+ private HashMap<String,Object> getVersionValue(int verRuleName) {
+ HashMap<String,Object> obj = new HashMap<>(2);
+ obj.put("VersionSeq",1);
+ if (verRuleName == 0) {
+ obj.put("VersionVal","1");
+ } else if (verRuleName == 1) {
+ obj.put("VersionVal","a");
+ } else if (verRuleName == 2) {
+ obj.put("VersionVal","0");
+ }
+
+ return obj;
+ }
+
+ /**
+ * 澶嶅埗妯℃澘娴佺▼
+ */
+ public List<ProcessTemplate> copyTemplateProcess(String templateOldOid,String templateNewOid){
+ Map<String,Object> wrapperMap = new HashMap();
+ wrapperMap.put("template_id",templateOldOid);
+ R<List<ProcessTemplate>> listR = iFlowClient.selectByWrapper(wrapperMap);
+ if(!listR.isSuccess()){
+ throw new VciBaseException("鏌ヨ妯℃澘娴佺▼鏃跺嚭閿欙紝璇烽噸璇曪紒");
+ }
+ List<ProcessTemplate> codeClsflowtempEntities = listR.getData();
+ for (ProcessTemplate codeClassifyProcessTempDO:codeClsflowtempEntities){
+ codeClassifyProcessTempDO.setId(null);
+ codeClassifyProcessTempDO.setTemplateId(templateNewOid);
+ //modify by lihang - @20220406 璁剧疆妯℃澘涓婚敭浣嶇疆鍑洪敊锛屽鑷村崌鐗堢殑妯℃澘涓殑娴佺▼鏄┖鐨勩��
+ }
+ return codeClsflowtempEntities;
+ }
+
+
+ /**
+ * 澶嶅埗妯℃澘闃舵锛屾ā鏉垮睘鎬�
+ * @param templateOldOid
+ * @param templateNewOid
+ * @return map phase:(List<CodeTemplatePhaseDO>) phaseAttr:(List<CodePhaseAttrDO>)
+ */
+ public Map copyTemplatePhase_attr(String templateOldOid,String templateNewOid){
+ //妯℃澘闃舵
+// VciQueryWrapperForDO phaseWrapper = new VciQueryWrapperForDO(CodeTemplatePhaseDO.class);
+// phaseWrapper.addQueryMap("codeClassifyTemplateOid",templateOldOid);
+ Map<String,Object> condition = new HashMap<>(1);
+ condition.put("codeclassifyTemplateOid",templateOldOid);
+ List<CodeTemplatePhase> codeTempphaseEntities = codeTempphaseMapper.selectByMap(condition);
+// List<CodeTemplatePhaseDO> codeClassifyPhaseDOList = codeTemplatePhaseDaoI.selectByWrapper(phaseWrapper);//瑕佷繚瀛樼殑鏂扮殑妯℃澘娴佺▼
+ Map<String,String> phaseKeyMap = new HashMap<String,String>();//闇�瑕佸鍒剁殑妯℃澘闃舵灞炴��,key:value,妯℃澘闃舵鑰乷id:妯℃澘灞炴�ф柊oid
+ List<String> phaseOidList = new ArrayList<String>();
+ for (CodeTemplatePhase codeTemplatePhaseDO:codeTempphaseEntities){
+ String oldoid = codeTemplatePhaseDO.getOid();
+ String newOid = VciBaseUtil.getPk();
+ codeTemplatePhaseDO.setOid(newOid);
+ codeTemplatePhaseDO.setCodeClassifyTemplateOid(templateNewOid);
+ phaseKeyMap.put(oldoid,newOid);
+ phaseOidList.add(oldoid);
+ }
+
+ //妯℃澘闃舵鐨勫睘鎬�
+ List<CodePhaseAttr> codePhaseAttrDOList = new ArrayList<CodePhaseAttr>();
+
+ if(!CollectionUtils.isEmpty(phaseOidList)){//size()==0涓嬭竟鏂规硶浼氭姤閿�
+// Map<String,String> conditionMap = new HashMap<>();
+// conditionMap.put("codephaseoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(phaseOidList.toArray(new String[0])) + ")");
+// codePhaseAttrDOList = codePhaseAttrDaoI.selectByCondition(conditionMap,new PageHelper(-1));
+ codePhaseAttrDOList = codePhaseattrMapper.selectByPhaseaIds(VciBaseUtil.toInSql(phaseOidList.toArray(new String[0])));
+ }
+ for (CodePhaseAttr codePhaseAttrDO:codePhaseAttrDOList){
+ String oldPhaseoid = codePhaseAttrDO.getCodePhaseOid();
+// String newOid = VciBaseUtil.getPk();
+ codePhaseAttrDO.setOid(null);
+ codePhaseAttrDO.setCodePhaseOid(phaseKeyMap.get(oldPhaseoid));
+// codePhaseattrMapper.insert(codePhaseAttrDO);
+ }
+ Map phaseMap = new HashMap();
+ phaseMap.put("phase",codeTempphaseEntities);
+ phaseMap.put("phaseAttr",codePhaseAttrDOList);
+ return phaseMap;
+ }
+
+ /**
+ * 澶嶅埗妯℃澘鎸夐挳
+ */
+ public List<CodeClassifyTemplateButton> copyTemplateButton(String templateOldOid,String templateNewOid){
+
+ Map<String,Object> condition = new HashMap<>(1);
+ condition.put("classifyTemplateOid",templateOldOid);
+// VciQueryWrapperForDO buttonWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateButtonDO.class);
+// buttonWrapper.addQueryMap("classifyTemplateOid",templateOldOid);
+ List<CodeClassifyTemplateButton> codeTempbuttonEntities = codeTempbuttonMapper.selectByMap(condition);
+// List<CodeClassifyTemplateButtonDO> codeClassifyTemplateButtonDOList = codeClassifyTemplateButtonDaoI.selectByWrapper(buttonWrapper);
+ for (CodeClassifyTemplateButton codeClassifyTemplateButtonDO:codeTempbuttonEntities){
+// String newOid = VciBaseUtil.getPk();
+ codeClassifyTemplateButtonDO.setOid(null);
+ codeClassifyTemplateButtonDO.setClassifyTemplateOid(templateNewOid);
+ }
+ return codeTempbuttonEntities;
+ }
+
+
+ /**
+ * 澶嶅埗妯℃澘灞炴��
+ */
+ public List<CodeClassifyTemplateAttr> copyTemplateAttr(String templateOldOid,String templateNewOid){
+
+// VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
+// codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid);
+
+// Map<String,Object> condition = new HashMap<>(1);
+// condition.put("classifyTemplateOid",templateOldOid);
+ QueryWrapper<CodeClassifyTemplateAttr> wrapper=new QueryWrapper<>();
+ wrapper.eq("classifyTemplateOid",templateOldOid);
+
+// List<CodeClassifyTemplateAttr> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery);
+ List<CodeClassifyTemplateAttr> codeClstempattrEntities = codeClstempattrMapper.selectList(wrapper);
+
+ for (CodeClassifyTemplateAttr codeClassifyTemplateAttrDO :codeClstempattrEntities){
+// String attrOid = VciBaseUtil.getPk();
+ codeClassifyTemplateAttrDO.setOid(null);
+ codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
+// codeClstempattrMapper.insert(codeClassifyTemplateAttrDO);
+ }
+ return codeClstempattrEntities;
+ }
+
+
+ /**
+ * 鍒嗙被妯℃澘鍒楄〃
+ *
+ * @param conditionMap 鏌ヨ鏉′欢
+ * @param pageHelper 鍒嗛〉瀵硅薄
+ * @return 鏄剧ず瀵硅薄
+ * @throws VciBaseException 鏌ヨ鍑洪敊鐨勬椂鍊欎細鎶涘嚭寮傚父
+ */
+ @Override
+ public DataGrid<CodeClassifyTemplateVO> gridCodeClassifyTemplate(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
+ DataGrid<CodeClassifyTemplateVO> dataGrid=new DataGrid<CodeClassifyTemplateVO>();
+ //娌℃湁浼犲垎绫籭d锛屼笉鎵ц鏌ヨ閫昏緫锛岀洿鎺ヨ繑鍥�
+// if(conditionMap.size()==0){
+// dataGrid.setData(new ArrayList<>());
+// dataGrid.setTotal(0);
+// return dataGrid;
+// }
+// if (pageHelper == null) {
+// pageHelper = new PageHelper(-1);
+// }
+// pageHelper.addDefaultDesc("revisionSeq");
+
+// CodeClassifyTemplateVO codeClstemplateVO = new CodeClassifyTemplateVO();
+
+
+ CodeClassifyTemplate codeClstemplateQuery = new CodeClassifyTemplate();
+// BeanUtil.toBean(map,codeClstempattrVO);
+// BeanUtil
+ CodeClassifyTemplateDTO codeClassifyTemplateDTO = new CodeClassifyTemplateDTO();
+ BeanMap beanMap = BeanMap.create(codeClassifyTemplateDTO);
+ beanMap.putAll(conditionMap);
+// BeanUtils.copyProperties(codeClstemplateVO,codeClstemplateQuery);
+ BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClstemplateQuery);
+ if (pageHelper == null) {
+ pageHelper = new PageHelper(-1);
+ }
+// IPage iPage = new IPage();
+ Query query = new Query();
+// query.setSize(100);
+ if(pageHelper.getLimit() != -1){
+ query.setSize(pageHelper.getLimit());
+ query.setCurrent(pageHelper.getPage());
+ query.setDescs("versionValue");
+ }
+
+// List<CodeClstemplateVO> doList = codeClstemplateMapper.selectPlCodeClstemplatePage(Condition.getPage(query), codeClstemplateVO);
+
+ IPage<CodeClassifyTemplate> doList = baseMapper.
+ selectPage(Condition.getPage(query), Condition.getQueryWrapper(codeClstemplateQuery));
+ if (!CollectionUtils.isEmpty(doList.getRecords())) {
+// QueryWrapper<CodeClstemplateVO> codeClstemplateVOQueryWrapper = new QueryWrapper<>();
+// codeClstemplateVOQueryWrapper.allEq(plCodeClstemplate);
+// List<CodeClstemplateEntity> codeClstemplateEntity = new ArrayList<>();
+// BeanUtils.copyProperties(doList,codeClstemplateEntity);
+
+ dataGrid.setData(codeClassifyTemplateDO2VOs(doList.getRecords()));
+ dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(codeClassifyTemplateMapper.selectCount(Condition.getQueryWrapper(codeClstemplateQuery)))));
+ }
+ return dataGrid;
+ }
+
+
+ /**
+ * 澧炲姞鍒嗙被妯℃澘瀵硅薄
+ * @param codeClassifyTemplateDTO 鍒嗙被妯℃澘瀵硅薄鏁版嵁浼犺緭瀵硅薄
+ * @return 鎵ц缁撴灉
+ * @throws VciBaseException 鍙傛暟涓虹┖锛屽敮涓�椤癸紝蹇呰緭椤逛笉閫氳繃鏃朵細鎶涘嚭寮傚父
+ */
+ @Override
+ public R<CodeClassifyTemplateVO> addSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
+ VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"闇�瑕佹坊鍔犵殑鏁版嵁瀵硅薄");
+
+ QueryWrapper<CodeClassifyTemplate> wrapper = new QueryWrapper<>();
+ wrapper.eq("CODECLASSIFYOID",codeClassifyTemplateDTO.getCodeclassifyoid());
+ Long aLong = baseMapper.selectCount(wrapper);
+ if(aLong > 0){
+ return R.fail("璇ュ垎绫讳笅宸叉湁瀛愭ā鐗堬紝鏃犳硶鏂板锛屼粎鑳借繘琛屽崌鐗堟搷浣滐紒");
+ }
+ //灏咲TO杞崲涓篋O
+ CodeClassifyTemplate codeClassifyTemplateDO = new CodeClassifyTemplate();
+ BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDO);
+
+ //鏌ヨ鍒嗙被浠ュ強涓婄骇鍒嗙被鐨勪笟鍔＄被鍨媌tmtypeid銆乥tmtypename
+ List<CodeClassify> codeClassifyDOList = codeClassifyService.selectAllLevelParents(codeClassifyTemplateDTO.getCodeclassifyoid());
+
+ //鎵�鏈夊垎绫婚兘娌℃湁涓氬姟绫诲瀷锛岃繑鍥炴彁绀�
+ if(codeClassifyDOList.size()==0){
+ return R.fail(DATA_OID_NOT_EXIST);
+ }
+
+ //璁剧疆btmtypeid鍜宯ame
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeClassifyTemplateDO, MdmBtmTypeConstant.CODE_CLASSIFY_TEMPLATE);
+ CodeClassify codeClassifyDO = codeClassifyDOList.stream().filter(s -> StringUtils.isNotBlank(s.getBtmTypeId())).findFirst().get();
+ codeClassifyTemplateDO.setBtmTypeId(codeClassifyDO.getBtmTypeId());
+ codeClassifyTemplateDO.setBtmTypeName(codeClassifyDO.getBtmTypeName());
+ codeClassifyTemplateDO.setLcStatus(FRAMEWORK_RELEASE_EDITING);
+ codeClassifyTemplateDO.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
+ codeClassifyTemplateDO.setLctid("codeClsTempLc");
+ codeClassifyTemplateDO.setRevisionRule("numberversionrule");
+
+ baseMapper.insert(codeClassifyTemplateDO);
+ //榛樿娣诲姞妯℃澘灞炴��
+// List<CodeClassifyTemplateAttrDO> attrDOList = new ArrayList<>();
+
+// CodeClassifyTemplateAttrDO codeAttr = new CodeClassifyTemplateAttrDO();
+// codeAttr.setId("id");
+// codeAttr.setName("浼佷笟缂栫爜");
+// codeAttr.setAttributeDataType("VTString");
+// codeAttr.setAttrTableWidth(150);
+// codeAttr.setOrderNum(1);
+// codeAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
+// codeAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
+// codeAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
+// attrDOList.add(codeAttr);
+//
+//
+// CodeClassifyTemplateAttrDO groupAttr = new CodeClassifyTemplateAttrDO();
+// groupAttr.setId("name");
+// groupAttr.setName("闆嗗洟鐮�");
+// groupAttr.setAttributeDataType("VTString");
+// groupAttr.setAttrTableWidth(150);
+// groupAttr.setOrderNum(2);
+// groupAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
+// groupAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
+// groupAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
+// attrDOList.add(groupAttr);
+//
+// CodeClassifyTemplateAttrDO descAttr = new CodeClassifyTemplateAttrDO();
+// descAttr.setId("description");
+// descAttr.setName("鎻忚堪");
+// descAttr.setAttrTableWidth(150);
+// descAttr.setAttributeDataType("VTString");
+// descAttr.setOrderNum(3);
+// descAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
+// descAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
+// descAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
+// attrDOList.add(descAttr);
+//
+// CodeClassifyTemplateAttrDO statusAttr = new CodeClassifyTemplateAttrDO();
+// statusAttr.setId("lcstatus");
+// statusAttr.setName("鐘舵��");
+// statusAttr.setAttrTableWidth(70);
+// statusAttr.setOrderNum(4);
+// statusAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
+// statusAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
+// statusAttr.setAttributeDataType("VTString");
+// statusAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
+// attrDOList.add(statusAttr);
+//
+//
+// CodeClassifyTemplateAttrDO secAttr = new CodeClassifyTemplateAttrDO();
+// secAttr.setId("secretgrade");
+// secAttr.setName("瀵嗙骇");
+// secAttr.setAttrTableWidth(70);
+// secAttr.setAttributeDataType(VciFieldTypeEnum.VTInteger.name());
+// secAttr.setEnumId("Enumsecretgrade");
+// secAttr.setEnumName("瀵嗙骇");
+// secAttr.setOrderNum(4);
+// secAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
+// secAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
+// secAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
+// attrDOList.add(secAttr);
+
+ return R.data(codeClassifyTemplateDO2VO(codeClassifyTemplateDO));
+ }
+
+ /**
+ * 淇敼鍒嗙被妯℃澘瀵硅薄
+ * @param codeClassifyTemplateDTO 鍒嗙被妯℃澘瀵硅薄鏁版嵁浼犺緭瀵硅薄
+ * @return 鎵ц缁撴灉
+ * @throws VciBaseException 鍙傛暟涓虹┖锛屽敮涓�椤癸紝蹇呰緭椤逛笉閫氳繃鏃朵細鎶涘嚭寮傚父
+ */
+ @Override
+ public R editSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
+ VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"鏁版嵁瀵硅薄",codeClassifyTemplateDTO.getOid(),"鍒嗙被妯℃澘瀵硅薄涓婚敭");
+ //妫�鏌s
+ CodeClassifyTemplate codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplate();
+ BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDOCopyFromDTO);
+ CodeClassifyTemplate codeClassifyTemplateDO = null;
+ if(codeClassifyTemplateDOCopyFromDTO.getOid() == null){
+ baseMapper.insert(codeClassifyTemplateDOCopyFromDTO);
+ return R.data(codeClassifyTemplateDOCopyFromDTO);
+ }else{
+// Map<String,Object> condition = new HashMap<>(2);
+// condition.put("oid",codeClassifyTemplateDOCopyFromDTO.getOid());
+// condition.put("ts",codeClassifyTemplateDOCopyFromDTO.getTs());
+ CodeClassifyTemplate detail = baseMapper
+ .selectById(codeClassifyTemplateDOCopyFromDTO.getOid());
+ // boolean tsBoolean = boService.checkTs(codeClassifyTemplateAttrDOListemplateDOCopyFromDTO);
+ if(detail.getTs().compareTo(codeClassifyTemplateDOCopyFromDTO.getTs()) != 0){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
+ return R.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+ }
+
+ //灏咲TO杞崲涓篋O
+ codeClassifyTemplateDO = selectByOid(codeClassifyTemplateDTO.getOid());
+ String lcstatus = codeClassifyTemplateDO.getLcStatus();
+ String versionvalue = codeClassifyTemplateDO.getVersionValue();
+
+ //鍙湁缂栬緫涓墠鑳戒慨鏀�
+ if(!CodeClassifyTemplateLC.EDITING.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
+ return R.fail("鍙湁缂栬緫涓殑锛屾ā鏉挎墠鑳戒慨鏀癸紒");
+ }
+ revisionModelUtil.copyFromDTOIgnore(codeClassifyTemplateDTO,codeClassifyTemplateDO);
+ //涓嶄慨鏀圭増鏈彿鍜岀姸鎬�
+ codeClassifyTemplateDO.setLcStatus(lcstatus);
+ codeClassifyTemplateDO.setVersionValue(versionvalue);
+ codeClassifyTemplateDO.setTs(new Date());
+ codeClassifyTemplateDO.setLastModifier(AuthUtil.getUser().getAccount());
+ codeClassifyTemplateDO.setLastModifyTime(new Date());
+ baseMapper.updateById(codeClassifyTemplateDO);
+ }
+ return R.data(codeClassifyTemplateDO2VO(codeClassifyTemplateDO));
+ }
+
+ /**
+ *鏍规嵁鐖跺垎绫籭d鍘绘煡鎵惧彾瀛愯妭鐐圭殑妯℃澘锛屽鏋滄病鏌ュ埌鍒欒涓烘ā鏉垮湪涓婂眰寤虹珛锛屽垯鏍规嵁鍒嗙被鍘绘煡褰撳墠妯℃澘
+ * @param codeClassifyOid 鐖跺垎绫荤殑涓婚敭
+ * @return
+ */
+ @Override
+ public List<CodeClassifyTemplateVO> childTemplates(String codeClassifyOid){
+ List<CodeClassifyTemplateVO> codeClassifyTemplateVOList=new ArrayList<>();
+// Map<String/**妯℃澘鐨勪富閿�**/,String/**鍒嗙被鐨勪富閿�**/> childHasTemplateMap =baseMapper
+// .selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED,
+// codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue());
+ List<Map<String,String>> childHasTemplateList = baseMapper
+ .selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED,
+ codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue());
+ Map<String/**妯℃澘鐨勪富閿�**/,String/**鍒嗙被鐨勪富閿�**/> childHasTemplateMap = new HashMap<>();
+ if(!CollectionUtils.isEmpty(childHasTemplateList)){
+ childHasTemplateList.stream().forEach(cbo->{
+ // 鏈夋椂鍊欐煡璇㈠嚭鏉ョ殑key鏄ぇ鍐欙紝鏈夋椂鍊欐槸灏忓啓鐨刱ey
+ String oid = Func.isEmpty(cbo.get("OID")) ? cbo.get("oid"):cbo.get("OID");
+ String clsoid = Func.isEmpty(cbo.get("CLSOID")) ? cbo.get("clsoid") : cbo.get("CLSOID");
+ childHasTemplateMap.put(oid,clsoid);
+ });
+ }
+
+ Set<String> templateOid = childHasTemplateMap.keySet();
+ List<CodeClassifyTemplate> classifyTemplateDOS=new ArrayList<>();
+ if(!CollectionUtils.isEmpty(templateOid)) {
+ classifyTemplateDOS= this.listCodeClassifyTemplateDOByOidCollections(templateOid);
+ }else{
+ classifyTemplateDOS=selectOnlyTemplateByClassifyOid(codeClassifyOid);
+ }
+ List<CodeClassifyTemplateVO> templateVOList = codeClassifyTemplateDO2VOs(classifyTemplateDOS, true);
+ if(!CollectionUtils.isEmpty(templateVOList)){
+ codeClassifyTemplateVOList.addAll(templateVOList);
+ }
+ return codeClassifyTemplateVOList;
+ }
+
+ /**
+ * 浣跨敤鍒嗙被涓婚敭閫掑綊鏌ヨ
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @return 妯℃澘鐨勬暟鎹璞�
+ */
+ private List<CodeClassifyTemplate> selectOnlyTemplateByClassifyOid(String codeClassifyOid){
+ //1.鐩存帴鏌ヨ锛岀湅鐪嬭繖涓垎绫讳笅闈㈡湁娌℃湁鍙戝竷鐘舵�佺殑妯℃澘
+ //2.濡傛灉娌℃湁锛屽垯寰�涓婃壘鍒嗙被鐨勫唴瀹癸紝杩欎釜鍒嗙被灞傜骇涓嶄細澶锛屾墍浠ョ洿鎺ラ�掑綊鍗冲彲
+ //3.濡傛灉鍒嗙被涓嬮潰娣诲姞浜嗘ā鏉匡紝浣嗘槸娌℃湁鍙戝竷锛屽垯璇存槑妯℃澘鍙兘杩樺湪缂栬緫鐨勭姸鎬侊紝渚濈劧浣跨敤涓婄骇鍒嗙被
+
+// Map<String,String> conditionMap = new HashMap<>();
+// conditionMap.put("codeClassifyOid",codeClassifyOid);
+// conditionMap.put("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue());
+ QueryWrapper<CodeClassifyTemplate> wrapper=new QueryWrapper<>();
+ wrapper.eq("codeClassifyOid",codeClassifyOid)
+ .eq("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue());
+
+ List<CodeClassifyTemplate> templateDOS = baseMapper.selectList(wrapper);
+ if(CollectionUtils.isEmpty(templateDOS)){
+ //閫掑綊鎵句笂绾х殑妯℃澘
+ CodeClassify classifyDO = codeClassifyMapper.selectById(codeClassifyOid);
+// codeClassifyDaoI.selectByPrimaryKey(codeClassifyOid);
+ if(Func.isEmpty(classifyDO)){
+ //璇存槑宸茬粡鏄《浜嗭紝涔熸病鎵惧埌鐨勮瘽锛岄偅灏辫繑鍥炰簡
+ return new ArrayList<>();
+ }
+ if(StringUtils.isNotBlank(classifyDO.getParentCodeClassifyOid())) {
+ return selectOnlyTemplateByClassifyOid(classifyDO.getParentCodeClassifyOid());
+ }else{
+ return new ArrayList<>();
+ }
+ }else{
+ return templateDOS;
+ }
+ }
+
+ /**
+ * 浣跨敤涓婚搴撶殑鍒嗙被涓婚敭锛岃幏鍙栫敓鏁堢殑妯℃澘
+ *
+ * @param codeClassifyOid 涓婚搴撳垎绫讳富閿�
+ * @param hasAttribute 鏄惁鍖呭惈灞炴��
+ * @return 妯℃澘鐨勪俊鎭�
+ */
+ @Override
+ public List<CodeClassifyTemplateVO> listReleaseTemplateByClassifyOid(String codeClassifyOid, boolean hasAttribute) {
+ VciBaseUtil.alertNotNull(codeClassifyOid,"涓婚搴撳垎绫讳富閿�");
+ List<CodeClassifyTemplate> templateDOS = selectOnlyTemplateByClassifyOid(codeClassifyOid);
+ if(CollectionUtils.isEmpty(templateDOS)){
+ throw new VciBaseException("褰撳墠鍒嗙被锛屼互鍙婂叾涓婄骇鍒嗙被閮芥病鏈夎缃ā鏉�");
+ }
+ List<CodeClassifyTemplateVO> templateVOList = codeClassifyTemplateDO2VOs(templateDOS, true);
+ return sortTemplateByRevision(templateVOList);
+ }
+
+ /**
+ * 鐢ㄦā鏉跨殑鐗堟湰鏉ユ帓搴�
+ * @param templateVOList 妯℃澘鐨勬樉绀哄璞�
+ * @return 鎺掑簭鍚庣殑鍒楄〃
+ */
+ @Override
+ public List<CodeClassifyTemplateVO> sortTemplateByRevision(List<CodeClassifyTemplateVO> templateVOList){
+ if(!CollectionUtils.isEmpty(templateVOList) && templateVOList.size() >1){
+ //鑾峰彇鐗堟湰鍙锋渶澶х殑閭ｄ釜
+ templateVOList = templateVOList.stream().sorted((o1,o2)->
+ Integer.valueOf(o1.getRevisionSeq()).compareTo(Integer.valueOf(o2.getRevisionValue()))
+ ).collect(Collectors.toList());
+ }
+ return templateVOList;
+ }
+
+ /**
+ * 涓婚敭鑾峰彇鍒嗙被妯℃澘瀵硅薄(鍖呭惈灞炴�э級
+ *
+ * @param oid 涓婚敭
+ * @return 鍒嗙被妯℃澘瀵硅薄鏄剧ず瀵硅薄
+ * @throws VciBaseException 鍙傛暟涓虹┖锛屾暟鎹笉瀛樺湪鏃朵細鎶涘嚭寮傚父
+ */
+ @Override
+ public CodeClassifyTemplateVO getObjectHasAttrByOid(String oid) throws VciBaseException {
+ List<CodeClassifyTemplate> doList = new ArrayList<>();
+ doList.add(selectByOid(oid));
+ List<CodeClassifyTemplateVO> templateVOS = codeClassifyTemplateDO2VOs(doList, true);
+ return CollectionUtils.isEmpty(templateVOS)?null:templateVOS.get(0);
+ }
}
--
Gitblit v1.9.3