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<Tree> treeCodeClassifyTemplate(TreeQueryObject treeQueryObject) throws VciBaseException{
|
List<CodeClassifyTemplateDO> 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<CodeClassifyTemplateDO> 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<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplateDO> codeClassifyTemplateDOs) throws VciBaseException{
|
return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOs,false);
|
}
|
|
/**
|
* 批量数据对象转换为显示对象
|
* @param codeClassifyTemplateDOs 数据对象列表
|
* @param hasAttr 是否包含属性
|
* @return 显示对象
|
* @throws VciBaseException 参数为空或者不存在的时候会抛出异常
|
*/
|
@Override
|
public List<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplateDO> codeClassifyTemplateDOs,boolean hasAttr) throws VciBaseException{
|
List<CodeClassifyTemplateVO> voList = new ArrayList<CodeClassifyTemplateVO>();
|
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<CodeClassifyTemplateAttrVO> attrVOList = templateAttrService.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())){
|
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<CodeClassifyTemplateVO> addSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
|
VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"需要添加的数据对象");
|
//将DTO转换为DO
|
CodeClassifyTemplateDO codeClassifyTemplateDO = new CodeClassifyTemplateDO();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDO);
|
|
//查询分类以及上级分类的业务类型btmtypeid、btmtypename
|
List<CodeClassifyDO> 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<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 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<String> 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<String> childrenOids = codeClassifyTemplateMapper.selectAllLevelChildOid(codeClassifyTemplateDO.getOid().trim());
|
if (!CollectionUtils.isEmpty(childrenOids)) {
|
Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids);
|
for (Collection<String> 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<CodeClassifyTemplateAttrDO> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(templateQueryWrapper);
|
|
if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrDOList)) {
|
List<String> templateAttrOids = new ArrayList<String>();
|
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<CodeClassifyTemplateDO> doList = new ArrayList<>();
|
doList.add(selectByOid(oid));
|
List<CodeClassifyTemplateVO> 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<CodeClassifyTemplateVO> listCodeClassifyTemplateByOids(Collection<String> oidCollections) throws VciBaseException{
|
VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合");
|
List<CodeClassifyTemplateDO> codeClassifyTemplateDOList = listCodeClassifyTemplateDOByOidCollections(oidCollections);
|
return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOList);
|
}
|
|
/**
|
* 使用主键集合查询数据对象
|
* @param oidCollections 主键的集合
|
* @return 数据对象列表
|
*/
|
private List<CodeClassifyTemplateDO> listCodeClassifyTemplateDOByOidCollections(Collection<String> oidCollections){
|
List<CodeClassifyTemplateDO> codeClassifyTemplateDOList = new ArrayList<CodeClassifyTemplateDO>();
|
if(!CollectionUtils.isEmpty(oidCollections)){
|
Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
|
for(Collection<String> oids: oidCollectionsList){
|
List<CodeClassifyTemplateDO> tempDOList = codeClassifyTemplateMapper.selectByPrimaryKeyCollection(oids);
|
if(!CollectionUtils.isEmpty(tempDOList)){
|
codeClassifyTemplateDOList.addAll(tempDOList);
|
}
|
}
|
}
|
return codeClassifyTemplateDOList;
|
}
|
|
|
|
/**
|
* 参照树 分类模板对象
|
* @param treeQueryObject 树形查询对象
|
* @return 分类模板对象显示树
|
* @throws VciBaseException 查询条件和分页出错的时候会抛出异常
|
*/
|
@Override
|
public List<Tree> referTree(TreeQueryObject treeQueryObject) throws VciBaseException{
|
if(treeQueryObject == null){
|
treeQueryObject = new TreeQueryObject();
|
}
|
if(treeQueryObject.getConditionMap() == null){
|
treeQueryObject.setConditionMap(new HashMap<>());
|
}
|
if(treeQueryObject.getConditionMap().containsKey(LC_STATUS)) {
|
treeQueryObject.getConditionMap().remove(LC_STATUS);
|
}
|
treeQueryObject.getConditionMap().put(LC_STATUS,CodeClassifyTemplateLC.RELEASED.getValue());
|
return treeCodeClassifyTemplate(treeQueryObject);
|
}
|
|
/**
|
* 分类模板列表
|
*
|
* @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>();
|
//没有传分类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<CodeClassifyTemplateDO> 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<CodeClassifyTemplateAttrDO> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery);
|
for (CodeClassifyTemplateAttrDO codeClassifyTemplateAttrDO :codeClassifyTemplateAttrDOList){
|
String attrOid = VciBaseUtil.getPk();
|
codeClassifyTemplateAttrDO.setOid(attrOid);
|
codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
|
}
|
|
//复制模板流程
|
List<CodeClassifyProcessTempDO> codeClassifyProcessTempDOList = copyTemplateProcess(templateOldOid,templateNewOid);
|
|
//复制模板阶段，阶段属性
|
Map phase_attrMap = copyTemplatePhase_attr(templateOldOid,templateNewOid);
|
|
List<CodeTemplatePhaseDO> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhaseDO>)phase_attrMap.get("phase");//模板阶段
|
List<CodePhaseAttrDO> codePhaseAttrDOList = (ArrayList<CodePhaseAttrDO>)phase_attrMap.get("phaseAttr");//阶段属性
|
|
//复制模板按钮
|
List<CodeClassifyTemplateButtonDO> 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<CodeClassifyTemplateDO> codeClassifyTemplateDOList = new ArrayList<CodeClassifyTemplateDO>();
|
codeClassifyTemplateDOList.add(codeClassifyTemplateDO_old);
|
|
//复制模板属性
|
List<CodeClassifyTemplateAttrDO> codeClassifyTemplateAttrDOList = copyTemplateAttr(oldOid,newOid);
|
|
//复制模板流程
|
List<CodeClassifyProcessTempDO> codeClassifyProcessTempDOList = copyTemplateProcess(oldOid,newOid);
|
|
//复制模板阶段，阶段属性
|
Map phase_attrMap = copyTemplatePhase_attr(oldOid,newOid);
|
|
List<CodeTemplatePhaseDO> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhaseDO>)phase_attrMap.get("phase");//模板阶段
|
List<CodePhaseAttrDO> codePhaseAttrDOList = (ArrayList<CodePhaseAttrDO>)phase_attrMap.get("phaseAttr");//阶段属性
|
|
//复制模板按钮
|
List<CodeClassifyTemplateButtonDO> 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<CodeClassifyTemplateVO> listReleaseTemplateByClassifyOid(String codeClassifyOid, boolean hasAttribute) {
|
VciBaseUtil.alertNotNull(codeClassifyOid,"主题库分类主键");
|
List<CodeClassifyTemplateDO> 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 codeClassifyOid 父分类的主键
|
* @return true表示相同
|
*/
|
@Override
|
public boolean checkChildHasSameTemplate(String codeClassifyOid) {
|
Map<String/**模板的主键**/,String/**分类的主键**/> 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<CodeClassifyTemplateVO> childTemplates(String codeClassifyOid){
|
List<CodeClassifyTemplateVO> codeClassifyTemplateVOList=new ArrayList<>();
|
Map<String/**模板的主键**/,String/**分类的主键**/> childHasTemplateMap =codeClassifyTemplateMapper.selectChildHasReleaseTemplate(codeClassifyOid);
|
Set<String> templateOid = childHasTemplateMap.keySet();
|
List<CodeClassifyTemplateDO> 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<CodeClassifyTemplateDO> selectOnlyTemplateByClassifyOid(String codeClassifyOid){
|
//1.直接查询，看看这个分类下面有没有发布状态的模板
|
//2.如果没有，则往上找分类的内容，这个分类层级不会太多，所以直接递归即可
|
//3.如果分类下面添加了模板，但是没有发布，则说明模板可能还在编辑的状态，依然使用上级分类
|
|
Map<String,String> conditionMap = new HashMap<>();
|
conditionMap.put("codeClassifyOid",codeClassifyOid);
|
conditionMap.put("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue());
|
List<CodeClassifyTemplateDO> 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<CodeClassifyTemplateDO>) templateAttr:(List<CodeClassifyTemplateAttrDO>)
|
*/
|
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<CodeClassifyTemplateDO> 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<CodeClassifyTemplateAttrDO> codeClassifyTemplateAttrDOList = copyTemplateAttr(templateOldOid,templateNewOid);
|
Map template_attrMap = new HashMap();
|
template_attrMap.put("tamplate",codeClassifyTemplateDOList);
|
template_attrMap.put("templateAttr",codeClassifyTemplateAttrDOList);
|
return template_attrMap;
|
}
|
|
/**
|
* 复制模板属性
|
*/
|
public List<CodeClassifyTemplateAttrDO> copyTemplateAttr(String templateOldOid,String templateNewOid){
|
VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
|
codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid);
|
List<CodeClassifyTemplateAttrDO> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery);
|
for (CodeClassifyTemplateAttrDO codeClassifyTemplateAttrDO :codeClassifyTemplateAttrDOList){
|
String attrOid = VciBaseUtil.getPk();
|
codeClassifyTemplateAttrDO.setOid(attrOid);
|
codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
|
}
|
return codeClassifyTemplateAttrDOList;
|
}
|
|
/**
|
* 复制模板流程
|
*/
|
public List<CodeClassifyProcessTempDO> copyTemplateProcess(String templateOldOid,String templateNewOid){
|
VciQueryWrapperForDO processWrapper = new VciQueryWrapperForDO(CodeClassifyProcessTempDO.class);
|
processWrapper.addQueryMap("classifyTemplateOid",templateOldOid);
|
List<CodeClassifyProcessTempDO> 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<CodeTemplatePhaseDO>) phaseAttr:(List<CodePhaseAttrDO>)
|
*/
|
public Map copyTemplatePhase_attr(String templateOldOid,String templateNewOid){
|
//模板阶段
|
VciQueryWrapperForDO phaseWrapper = new VciQueryWrapperForDO(CodeTemplatePhaseDO.class);
|
phaseWrapper.addQueryMap("codeClassifyTemplateOid",templateOldOid);
|
List<CodeTemplatePhaseDO> codeClassifyPhaseDOList = codeTemplatePhaseDaoI.selectByWrapper(phaseWrapper);//要保存的新的模板流程
|
Map<String,String> phaseKeyMap = new HashMap<String,String>();//需要复制的模板阶段属性,key:value,模板阶段老oid:模板属性新oid
|
List<String> phaseOidList = new ArrayList<String>();
|
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<CodePhaseAttrDO> codePhaseAttrDOList = new ArrayList<CodePhaseAttrDO>();
|
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));
|
}
|
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<CodeClassifyTemplateButtonDO> copyTemplateButton(String templateOldOid,String templateNewOid){
|
VciQueryWrapperForDO buttonWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateButtonDO.class);
|
buttonWrapper.addQueryMap("classifyTemplateOid",templateOldOid);
|
List<CodeClassifyTemplateButtonDO> codeClassifyTemplateButtonDOList = codeClassifyTemplateButtonDaoI.selectByWrapper(buttonWrapper);
|
for (CodeClassifyTemplateButtonDO codeClassifyTemplateButtonDO:codeClassifyTemplateButtonDOList){
|
String newOid = VciBaseUtil.getPk();
|
codeClassifyTemplateButtonDO.setOid(newOid);
|
codeClassifyTemplateButtonDO.setClassifyTemplateOid(templateNewOid);
|
}
|
return codeClassifyTemplateButtonDOList;
|
}
|
|
|
|
}
|
