/* * Copyright (c) 2018-2028, Chill Zhuang All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * Neither the name of the dreamlu.net developer nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * Author: Chill 庄骞 (smallchill@163.com) */ package com.vci.ubcs.code.service.impl; import com.alibaba.nacos.api.utils.StringUtils; 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.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.pagemodel.CodeClassifyTemplateAttrVO; import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO; 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.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 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.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; /** * 编码库定义-模板管理 服务实现类 * * @author yuxc * @since 2023-04-10 */ @Service public class CodeClstemplateServiceImpl extends ServiceImpl 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; @Override public IPage selectPlCodeClstemplatePage(IPage page, CodeClassifyTemplateVO plCodeClstemplate) { return page.setRecords(baseMapper.selectPlCodeClstemplatePage(page, plCodeClstemplate)); } /** * 查询分类模板对象 树 * @param treeQueryObject 树查询对象 * @return 分类模板对象 显示树 */ @Override public List treeCodeClassifyTemplate(TreeQueryObject treeQueryObject) { List doList =selectCodeClassifyTemplateDOByTree(treeQueryObject); List 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 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 codeClassifyTemplateDO2VOs(Collection codeClassifyTemplateDOs) { return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOs,false); } /** * 批量数据对象转换为显示对象 * @param codeClassifyTemplateDOs 数据对象列表 * @param hasAttr 是否包含属性 * @return 显示对象 */ @Override public List codeClassifyTemplateDO2VOs(Collection codeClassifyTemplateDOs, boolean hasAttr) { List voList = new ArrayList(); 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 attrVOList = codeClstempattrService.listCodeClassifyTemplateAttrByTemplateOids(tempOids); if(!CollectionUtils.isEmpty(attrVOList)){ Map> attrVOMap = attrVOList.stream().collect(Collectors.groupingBy(s -> s.getClassifyTemplateOid())); voList.stream().forEach(templateVO->{ if(attrVOMap.containsKey(templateVO.getOid())){ List 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); //如果有lcstatus的类的话 vo.setLcStatusText(CodeClassifyTemplateLC.getTextByValue(vo.getLcStatus())); } return vo; } /** * 检查 分类模板对象是否删除 * @param codeClstemplateDTO 分类模板对象数据传输对象，必须要有oid和ts属性 * @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级 */ @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为true为可以删除，false表示有数据引用，obj为true表示有下级 */ private R checkIsCanDeleteForDO(CodeClassifyTemplateDTO codeClstemplateDTO, CodeClassifyTemplate codeClassifyTemplate) { CodeClassifyTemplate codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplate(); BeanUtilForVCI.copyPropertiesIgnoreCase(codeClstemplateDTO,codeClassifyTemplateDOCopyFromDTO); //检查ts // Map 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 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 分类模板对象数据传输对象，oid和ts需要传输 * @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 childrenOids = baseMapper.selectAllLevelChildOid(codeClassifyTemplateDO.getOid().trim()); if (!CollectionUtils.isEmpty(childrenOids)) { Collection> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids); for (Collection 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 codeClstempattrEntityList = codeClstempattrMapper.selectRefByOid(templateOid); if(!CollectionUtils.isEmpty(codeClstempattrEntityList)) { List templateAttrOids = new ArrayList(); 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 listCodeClassifyTemplateByOids(List oidCollections) { VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合"); List codeClassifyTemplateDOList = listCodeClassifyTemplateDOByOidCollections(oidCollections); return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOList); } /** * 参照树 分类模板对象 * @param treeQueryObject 树形查询对象 * @return 分类模板对象显示树 */ @Transactional @Override public List 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 listCodeClassifyTemplateDOByOidCollections(Collection oidCollections){ List codeClassifyTemplateDOList = new ArrayList(); if(!CollectionUtils.isEmpty(oidCollections)){ Collection> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections); for(Collection oids: oidCollectionsList){ List 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)){ // CodeClstemplateEntity codeClassifyTemplateDO = baseMapper.selectById(oid); if(!CodeClassifyTemplateLC.RELEASED.getValue().equals(codeClassifyTemplateDO.getLcStatus())){ return R.fail("模板未启用，不能停用！"); } } //启用、停用 codeClassifyTemplateDO.setLcStatus(lcStatus); int u = baseMapper.updateById(codeClassifyTemplateDO); // codeClassifyTemplateMapper.updateLcStatus(oid,lcStatus); 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(1)); codeCls_template_insert.setFirstV(String.valueOf(1)); codeCls_template_insert.setLastV(String.valueOf(1)); codeCls_template_insert.setCreator(AuthUtil.getUser().getUserName()); codeCls_template_insert.setCreateTime(new Date()); codeCls_template_insert.setTs(new Date()); codeCls_template_insert.setLastModifier(AuthUtil.getUser().getUserName()); 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(AuthUtil.getUser().getUserName()); codeCls_template_insert.setCopyFromVersion(codeCls_template.getOid()); int insertCount = baseMapper.insert(codeCls_template_insert); //升版过后的模板oid String templateNewOid = codeCls_template_insert.getOid(); //需要复制的模板属性 //查询老模板下边的所有属性，赋值新模板oid Map condition = new HashMap<>(1); condition.put("classifyTemplateOid",templateOldOid); List codeClstempattrEntities = codeClstempattrMapper.selectByMap(condition); for (CodeClassifyTemplateAttr codeClassifyTemplateAttrDO :codeClstempattrEntities){ codeClassifyTemplateAttrDO.setOid(VciBaseUtil.getPk()); codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid); codeClstempattrMapper.insert(codeClassifyTemplateAttrDO); } //复制模板流程 List codeClassifyProcessTempDOList = copyTemplateProcess(templateOldOid,templateNewOid); //复制模板阶段，阶段属性 Map phase_attrMap = copyTemplatePhase_attr(templateOldOid,templateNewOid); List codeClassifyPhaseDOList = (ArrayList)phase_attrMap.get("phase");//模板阶段 List codePhaseAttrDOList = (ArrayList)phase_attrMap.get("phaseAttr");//阶段属性 //复制模板按钮 List codeClassifyTemplateButtonDOList = copyTemplateButton(templateOldOid,templateNewOid); //保存模板流程 if(!CollectionUtils.isEmpty(codeClassifyProcessTempDOList)) { codeClsflowtempServiceImpl.saveBatch(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,复制过来的新的分类oid String codeClassifyOid = codeClassifyDTO.getCodeclassifyoid(); //复制模板 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()); List codeClassifyTemplateDOList = new ArrayList<>(); codeClassifyTemplateDOList.add(codeClassifyTemplateDO_old); //复制模板属性 List codeClassifyTemplateAttrDOList = copyTemplateAttr(oldOid,newOid); //复制模板流程 List codeClassifyProcessTempDOList = copyTemplateProcess(oldOid,newOid); //复制模板阶段，阶段属性 Map phase_attrMap = copyTemplatePhase_attr(oldOid,newOid); List codeClassifyPhaseDOList = (ArrayList)phase_attrMap.get("phase");//模板阶段 List codePhaseAttrDOList = (ArrayList)phase_attrMap.get("phaseAttr");//阶段属性 //复制模板按钮 List codeClassifyTemplateButtonDOList = copyTemplateButton(oldOid,newOid); // baseMapper.insert(codeClassifyTemplateDOList); this.saveBatch(codeClassifyTemplateDOList); codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList); codeClsflowtempServiceImpl.saveBatch(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 getVersionValue(int verRuleName) { HashMap 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 copyTemplateProcess(String templateOldOid,String templateNewOid){ // VciQueryWrapperForDO processWrapper = new VciQueryWrapperForDO(CodeClassifyProcessTempDO.class); // processWrapper.addQueryMap("classifyTemplateOid",templateOldOid); // Map condition = new HashMap<>(1); // condition.put("classifyTemplateOid",templateOldOid); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("classifyTemplateOid",templateOldOid); List codeClsflowtempEntities = codeClsflowtempServiceImpl.list(wrapper); // List codeClassifyProcessTempDOList = codeClassifyProcessTempDaoI.selectByWrapper(processWrapper);//要保存的新的模板流程 for (CodeClassifyProcessTemp codeClassifyProcessTempDO:codeClsflowtempEntities){ // String newOid = VciBaseUtil.getPk(); codeClassifyProcessTempDO.setOid(null); //codeClassifyProcessTempDO.setCodeClassifyOid(templateNewOid); codeClassifyProcessTempDO.setClassifyTemplateOid(templateNewOid); // codeClsflowtempMapper.insert(codeClassifyProcessTempDO); //modify by lihang - @20220406 设置模板主键位置出错，导致升版的模板中的流程是空的。 } return codeClsflowtempEntities; } /** * 复制模板阶段，模板属性 * @param templateOldOid * @param templateNewOid * @return map phase:(List) phaseAttr:(List) */ public Map copyTemplatePhase_attr(String templateOldOid,String templateNewOid){ //模板阶段 // VciQueryWrapperForDO phaseWrapper = new VciQueryWrapperForDO(CodeTemplatePhaseDO.class); // phaseWrapper.addQueryMap("codeClassifyTemplateOid",templateOldOid); Map condition = new HashMap<>(1); condition.put("codeclassifyTemplateOid",templateOldOid); List codeTempphaseEntities = codeTempphaseMapper.selectByMap(condition); // List codeClassifyPhaseDOList = codeTemplatePhaseDaoI.selectByWrapper(phaseWrapper);//要保存的新的模板流程 Map phaseKeyMap = new HashMap();//需要复制的模板阶段属性,key:value,模板阶段老oid:模板属性新oid List phaseOidList = new ArrayList(); 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 codePhaseAttrDOList = new ArrayList(); if(!CollectionUtils.isEmpty(phaseOidList)){//size()==0下边方法会报错 // Map 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 copyTemplateButton(String templateOldOid,String templateNewOid){ Map condition = new HashMap<>(1); condition.put("classifyTemplateOid",templateOldOid); // VciQueryWrapperForDO buttonWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateButtonDO.class); // buttonWrapper.addQueryMap("classifyTemplateOid",templateOldOid); List codeTempbuttonEntities = codeTempbuttonMapper.selectByMap(condition); // List codeClassifyTemplateButtonDOList = codeClassifyTemplateButtonDaoI.selectByWrapper(buttonWrapper); for (CodeClassifyTemplateButton codeClassifyTemplateButtonDO:codeTempbuttonEntities){ // String newOid = VciBaseUtil.getPk(); codeClassifyTemplateButtonDO.setOid(null); codeClassifyTemplateButtonDO.setClassifyTemplateOid(templateNewOid); } return codeTempbuttonEntities; } /** * 复制模板属性 */ public List copyTemplateAttr(String templateOldOid,String templateNewOid){ // VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class); // codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid); // Map condition = new HashMap<>(1); // condition.put("classifyTemplateOid",templateOldOid); QueryWrapper wrapper=new QueryWrapper<>(); wrapper.eq("classifyTemplateOid",templateOldOid); // List codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery); List 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 gridCodeClassifyTemplate(Map conditionMap, PageHelper pageHelper) throws VciBaseException { DataGrid dataGrid=new DataGrid(); //没有传分类id，不执行查询逻辑，直接返回 // 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()); } // List doList = codeClstemplateMapper.selectPlCodeClstemplatePage(Condition.getPage(query), codeClstemplateVO); IPage doList = baseMapper. selectPage(Condition.getPage(query), Condition.getQueryWrapper(codeClstemplateQuery)); if (!CollectionUtils.isEmpty(doList.getRecords())) { // QueryWrapper codeClstemplateVOQueryWrapper = new QueryWrapper<>(); // codeClstemplateVOQueryWrapper.allEq(plCodeClstemplate); // List 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 addSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{ VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"需要添加的数据对象"); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("CODECLASSIFYOID",codeClassifyTemplateDTO.getCodeclassifyoid()); Long aLong = baseMapper.selectCount(wrapper); if(aLong > 0){ return R.fail("该分类下已有子模版，无法新增，仅能进行升版操作！"); } //将DTO转换为DO CodeClassifyTemplate codeClassifyTemplateDO = new CodeClassifyTemplate(); BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDO); //查询分类以及上级分类的业务类型btmtypeid、btmtypename List codeClassifyDOList = codeClassifyService.selectAllLevelParents(codeClassifyTemplateDTO.getCodeclassifyoid()); //所有分类都没有业务类型，返回提示 if(codeClassifyDOList.size()==0){ return R.fail("添加模板添加失败,分类和上级分类都没有关联业务类型！"); } //设置btmtypeid和name CodeClassify codeClassifyDO = codeClassifyDOList.get(0); codeClassifyTemplateDO.setBtmTypeId(codeClassifyDO.getBtmTypeId()); codeClassifyTemplateDO.setNameOid(VciBaseUtil.getPk()); codeClassifyTemplateDO.setBtmTypeName(codeClassifyDO.getBtmTypeName()); codeClassifyTemplateDO.setLcStatus(FRAMEWORK_RELEASE_EDITING); codeClassifyTemplateDO.setTs(new Date()); codeClassifyTemplateDO.setOwner(String.valueOf(AuthUtil.getUser().getUserId())); codeClassifyTemplateDO.setLctid("codeClsTempLc"); codeClassifyTemplateDO.setVersionValue("1"); codeClassifyTemplateDO.setVersionSeq(1); codeClassifyTemplateDO.setRevisionValue("1"); codeClassifyTemplateDO.setRevisionSeq(1); codeClassifyTemplateDO.setVersionRule("0"); codeClassifyTemplateDO.setRevisionRule("numberversionrule"); codeClassifyTemplateDO.setLastModifyTime(new Date()); codeClassifyTemplateDO.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId())); codeClassifyTemplateDO.setCreator(String.valueOf(AuthUtil.getUser().getUserId())); codeClassifyTemplateDO.setCreateTime(new Date()); codeClassifyTemplateDO.setLastV("1"); codeClassifyTemplateDO.setLastR("1"); codeClassifyTemplateDO.setFirstV("1"); codeClassifyTemplateDO.setFirstR("1"); codeClassifyTemplateDO.setBtmname("codeclstemplate"); baseMapper.insert(codeClassifyTemplateDO); //默认添加模板属性 // List 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(),"分类模板对象主键"); //检查ts CodeClassifyTemplate codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplate(); BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDOCopyFromDTO); CodeClassifyTemplate codeClassifyTemplateDO = null; if(codeClassifyTemplateDOCopyFromDTO.getOid() == null){ baseMapper.insert(codeClassifyTemplateDOCopyFromDTO); return R.data(codeClassifyTemplateDOCopyFromDTO); }else{ // Map 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("当前数据不是最新，请刷新后再修改！"); } //将DTO转换为DO 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().getUserName()); codeClassifyTemplateDO.setLastModifyTime(new Date()); baseMapper.updateById(codeClassifyTemplateDO); } return R.data(codeClassifyTemplateDO2VO(codeClassifyTemplateDO)); } /** *根据父分类id去查找叶子节点的模板，如果没查到则认为模板在上层建立，则根据分类去查当前模板 * @param codeClassifyOid 父分类的主键 * @return */ @Override public List childTemplates(String codeClassifyOid){ List codeClassifyTemplateVOList=new ArrayList<>(); // Map childHasTemplateMap =baseMapper // .selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED, // codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue()); List> childHasTemplateList =baseMapper .selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED, codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue()); Map childHasTemplateMap = new HashMap<>(); if(!CollectionUtils.isEmpty(childHasTemplateList)){ childHasTemplateList.stream().forEach(cbo->{ childHasTemplateMap.put(cbo.get("OID"),cbo.get("CLSOID")); }); } Set templateOid = childHasTemplateMap.keySet(); List classifyTemplateDOS=new ArrayList<>(); if(!CollectionUtils.isEmpty(templateOid)) { classifyTemplateDOS= this.listCodeClassifyTemplateDOByOidCollections(templateOid); }else{ classifyTemplateDOS=selectOnlyTemplateByClassifyOid(codeClassifyOid); } List templateVOList = codeClassifyTemplateDO2VOs(classifyTemplateDOS, true); if(!CollectionUtils.isEmpty(templateVOList)){ codeClassifyTemplateVOList.addAll(templateVOList); } return codeClassifyTemplateVOList; } /** * 使用分类主键递归查询 * @param codeClassifyOid 分类的主键 * @return 模板的数据对象 */ private List selectOnlyTemplateByClassifyOid(String codeClassifyOid){ //1.直接查询，看看这个分类下面有没有发布状态的模板 //2.如果没有，则往上找分类的内容，这个分类层级不会太多，所以直接递归即可 //3.如果分类下面添加了模板，但是没有发布，则说明模板可能还在编辑的状态，依然使用上级分类 // Map conditionMap = new HashMap<>(); // conditionMap.put("codeClassifyOid",codeClassifyOid); // conditionMap.put("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue()); QueryWrapper wrapper=new QueryWrapper<>(); wrapper.eq("codeClassifyOid",codeClassifyOid) .eq("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue()); List templateDOS = baseMapper.selectList(wrapper); if(CollectionUtils.isEmpty(templateDOS)){ //递归找上级的模板 CodeClassify classifyDO = codeClassifyMapper.selectById(codeClassifyOid); // codeClassifyDaoI.selectByPrimaryKey(codeClassifyOid); if(StringUtils.isBlank(classifyDO.getParentCodeClassifyOid())){ //说明已经是顶了，也没找到的话，那就返回了 return null; } return selectOnlyTemplateByClassifyOid(classifyDO.getParentCodeClassifyOid()); }else{ return templateDOS; } } /** * 使用主题库的分类主键，获取生效的模板 * * @param codeClassifyOid 主题库分类主键 * @param hasAttribute 是否包含属性 * @return 模板的信息 */ @Override public List listReleaseTemplateByClassifyOid(String codeClassifyOid, boolean hasAttribute) { VciBaseUtil.alertNotNull(codeClassifyOid,"主题库分类主键"); List templateDOS = selectOnlyTemplateByClassifyOid(codeClassifyOid); if(CollectionUtils.isEmpty(templateDOS)){ throw new VciBaseException("当前分类，以及其上级分类都没有设置模板"); } List templateVOList = codeClassifyTemplateDO2VOs(templateDOS, true); return sortTemplateByRevision(templateVOList); } /** * 用模板的版本来排序 * @param templateVOList 模板的显示对象 * @return 排序后的列表 */ @Override public List sortTemplateByRevision(List 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 doList = new ArrayList<>(); doList.add(selectByOid(oid)); List templateVOS = codeClassifyTemplateDO2VOs(doList, true); return CollectionUtils.isEmpty(templateVOS)?null:templateVOS.get(0); } }