package com.vci.ubcs.code.service.impl; import com.vci.corba.common.VCIError; import com.vci.frameworkcore.lcstatuspck.FrameworkDataLCStatus; 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.BeanUtilForVCI; import com.vci.starter.web.util.VciBaseUtil; import com.vci.starter.web.wrapper.VciParentQueryOption; import com.vci.starter.web.wrapper.VciQueryWrapperForDO; import com.vci.ubcs.code.dto.CodeClassifyTemplateDTO; import com.vci.ubcs.code.lifecycle.CodeClassifyTemplateLC; import com.vci.ubcs.code.mapper.*; import com.vci.ubcs.code.entity.*; import com.vci.ubcs.code.service.*; import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO; import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO; import com.vci.web.pageModel.BatchCBO; import com.vci.web.service.WebBoServiceI; import com.vci.web.util.WebUtil; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; import org.springframework.util.CollectionUtils; import plm.bs.bom.clientobject.ClientBusinessObject; import plm.bs.bom.clientobject.ClientBusinessObjectOperation; import javax.annotation.Resource; import java.util.*; import java.util.stream.Collectors; import static com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant.*; import static com.vci.frameworkcore.constant.FrameWorkLangCodeConstant.*; /** * 分类模板对象服务 * @author weidy * @date 2022-01-24 */ @Service public class CodeClassifyTemplateServiceImpl implements CodeClassifyTemplateServiceI { /** * 日志 */ private Logger logger = LoggerFactory.getLogger(getClass()); /** * 数据操作层 */ @Resource private CodeClassifyTemplateMapper codeClassifyTemplateMapper; /** * 模板流程操作层 */ @Resource private CodeClassifyProcessTempMapper codeClassifyProcessTempDaoI; /** * 模板流程操作层 */ @Resource private CodeTemplatePhaseMapper codeTemplatePhaseDaoI; /** * 模板流程操作层 */ @Resource private CodeClassifyTemplateButtonMapper codeClassifyTemplateButtonDaoI; /** * 模板流程操作层 */ @Resource private CodePhaseAttrMapper codePhaseAttrDaoI; /** * 分类 */ @Resource private CodeClassifyMapper codeClassifyDaoI; /** * 模板阶段 */ @Resource private CodeTemplatePhaseServiceI codeTemplatePhaseServiceI; /** * 模板流程 */ @Resource private CodeClassifyProcessTempServiceI codeClassifyProcessTempServiceI; /** * 模板按钮 */ @Resource private CodeClassifyTemplateButtonServiceI codeClassifyTemplateButtonServiceI; /** * 模板属性 */ @Resource private CodeClassifyTemplateAttrMapper codeClassifyTemplateAttrDaoI; /** * 模板属性的服务 */ @Lazy @Autowired(required = false) private CodeClassifyTemplateAttrServiceI templateAttrService; /** * 业务类型操作的服务 */ @Autowired @Lazy private WebBoServiceI boService; /** * 对象的操作 */ @Autowired private RevisionModelUtil revisionModelUtil; /** * 上级节点的属性名称 */ private static final String PARENT_FIELD_NAME = ""; /** * 查询分类模板对象 树 * @param treeQueryObject 树查询对象 * @return 分类模板对象 显示树 * @throws VciBaseException 查询条件不符合要求的时候会抛出异常 */ @Override public List treeCodeClassifyTemplate(TreeQueryObject treeQueryObject) throws VciBaseException{ 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); return codeClassifyTemplateMapper.selectByWrapper(queryWrapperForDO); } /** * 批量数据对象转换为显示对象 * @param codeClassifyTemplateDOs 数据对象列表 * @return 显示对象 * @throws VciBaseException 参数为空或者不存在的时候会抛出异常 */ @Override public List codeClassifyTemplateDO2VOs(Collection codeClassifyTemplateDOs) throws VciBaseException{ return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOs,false); } /** * 批量数据对象转换为显示对象 * @param codeClassifyTemplateDOs 数据对象列表 * @param hasAttr 是否包含属性 * @return 显示对象 * @throws VciBaseException 参数为空或者不存在的时候会抛出异常 */ @Override public List codeClassifyTemplateDO2VOs(Collection codeClassifyTemplateDOs,boolean hasAttr) throws VciBaseException{ List voList = new ArrayList(); if(!CollectionUtils.isEmpty(codeClassifyTemplateDOs)){ for(CodeClassifyTemplateDO 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 = templateAttrService.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())){ templateVO.setAttributes(attrVOMap.get(templateVO.getOid())); } }); } }); } return voList; } /** * 数据对象转换为显示对象 * @param codeClassifyTemplateDO 数据对象 * @return 显示对象 * @throws VciBaseException 拷贝属性出错的时候会抛出异常 */ @Override public CodeClassifyTemplateVO codeClassifyTemplateDO2VO(CodeClassifyTemplateDO codeClassifyTemplateDO) throws VciBaseException{ CodeClassifyTemplateVO vo = new CodeClassifyTemplateVO(); if(codeClassifyTemplateDO != null){ BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDO,vo); //如果有lcstatus的类的话 vo.setLcStatusText(CodeClassifyTemplateLC.getTextByValue(vo.getLcStatus())); } return vo; } /** * 增加分类模板对象 * @param codeClassifyTemplateDTO 分类模板对象数据传输对象 * @return 执行结果 * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常 */ @Override public BaseResult addSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{ VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"需要添加的数据对象"); //将DTO转换为DO CodeClassifyTemplateDO codeClassifyTemplateDO = new CodeClassifyTemplateDO(); BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDO); //查询分类以及上级分类的业务类型btmtypeid、btmtypename List codeClassifyDOList = codeClassifyDaoI.selectAllLevelParents(codeClassifyTemplateDTO.getCodeclassifyoid()); //所有分类都没有业务类型，返回提示 if(codeClassifyDOList.size()==0){ return BaseResult.fail("添加模板添加失败,分类和上级分类都没有关联业务类型！"); } //设置btmtypeid和name CodeClassifyDO codeClassifyDO = codeClassifyDOList.get(0); codeClassifyTemplateDO.setBtmTypeId(codeClassifyDO.getBtmTypeId()); codeClassifyTemplateDO.setBtmTypeName(codeClassifyDO.getBtmTypeName()); codeClassifyTemplateDO.setLcStatus(FRAMEWORK_RELEASE_EDITING); codeClassifyTemplateMapper.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 BaseResult.success(codeClassifyTemplateDO2VO(codeClassifyTemplateDO)); } /** * 修改分类模板对象 * @param codeClassifyTemplateDTO 分类模板对象数据传输对象 * @return 执行结果 * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常 */ @Override public BaseResult editSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{ VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"数据对象",codeClassifyTemplateDTO.getOid(),"分类模板对象主键"); //检查ts CodeClassifyTemplateDO codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplateDO(); BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDOCopyFromDTO); boolean tsBoolean = boService.checkTs(codeClassifyTemplateDOCopyFromDTO); if(!tsBoolean){//不是最新的不让改 return BaseResult.fail("当前数据不是最新，请刷新后再修改！"); } //将DTO转换为DO CodeClassifyTemplateDO codeClassifyTemplateDO = selectByOid(codeClassifyTemplateDTO.getOid()); String lcstatus = codeClassifyTemplateDO.getLcStatus(); String versionvalue = codeClassifyTemplateDO.getVersionValue(); //只有编辑中才能修改 if(!CodeClassifyTemplateLC.EDITING.getValue().equals(codeClassifyTemplateDO.getLcStatus())){ return BaseResult.fail("只有编辑中的，模板才能修改！"); } revisionModelUtil.copyFromDTOIgnore(codeClassifyTemplateDTO,codeClassifyTemplateDO); //不修改版本号和状态 codeClassifyTemplateDO.setLcStatus(lcstatus); codeClassifyTemplateDO.setVersionValue(versionvalue); codeClassifyTemplateMapper.updateByPrimaryKey(codeClassifyTemplateDO); return BaseResult.success(codeClassifyTemplateDO2VO(codeClassifyTemplateDO)); } /** * 检查 分类模板对象是否删除 * @param codeClassifyTemplateDTO 分类模板对象数据传输对象，必须要有oid和ts属性 * @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级 * @throws VciBaseException 参数为空，被引用时抛出异常 */ @Override public BaseResult checkIsCanDelete(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{ VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"数据传输对象",codeClassifyTemplateDTO.getOid(),"主键"); CodeClassifyTemplateDO codeClassifyTemplateDO = selectByOid(codeClassifyTemplateDTO.getOid()); return checkIsCanDeleteForDO(codeClassifyTemplateDTO,codeClassifyTemplateDO); } /** * 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除 * @param codeClassifyTemplateDTO 数据传输对象 * @param codeClassifyTemplateDO 数据库中的数据对象 * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级 */ private BaseResult checkIsCanDeleteForDO(CodeClassifyTemplateDTO codeClassifyTemplateDTO, CodeClassifyTemplateDO codeClassifyTemplateDO) { CodeClassifyTemplateDO codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplateDO(); BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDOCopyFromDTO); boService.checkTs(codeClassifyTemplateDOCopyFromDTO); //校验下级是否有引用 if(checkChildIsLinked(codeClassifyTemplateDO.getOid())){ return BaseResult.fail(DATA_CASCADE_LINKED_NOT_DELETE,new String[]{""}); } return BaseResult.success(checkHasChild(codeClassifyTemplateDO.getOid())); } /** * 检查是否有下级是否关联了数据 * * @param oid 主键 * @return true 表示有引用，false表示没有引用 * @throws VciBaseException 参数为空和有引用的时候会抛出异常 */ @Override public boolean checkChildIsLinked(String oid) throws VciBaseException { VciBaseUtil.alertNotNull(oid,"主键"); List childOids = codeClassifyTemplateMapper.selectAllLevelChildOid(oid.trim()); if(!CollectionUtils.isEmpty(childOids)){ for(String childOid: childOids){ if(!checkIsLinked(childOid)){ return false; } } return true; } return false; } /** * 校验是否有下级节点，不校验是否关联了数据 * * @param oid 主键 * @return true表示有下级，false表示没有下级 * @throws VciBaseException 参数错误，或者数据不存在的时候会抛出异常 */ @Override public boolean checkHasChild(String oid) throws VciBaseException { VciBaseUtil.alertNotNull(oid,"主键"); return codeClassifyTemplateMapper.countAllLevelChildOid(oid.trim()) > 0; } /** * 校验是否被引用 * @param oid 主键 * @throws VciBaseException 被引用的时候会抛出异常 */ private boolean checkIsLinked(String oid) throws VciBaseException{ //TODO 添加需要校验引用的地方 return false; } /** * 删除分类模板对象 * @param codeClassifyTemplateDTO 分类模板对象数据传输对象，oid和ts需要传输 * @return 删除结果反馈：：success：成功，fail：失败 * @throws VciBaseException 参数为空，被引用时抛出异常 */ @Override public BaseResult deleteCodeClassifyTemplate(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{ checkIsCanDelete(codeClassifyTemplateDTO); VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"分类模板对象数据对象",codeClassifyTemplateDTO.getOid(),"分类模板对象的主键"); CodeClassifyTemplateDO codeClassifyTemplateDO = selectByOid(codeClassifyTemplateDTO.getOid()); //只有编辑中才能删 if(!CodeClassifyTemplateLC.EDITING.getValue().equals(codeClassifyTemplateDO.getLcStatus())){ return BaseResult.fail("只有编辑中的，模板才能删除！"); } BaseResult baseResult = checkIsCanDeleteForDO(codeClassifyTemplateDTO,codeClassifyTemplateDO); //模板oid String templateOid = codeClassifyTemplateDTO.getOid(); WebUtil.setPersistence(false);//不执行保存 BatchCBO batchCBO = new BatchCBO(); if(baseResult.isSuccess()) { //找下级的，这个是可以删除的时候 List childrenOids = codeClassifyTemplateMapper.selectAllLevelChildOid(codeClassifyTemplateDO.getOid().trim()); if (!CollectionUtils.isEmpty(childrenOids)) { Collection> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids); for (Collection s : childrenCollections) { BatchCBO batchCBOi = codeClassifyTemplateMapper.batchDeleteByOids(s); batchCBO.copyFromOther(batchCBOi); } } }else{ return baseResult; } //执行删除操作 BatchCBO batchCBO_delete = codeClassifyTemplateMapper.deleteByPrimaryKey(codeClassifyTemplateDO.getOid()); batchCBO.copyFromOther(batchCBO_delete); //删除模板属性 VciQueryWrapperForDO templateQueryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class); templateQueryWrapper.addQueryMap("classifyTemplateOid",templateOid); List codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(templateQueryWrapper); if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrDOList)) { List templateAttrOids = new ArrayList(); for (CodeClassifyTemplateAttrDO codeClassifyTemplateAttrDO:codeClassifyTemplateAttrDOList){ templateAttrOids.add(codeClassifyTemplateAttrDO.getOid()); } BatchCBO batchCBO_templateAttr_delete = codeClassifyTemplateAttrDaoI.batchDeleteByOids(templateAttrOids); batchCBO.copyFromOther(batchCBO_templateAttr_delete); } //调用模板阶段方法 BatchCBO batchCBO_phase = codeTemplatePhaseServiceI.codeTemplateDeleteTrigger(templateOid); batchCBO.copyFromOther(batchCBO_phase); //调用模板按钮方法 BatchCBO batchCBO_button = codeClassifyTemplateButtonServiceI.codeTemplateDeleteTrigger(templateOid); batchCBO.copyFromOther(batchCBO_button); //调用模板流程方法 BatchCBO batchCBO_process = codeClassifyProcessTempServiceI.codeTemplateDeleteTrigger(templateOid); batchCBO.copyFromOther(batchCBO_process); WebUtil.setPersistence(true);//执行保存 boService.persistenceBatch(batchCBO);//一起执行保存 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 CodeClassifyTemplateVO getObjectByOid(String oid) throws VciBaseException{ return codeClassifyTemplateDO2VO(selectByOid(oid)); } /** * 主键获取分类模板对象(包含属性） * * @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); } /** * 主键查询数据对象 * @param oid 主键 * @return 数据对象 * @throws VciBaseException 参数为空，并且数据不存在的时候会抛出异常 */ private CodeClassifyTemplateDO selectByOid(String oid) throws VciBaseException{ VciBaseUtil.alertNotNull(oid,"主键"); CodeClassifyTemplateDO codeClassifyTemplateDO = codeClassifyTemplateMapper.selectByPrimaryKey(oid.trim()); if(codeClassifyTemplateDO == null || StringUtils.isBlank(codeClassifyTemplateDO.getOid())){ throw new VciBaseException(DATA_OID_NOT_EXIST); } return codeClassifyTemplateDO; } /** * 主键批量获取分类模板对象 * @param oidCollections 主键集合，但是受性能影响，建议一次查询不超过10000个 * @return 分类模板对象显示对象 * @throws VciBaseException 查询出现异常时会抛出 */ @Override public Collection listCodeClassifyTemplateByOids(Collection oidCollections) throws VciBaseException{ VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合"); List codeClassifyTemplateDOList = listCodeClassifyTemplateDOByOidCollections(oidCollections); return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOList); } /** * 使用主键集合查询数据对象 * @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 = codeClassifyTemplateMapper.selectByPrimaryKeyCollection(oids); if(!CollectionUtils.isEmpty(tempDOList)){ codeClassifyTemplateDOList.addAll(tempDOList); } } } return codeClassifyTemplateDOList; } /** * 参照树 分类模板对象 * @param treeQueryObject 树形查询对象 * @return 分类模板对象显示树 * @throws VciBaseException 查询条件和分页出错的时候会抛出异常 */ @Override public List 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); } treeQueryObject.getConditionMap().put(LC_STATUS,CodeClassifyTemplateLC.RELEASED.getValue()); return treeCodeClassifyTemplate(treeQueryObject); } /** * 分类模板列表 * * @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"); List doList = codeClassifyTemplateMapper.selectByCondition(conditionMap,pageHelper); if (!CollectionUtils.isEmpty(doList)) { dataGrid.setData(codeClassifyTemplateDO2VOs(doList)); dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(codeClassifyTemplateMapper.countByCondition(conditionMap)))); } return dataGrid; } /** * 启用、停用 * @param oid * @param lcStatus * @return */ @Override public BaseResult updateLcStatus( String oid, String lcStatus){ //停用的时候，验证模板是否为已发布 if(CodeClassifyTemplateLC.DISABLED.getValue().equals(lcStatus)){ CodeClassifyTemplateDO codeClassifyTemplateDO = codeClassifyTemplateMapper.selectByPrimaryKey(oid); if(!CodeClassifyTemplateLC.RELEASED.getValue().equals(codeClassifyTemplateDO.getLcStatus())){ return BaseResult.fail("模板未启用，不能停用！"); } } //启用、停用 int u = codeClassifyTemplateMapper.updateLcStatus(oid,lcStatus); return u==0?BaseResult.error("修改失败！"):BaseResult.success("修改成功"); } /** * 升版 * @param codeClassifyDTO */ @Override public BaseResult Upgrade(CodeClassifyTemplateDTO codeClassifyDTO){ //旧的模板oid String templateOldOid = codeClassifyDTO.getOid(); //只有已发布的才能升版 CodeClassifyTemplateDO codeClassifyTemplateDOOld = codeClassifyTemplateMapper.selectByPrimaryKey(templateOldOid); if(!FRAMEWORK_RELEASE_RELEASED.equals(codeClassifyTemplateDOOld.getLcStatus())){ return BaseResult.fail("该模板未发布，不能升版！"); } ClientBusinessObjectOperation clientBusinessObjectOperation = new ClientBusinessObjectOperation(); //需要新增的升级模板 ClientBusinessObject clientBusinessObject_template = boService.selectCBOByOid(codeClassifyDTO.getOid(), "codeclstemplate"); ClientBusinessObject clientBusinessObject_template_insert = null; try { clientBusinessObject_template_insert = clientBusinessObjectOperation.reviseBusinessObject(clientBusinessObject_template, ""); }catch (VCIError e){ e.printStackTrace(); logger.error("===============>分类模板-升版复制出错oid： "+templateOldOid+",mes"+e.error_message); return BaseResult.error("升版出错"); } CodeClassifyTemplateDO codeClassifyTemplateDO = new CodeClassifyTemplateDO(); BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,codeClassifyTemplateDO); WebUtil.copyValueToObjectFromCbos(clientBusinessObject_template_insert,codeClassifyTemplateDO); //modify by weidy@2022-2-27 //升版后不能使用insert方法，因为那个永远是新增一条数据， //上方先从dto转给do，然后把升版的初始化的属性拷贝给do，最后再从do拷贝到cbo上 WebUtil.copyValueToCboFromObj(clientBusinessObject_template_insert,codeClassifyTemplateDO); //升版过后的模板oid String templateNewOid = codeClassifyTemplateDO.getOid(); //需要复制的模板属性 //查询老模板下边的所有属性，赋值新模板oid VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class); codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid); List codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery); for (CodeClassifyTemplateAttrDO codeClassifyTemplateAttrDO :codeClassifyTemplateAttrDOList){ String attrOid = VciBaseUtil.getPk(); codeClassifyTemplateAttrDO.setOid(attrOid); codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid); } //复制模板流程 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); //一起保存数据 WebUtil.setPersistence(false);//不执行保存 //保存模板 BatchCBO batchCBOTemplate = new BatchCBO(); //batchCBO保存的时候没有能够自动update源数据的isLastR //batchCBOTemplate.getCreateCbos().add(clientBusinessObject_template_insert); //使用saveRevisionBuisnessObject可以解决这个问题，这里先暂时执行两次保存 try { clientBusinessObjectOperation.saveRevisionBuinessObject(clientBusinessObject_template_insert); } catch (VCIError vciError) { throw new VciBaseException("升版保存出错了",new String[0],vciError); } // end --modify by lihang @20220408 //codeClassifyTemplateMapper.insert(codeClassifyTemplateDO); //保存模板属性 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 BaseResult.success("升版成功！"); } @Override public BaseResult copyTemplate(CodeClassifyTemplateDTO codeClassifyDTO){ //旧的模板oid String oldOid = codeClassifyDTO.getOid(); //新的模板oid String newOid = VciBaseUtil.getPk(); //分类oid,复制过来的新的分类oid String codeClassifyOid = codeClassifyDTO.getCodeclassifyoid(); //复制模板 CodeClassifyTemplateDO codeClassifyTemplateDO_old = codeClassifyTemplateMapper.selectByPrimaryKey(oldOid);//旧模板 //验证，业务类型是不是一致 CodeClassifyDO codeClassifyDO_old = codeClassifyDaoI.selectBtmOrParentBtm(codeClassifyTemplateDO_old.getCodeClassifyOid()); if(codeClassifyDO_old==null){ return BaseResult.fail("复制的模板所属分类以及上级没有业务类型，请重新选择!"); } //找当前分类下的业务类型 CodeClassifyDO codeClassifyDO_new = codeClassifyDaoI.selectBtmOrParentBtm(codeClassifyOid); if(codeClassifyDO_new==null){ return BaseResult.fail("当前分类没有业务类型，请重新选择!"); } if(!codeClassifyDO_old.getBtmTypeId().equals(codeClassifyDO_new.getBtmTypeId())){ return BaseResult.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); 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); //一起保存数据 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 BaseResult.success("复制成功！"); } /** * 使用主题库的分类主键，获取生效的模板 * * @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 codeClassifyOid 父分类的主键 * @return true表示相同 */ @Override public boolean checkChildHasSameTemplate(String codeClassifyOid) { Map childHasTemplateMap =codeClassifyTemplateMapper.selectChildHasReleaseTemplate(codeClassifyOid); if(!CollectionUtils.isEmpty(childHasTemplateMap) && childHasTemplateMap.values().stream().collect(Collectors.toSet()).size()>1){ return false; } return true; } /** *根据父分类id去查找叶子节点的模板，如果没查到则认为模板在上层建立，则根据分类去查当前模板 * @param codeClassifyOid 父分类的主键 * @return */ @Override public List childTemplates(String codeClassifyOid){ List codeClassifyTemplateVOList=new ArrayList<>(); Map childHasTemplateMap =codeClassifyTemplateMapper.selectChildHasReleaseTemplate(codeClassifyOid); 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()); List templateDOS = codeClassifyTemplateMapper.selectByCondition(conditionMap, new PageHelper(-1)); if(CollectionUtils.isEmpty(templateDOS)){ //递归找上级的模板 CodeClassifyDO classifyDO = codeClassifyDaoI.selectByPrimaryKey(codeClassifyOid); if(StringUtils.isBlank(classifyDO.getParentCodeClassifyOid())){ //说明已经是顶了，也没找到的话，那就返回了 return null; } return selectOnlyTemplateByClassifyOid(classifyDO.getParentCodeClassifyOid()); }else{ return templateDOS; } } /** * 复制模板，模板属性 * @param templateOldOid * @param templateNewOid * @param codeClassifyDTO 模板名称，模板编号，描述 * @return map tamplate:(List) templateAttr:(List) */ public Map copyTemplate_attr(String templateOldOid,String templateNewOid,String codeckassfyOid,CodeClassifyTemplateDTO codeClassifyDTO){ templateNewOid = templateNewOid==null?VciBaseUtil.getPk():VciBaseUtil.getPk(); VciQueryWrapperForDO codeClassifyTemplateQuery = new VciQueryWrapperForDO(CodeClassifyTemplateDO.class); codeClassifyTemplateQuery.addQueryMap("oid",templateOldOid); List codeClassifyTemplateDOList = codeClassifyTemplateMapper.selectByWrapper(codeClassifyTemplateQuery); for (CodeClassifyTemplateDO codeClassifyTemplateDO:codeClassifyTemplateDOList){ codeClassifyTemplateDO.setOid(templateNewOid); codeClassifyTemplateDO.setCodeClassifyOid(codeckassfyOid); codeClassifyTemplateDO.setId(codeClassifyDTO.getId()); codeClassifyTemplateDO.setName(codeClassifyDTO.getName()); codeClassifyTemplateDO.setDescription(codeClassifyDTO.getDescription()); } //复制模板属性 List codeClassifyTemplateAttrDOList = copyTemplateAttr(templateOldOid,templateNewOid); Map template_attrMap = new HashMap(); template_attrMap.put("tamplate",codeClassifyTemplateDOList); template_attrMap.put("templateAttr",codeClassifyTemplateAttrDOList); return template_attrMap; } /** * 复制模板属性 */ public List copyTemplateAttr(String templateOldOid,String templateNewOid){ VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class); codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid); List codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery); for (CodeClassifyTemplateAttrDO codeClassifyTemplateAttrDO :codeClassifyTemplateAttrDOList){ String attrOid = VciBaseUtil.getPk(); codeClassifyTemplateAttrDO.setOid(attrOid); codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid); } return codeClassifyTemplateAttrDOList; } /** * 复制模板流程 */ public List copyTemplateProcess(String templateOldOid,String templateNewOid){ VciQueryWrapperForDO processWrapper = new VciQueryWrapperForDO(CodeClassifyProcessTempDO.class); processWrapper.addQueryMap("classifyTemplateOid",templateOldOid); List codeClassifyProcessTempDOList = codeClassifyProcessTempDaoI.selectByWrapper(processWrapper);//要保存的新的模板流程 for (CodeClassifyProcessTempDO codeClassifyProcessTempDO:codeClassifyProcessTempDOList){ String newOid = VciBaseUtil.getPk(); codeClassifyProcessTempDO.setOid(newOid); //codeClassifyProcessTempDO.setCodeClassifyOid(templateNewOid); codeClassifyProcessTempDO.setClassifyTemplateOid(templateNewOid); //modify by lihang - @20220406 设置模板主键位置出错，导致升版的模板中的流程是空的。 } return codeClassifyProcessTempDOList; } /** * 复制模板阶段，模板属性 * @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); List codeClassifyPhaseDOList = codeTemplatePhaseDaoI.selectByWrapper(phaseWrapper);//要保存的新的模板流程 Map phaseKeyMap = new HashMap();//需要复制的模板阶段属性,key:value,模板阶段老oid:模板属性新oid List phaseOidList = new ArrayList(); for (CodeTemplatePhaseDO codeTemplatePhaseDO:codeClassifyPhaseDOList){ 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)); } for (CodePhaseAttrDO codePhaseAttrDO:codePhaseAttrDOList){ String oldPhaseoid = codePhaseAttrDO.getCodePhaseOid(); String newOid = VciBaseUtil.getPk(); codePhaseAttrDO.setOid(newOid); codePhaseAttrDO.setCodePhaseOid(phaseKeyMap.get(oldPhaseoid)); } Map phaseMap = new HashMap(); phaseMap.put("phase",codeClassifyPhaseDOList); phaseMap.put("phaseAttr",codePhaseAttrDOList); return phaseMap; } /** * 复制模板按钮 */ public List copyTemplateButton(String templateOldOid,String templateNewOid){ VciQueryWrapperForDO buttonWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateButtonDO.class); buttonWrapper.addQueryMap("classifyTemplateOid",templateOldOid); List codeClassifyTemplateButtonDOList = codeClassifyTemplateButtonDaoI.selectByWrapper(buttonWrapper); for (CodeClassifyTemplateButtonDO codeClassifyTemplateButtonDO:codeClassifyTemplateButtonDOList){ String newOid = VciBaseUtil.getPk(); codeClassifyTemplateButtonDO.setOid(newOid); codeClassifyTemplateButtonDO.setClassifyTemplateOid(templateNewOid); } return codeClassifyTemplateButtonDOList; } }