/*
|
* 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.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.flow.core.entity.ProcessTemplate;
|
import com.vci.ubcs.flow.core.feign.IFlowClient;
|
import com.vci.ubcs.starter.exception.VciBaseException;
|
import com.vci.ubcs.starter.revision.model.TreeQueryObject;
|
import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
|
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
|
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
|
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
|
import com.vci.ubcs.starter.web.pagemodel.Tree;
|
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
|
import com.vci.ubcs.starter.web.util.VciBaseUtil;
|
import net.logstash.logback.encoder.org.apache.commons.lang3.StringUtils;
|
import org.springblade.core.mp.support.Condition;
|
import org.springblade.core.mp.support.Query;
|
import org.springblade.core.secure.utils.AuthUtil;
|
import org.springblade.core.tool.api.R;
|
import org.springblade.core.tool.utils.Func;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.cglib.beans.BeanMap;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
|
import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.*;
|
import static com.vci.ubcs.code.service.impl.CodeClassifyServiceImpl.PARENT_FIELD_NAME;
|
|
/**
|
* 编码库定义-模板管理 服务实现类
|
*
|
* @author yuxc
|
* @since 2023-04-10
|
*/
|
@Service
|
public class CodeClstemplateServiceImpl extends ServiceImpl<CodeClassifyTemplateMapper, CodeClassifyTemplate> implements ICodeClstemplateService {
|
|
/**
|
* 模板属性的服务
|
*/
|
@Lazy
|
@Autowired(required = false)
|
ICodeClassifyTemplateAttrService codeClstempattrService;
|
|
/**
|
* 对象的操作
|
*/
|
@Autowired(required = false)
|
private RevisionModelUtil revisionModelUtil;
|
|
@Autowired(required = false)
|
private CodeClassifyTemplateAttrMapper codeClstempattrMapper;
|
@Autowired(required = false)
|
private CodeTempphaseServiceImpl codeTempphaseServiceImpl;
|
@Autowired(required = false)
|
private CodeClassifyTemplateButtonServiceImpl codeTempbuttonServiceImpl;
|
@Autowired(required = false)
|
private ICodeClassifyProcessTempService codeClsflowtempServiceImpl;
|
// @Autowired(required = false)
|
// private CodeClsflowtempMapper codeClsflowtempMapper;
|
@Autowired(required = false)
|
private CodeTemplatePhaseMapper codeTempphaseMapper;
|
@Autowired(required = false)
|
private CodeClassifyTemplateButtonMapper codeTempbuttonMapper;
|
@Autowired(required = false)
|
private CodePhaseAttrMapper codePhaseattrMapper;
|
@Autowired(required = false)
|
private CodeClassifyMapper codeClassifyMapper;
|
@Autowired(required = false)
|
private ICodeClassifyService codeClassifyService;
|
@Autowired(required = false)
|
private CodeClassifyTemplateMapper codeClassifyTemplateMapper;
|
@Autowired(required = false)
|
private CodePhaseAttrServiceImpl codePhaseattrServiceImpl;
|
@Autowired(required = false)
|
private IFlowClient iFlowClient;
|
|
@Override
|
public IPage<CodeClassifyTemplateVO> selectPlCodeClstemplatePage(IPage<CodeClassifyTemplateVO> page, CodeClassifyTemplateVO plCodeClstemplate) {
|
return page.setRecords(baseMapper.selectPlCodeClstemplatePage(page, plCodeClstemplate));
|
}
|
|
/**
|
* 查询分类模板对象 树
|
* @param treeQueryObject 树查询对象
|
* @return 分类模板对象 显示树
|
*/
|
@Override
|
public List<Tree> treeCodeClassifyTemplate(TreeQueryObject treeQueryObject) {
|
List<CodeClassifyTemplate> doList =selectCodeClassifyTemplateDOByTree(treeQueryObject);
|
|
List<CodeClassifyTemplateVO> voList = codeClassifyTemplateDO2VOs(doList);
|
TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
|
treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
|
return revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyTemplateVO s) ->{
|
//可以在这里处理树节点的显示
|
return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
|
.getLcStatus()) ? (" 【停用】 ") : "");
|
});
|
}
|
|
/**
|
* 根据树形查询对象来查询数据对象
|
*
|
* @param treeQueryObject 树形查询对象
|
* @return 查询结果,数据对象
|
*/
|
@Override
|
public List<CodeClassifyTemplate> selectCodeClassifyTemplateDOByTree(TreeQueryObject treeQueryObject) {
|
// VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null,CodeClassifyTemplateDO.class);
|
// VciParentQueryOption parentQueryOption = new VciParentQueryOption();
|
// parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
|
// queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
|
// CodeClstemplateEntity codeClstemplateEntity = new CodeClstemplateEntity();
|
// codeClstemplateEntity.set
|
return baseMapper.selectCodeClassifyTemplateDOByTree(
|
treeQueryObject.getConditionMap().get("codeclassifyoid"),
|
treeQueryObject.getConditionMap().get("lcStatus"));
|
// return baseMapper.selectList(Condition.getQueryWrapper(codeClstemplateEntity));
|
// return codeClassifyTemplateMapper.selectByWrapper(queryWrapperForDO);
|
}
|
|
/**
|
* 批量数据对象转换为显示对象
|
* @param codeClassifyTemplateDOs 数据对象列表
|
* @return 显示对象
|
*/
|
@Override
|
public List<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplate> codeClassifyTemplateDOs) {
|
return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOs,false);
|
}
|
|
/**
|
* 批量数据对象转换为显示对象
|
* @param codeClassifyTemplateDOs 数据对象列表
|
* @param hasAttr 是否包含属性
|
* @return 显示对象
|
*/
|
@Override
|
public List<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplate> codeClassifyTemplateDOs, boolean hasAttr) {
|
List<CodeClassifyTemplateVO> voList = new ArrayList<CodeClassifyTemplateVO>();
|
if(!CollectionUtils.isEmpty(codeClassifyTemplateDOs)){
|
for(CodeClassifyTemplate s: codeClassifyTemplateDOs){
|
CodeClassifyTemplateVO vo = codeClassifyTemplateDO2VO(s);
|
if(vo != null){
|
voList.add(vo);
|
}
|
}
|
}
|
if(hasAttr){
|
//一个分类里面总不能超过1000个生效的版本吧！！！
|
VciBaseUtil.switchCollectionForOracleIn(voList.stream().map(CodeClassifyTemplateVO::getOid).collect(Collectors.toList())).forEach(tempOids->{
|
List<CodeClassifyTemplateAttrVO> attrVOList = codeClstempattrService.listCodeClassifyTemplateAttrByTemplateOids(tempOids);
|
|
if(!CollectionUtils.isEmpty(attrVOList)){
|
Map<String, List<CodeClassifyTemplateAttrVO>> attrVOMap = attrVOList.stream().collect(Collectors.groupingBy(s -> s.getClassifyTemplateOid()));
|
|
voList.stream().forEach(templateVO->{
|
if(attrVOMap.containsKey(templateVO.getOid())){
|
List<CodeClassifyTemplateAttrVO> codeClstempattrVO = new ArrayList<>();
|
for (CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO : attrVOMap.get(templateVO.getOid())) {
|
codeClstempattrVO.add(codeClassifyTemplateAttrVO);
|
}
|
templateVO.setAttributes(codeClstempattrVO);
|
}
|
});
|
}
|
});
|
|
}
|
return voList;
|
}
|
/**
|
* 数据对象转换为显示对象
|
* @param codeClassifyTemplateDO 数据对象
|
* @return 显示对象
|
*/
|
@Override
|
public CodeClassifyTemplateVO codeClassifyTemplateDO2VO(CodeClassifyTemplate codeClassifyTemplateDO) {
|
CodeClassifyTemplateVO vo = new CodeClassifyTemplateVO();
|
if(codeClassifyTemplateDO != null){
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDO,vo);
|
//如果有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<String,Object> condition = new HashMap<>(2);
|
// condition.put("oid",codeClstemplateDTO.getOid());
|
// condition.put("ts",codeClstemplateDTO.getTs());
|
CodeClassifyTemplate detail = baseMapper
|
.selectById(codeClstemplateDTO.getOid());
|
|
if(!detail.getTs().toString().equals(codeClstemplateDTO.getTs().toString())){//不是最新的不让改
|
return R.fail("当前数据不是最新，请刷新后再修改！");
|
}
|
//校验下级是否有引用
|
if(checkChildIsLinked(codeClassifyTemplate.getOid())){
|
return R.fail(DATA_CASCADE_LINKED_NOT_DELETE);
|
}
|
return R.success(String.valueOf(checkHasChild(codeClassifyTemplate.getOid())));
|
}
|
|
/**
|
* 检查是否有下级是否关联了数据
|
*
|
* @param oid 主键
|
* @return true 表示有引用，false表示没有引用
|
*/
|
@Override
|
public boolean checkChildIsLinked(String oid) {
|
VciBaseUtil.alertNotNull(oid,"主键");
|
List<String> childOids = baseMapper.selectAllLevelChildOid(oid.trim());
|
if(!CollectionUtils.isEmpty(childOids)){
|
for(String childOid: childOids){
|
if(!checkIsLinked(childOid)){
|
return false;
|
}
|
}
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 校验是否被引用
|
* @param oid 主键
|
*/
|
private boolean checkIsLinked(String oid){
|
//TODO 添加需要校验引用的地方
|
return false;
|
}
|
|
/**
|
* 校验是否有下级节点，不校验是否关联了数据
|
*
|
* @param oid 主键
|
* @return true表示有下级，false表示没有下级
|
*/
|
@Override
|
public boolean checkHasChild(String oid) {
|
VciBaseUtil.alertNotNull(oid,"主键");
|
return baseMapper.countAllLevelChildOid(oid.trim()) > 0;
|
}
|
|
|
/**
|
* 删除分类模板对象
|
* @param codeClstemplateDTO 分类模板对象数据传输对象，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<String> childrenOids = baseMapper.selectAllLevelChildOid(codeClassifyTemplateDO.getOid().trim());
|
if (!CollectionUtils.isEmpty(childrenOids)) {
|
Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids);
|
for (Collection<String> s : childrenCollections) {
|
updateCount += baseMapper.deleteBatchIds(s);
|
|
// batchCBO.copyFromOther(batchCBOi);
|
}
|
}
|
}else{
|
return baseResult;
|
}
|
//执行删除操作
|
|
updateCount += baseMapper.deleteById(codeClassifyTemplateDO.getOid());
|
// batchCBO.copyFromOther(batchCBO_delete);
|
|
//删除模板属性
|
// VciQueryWrapperForDO templateQueryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
|
// templateQueryWrapper.addQueryMap("classifyTemplateOid",templateOid);
|
List<CodeClassifyTemplateAttr> codeClstempattrEntityList = codeClstempattrMapper.selectRefByOid(templateOid);
|
|
if(!CollectionUtils.isEmpty(codeClstempattrEntityList)) {
|
List<String> templateAttrOids = new ArrayList<String>();
|
for (CodeClassifyTemplateAttr codeClstempattrEntity:codeClstempattrEntityList){
|
templateAttrOids.add(codeClstempattrEntity.getOid());
|
}
|
|
updateCount += codeClstempattrMapper.deleteBatchIds(templateAttrOids);
|
// batchCBO.copyFromOther(batchCBO_templateAttr_delete);
|
}
|
|
//调用模板阶段方法
|
updateCount += codeTempphaseServiceImpl.codeTemplateDeleteTrigger(templateOid);
|
|
//调用模板按钮方法
|
updateCount += codeTempbuttonServiceImpl.codeTemplateDeleteTrigger(templateOid);
|
|
//调用模板流程方法
|
updateCount += codeClsflowtempServiceImpl.codeTemplateDeleteTrigger(templateOid);
|
|
return updateCount > 0?R.success(DELETE_SUCCESS):R.fail(DELETE_FAIL);
|
}
|
|
|
/**
|
* 主键获取分类模板对象
|
* @param oid 主键
|
* @return 分类模板对象显示对象
|
*/
|
@Override
|
public CodeClassifyTemplateVO getObjectByOid(String oid) {
|
return codeClassifyTemplateDO2VO(selectByOid(oid));
|
}
|
|
@Override
|
public Collection<CodeClassifyTemplateVO> listCodeClassifyTemplateByOids(List<String> oidCollections) {
|
VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合");
|
List<CodeClassifyTemplate> codeClassifyTemplateDOList = listCodeClassifyTemplateDOByOidCollections(oidCollections);
|
return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOList);
|
}
|
|
/**
|
* 参照树 分类模板对象
|
* @param treeQueryObject 树形查询对象
|
* @return 分类模板对象显示树
|
*/
|
@Transactional
|
@Override
|
public List<Tree> referTree(TreeQueryObject treeQueryObject) {
|
if(treeQueryObject == null){
|
treeQueryObject = new TreeQueryObject();
|
}
|
if(treeQueryObject.getConditionMap() == null){
|
treeQueryObject.setConditionMap(new HashMap<>());
|
}
|
if(treeQueryObject.getConditionMap().containsKey(LC_STATUS)) {
|
treeQueryObject.getConditionMap().remove(LC_STATUS);
|
}
|
treeQueryObject.getConditionMap().put(LC_STATUS,CodeClassifyTemplateLC.RELEASED.getValue());
|
return treeCodeClassifyTemplate(treeQueryObject);
|
}
|
|
/**
|
* 使用主键集合查询数据对象
|
* @param oidCollections 主键的集合
|
* @return 数据对象列表
|
*/
|
private List<CodeClassifyTemplate> listCodeClassifyTemplateDOByOidCollections(Collection<String> oidCollections){
|
List<CodeClassifyTemplate> codeClassifyTemplateDOList = new ArrayList<CodeClassifyTemplate>();
|
if(!CollectionUtils.isEmpty(oidCollections)){
|
Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
|
for(Collection<String> oids: oidCollectionsList){
|
List<CodeClassifyTemplate> tempDOList = baseMapper.selectBatchIds(oids); //codeClassifyTemplateMapper.selectByPrimaryKeyCollection(oids);
|
if(!CollectionUtils.isEmpty(tempDOList)){
|
codeClassifyTemplateDOList.addAll(tempDOList);
|
}
|
}
|
}
|
return codeClassifyTemplateDOList;
|
}
|
|
/**
|
* 主键查询数据对象
|
* @param oid 主键
|
* @return 数据对象
|
*/
|
private CodeClassifyTemplate selectByOid(String oid) {
|
VciBaseUtil.alertNotNull(oid,"主键");
|
CodeClassifyTemplate codeClassifyTemplate = baseMapper.selectById(oid.trim());
|
if(codeClassifyTemplate == null || StringUtils.isBlank(codeClassifyTemplate.getOid())){
|
throw new VciBaseException(DATA_OID_NOT_EXIST);
|
}
|
return codeClassifyTemplate;
|
}
|
|
/**
|
* 启用、停用
|
* @param oid
|
* @param lcStatus
|
* @return
|
*/
|
@Transactional
|
@Override
|
public R updateLcStatus( String oid, String lcStatus){
|
CodeClassifyTemplate codeClassifyTemplateDO = baseMapper.selectById(oid);
|
//停用的时候，验证模板是否为已发布
|
if(CodeClassifyTemplateLC.DISABLED.getValue().equals(lcStatus)){
|
if(!CodeClassifyTemplateLC.RELEASED.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
|
return R.fail("模板未启用，不能停用！");
|
}
|
}
|
|
if(lcStatus.equals(CodeClassifyTemplateLC.RELEASED.getValue())){
|
QueryWrapper<CodeClassify> classifyQueryWrapper = new QueryWrapper<>();
|
classifyQueryWrapper.eq("oid",codeClassifyTemplateDO.getCodeClassifyOid());
|
classifyQueryWrapper.eq("lcstatus","Enabled");
|
List<CodeClassify> codeClassifyList = codeClassifyService.selectByWrapper(classifyQueryWrapper);
|
if(codeClassifyList.size()==0){
|
return R.fail("查询到所属分类未启用，请先进行启用！！！");
|
}
|
}
|
|
//启用、停用
|
codeClassifyTemplateDO.setLcStatus(lcStatus);
|
int u = baseMapper.updateById(codeClassifyTemplateDO);
|
return u==0?R.fail("修改失败！"):R.success("修改成功");
|
}
|
|
/**
|
* 升版
|
* @param codeClassifyDTO
|
*/
|
@Transactional
|
@Override
|
public R Upgrade(CodeClassifyTemplateDTO codeClassifyDTO) {
|
|
//旧的模板oid
|
String templateOldOid = codeClassifyDTO.getOid();
|
//只有已发布的才能升版
|
CodeClassifyTemplate codeClassifyTemplateDOOld = baseMapper.selectById(templateOldOid);
|
if(!FRAMEWORK_RELEASE_RELEASED.equals(codeClassifyTemplateDOOld.getLcStatus())){
|
return R.fail("该模板未发布，不能升版！");
|
}
|
|
//需要新增的升级模板
|
CodeClassifyTemplate codeCls_template = baseMapper.selectById(templateOldOid);
|
CodeClassifyTemplate codeCls_template_insert = new CodeClassifyTemplate();
|
codeCls_template_insert.setOid(VciBaseUtil.getPk());
|
codeCls_template_insert.setRevisionOid(VciBaseUtil.getPk());
|
codeCls_template_insert.setNameOid(codeCls_template.getNameOid());
|
codeCls_template_insert.setBtmname(codeCls_template.getBtmname());
|
codeCls_template_insert.setLastR(String.valueOf(1));
|
codeCls_template_insert.setFirstR(String.valueOf(0));
|
codeCls_template_insert.setFirstV(String.valueOf(1));
|
codeCls_template_insert.setLastV(String.valueOf(1));
|
codeCls_template_insert.setCreator(String.valueOf(AuthUtil.getUser().getUserId()));
|
codeCls_template_insert.setCreateTime(new Date());
|
codeCls_template_insert.setTs(new Date());
|
codeCls_template_insert.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
|
codeCls_template_insert.setLastModifyTime(new Date());
|
codeCls_template_insert.setRevisionRule(codeCls_template.getRevisionRule());
|
codeCls_template_insert.setVersionRule(codeCls_template.getVersionRule());
|
codeCls_template_insert.setBtmTypeId(codeCls_template.getBtmTypeId());
|
codeCls_template_insert.setBtmTypeName(codeCls_template.getBtmTypeName());
|
codeCls_template_insert.setCodeClassifyOid(codeCls_template.getCodeClassifyOid());
|
codeCls_template_insert.setCodeClassifyOidName(codeCls_template.getCodeClassifyOidName());
|
Map rvObj = baseMapper.getNextRevision(codeCls_template.getNameOid());
|
codeCls_template_insert.setRevisionSeq(Integer.parseInt(rvObj.get("REVISIONSEQ").toString()));
|
codeCls_template_insert.setRevisionValue(rvObj.get("REVISIONVAL").toString());
|
codeCls_template_insert.setVersionSeq(Integer.parseInt(rvObj.get("VERSIONSEQ").toString()));
|
codeCls_template_insert.setVersionValue(rvObj.get("VERSIONVAL").toString());
|
codeCls_template_insert.setLctid(codeCls_template.getLctid());
|
codeCls_template_insert.setLcStatus("Editing");
|
codeCls_template_insert.setId(codeCls_template.getId());
|
codeCls_template_insert.setName(codeCls_template.getName());
|
codeCls_template_insert.setDescription(codeCls_template.getDescription());
|
codeCls_template_insert.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
|
codeCls_template_insert.setCopyFromVersion(codeCls_template.getOid());
|
int insertCount = baseMapper.insert(codeCls_template_insert);
|
codeCls_template.setLastR("0");
|
codeCls_template.setLastModifyTime(new Date());
|
codeCls_template.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
|
baseMapper.updateById(codeCls_template);
|
//升版过后的模板oid
|
String templateNewOid = codeCls_template_insert.getOid();
|
|
//需要复制的模板属性
|
//查询老模板下边的所有属性，赋值新模板oid
|
Map<String,Object> condition = new HashMap<>(1);
|
condition.put("classifyTemplateOid",templateOldOid);
|
List<CodeClassifyTemplateAttr> codeClstempattrEntities = codeClstempattrMapper.selectByMap(condition);
|
for (CodeClassifyTemplateAttr codeClassifyTemplateAttrDO :codeClstempattrEntities){
|
codeClassifyTemplateAttrDO.setOid(VciBaseUtil.getPk());
|
codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
|
codeClstempattrMapper.insert(codeClassifyTemplateAttrDO);
|
}
|
|
//复制模板流程
|
List<ProcessTemplate> codeClassifyProcessTempDOList = copyTemplateProcess(templateOldOid,templateNewOid);
|
//复制模板阶段，阶段属性
|
Map phase_attrMap = copyTemplatePhase_attr(templateOldOid,templateNewOid);
|
|
List<CodeTemplatePhase> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhase>)phase_attrMap.get("phase");//模板阶段
|
List<CodePhaseAttr> codePhaseAttrDOList = (ArrayList<CodePhaseAttr>)phase_attrMap.get("phaseAttr");//阶段属性
|
|
//复制模板按钮
|
List<CodeClassifyTemplateButton> codeClassifyTemplateButtonDOList = copyTemplateButton(templateOldOid,templateNewOid);
|
|
//保存模板流程
|
if(!CollectionUtils.isEmpty(codeClassifyProcessTempDOList)) {
|
iFlowClient.processBatchSave(codeClassifyProcessTempDOList);
|
}
|
//模板阶段
|
if(!CollectionUtils.isEmpty(codeClassifyPhaseDOList)) {
|
codeTempphaseServiceImpl.saveBatch(codeClassifyPhaseDOList);
|
}
|
|
//模板阶段属性
|
if(!CollectionUtils.isEmpty(codePhaseAttrDOList)) {
|
codePhaseattrServiceImpl.saveBatch(codePhaseAttrDOList);
|
}
|
// //模板按钮
|
if(!CollectionUtils.isEmpty(codeClassifyTemplateButtonDOList)) {
|
codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList);
|
}
|
return R.success("升版成功！");
|
}
|
|
@Override
|
@Transactional
|
public R copyTemplate(CodeClassifyTemplateDTO codeClassifyDTO) {
|
//旧的模板oid
|
String oldOid = codeClassifyDTO.getOid();
|
//新的模板oid
|
String newOid = VciBaseUtil.getPk();
|
//分类oid,复制过来的新的分类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<CodeClassifyTemplate> codeClassifyTemplateDOList = new ArrayList<>();
|
codeClassifyTemplateDOList.add(codeClassifyTemplateDO_old);
|
|
//复制模板属性
|
List<CodeClassifyTemplateAttr> codeClassifyTemplateAttrDOList = copyTemplateAttr(oldOid,newOid);
|
|
//复制模板流程
|
List<ProcessTemplate> codeClassifyProcessTempDOList = copyTemplateProcess(oldOid,newOid);
|
|
//复制模板阶段，阶段属性
|
Map phase_attrMap = copyTemplatePhase_attr(oldOid,newOid);
|
|
List<CodeTemplatePhase> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhase>)phase_attrMap.get("phase");//模板阶段
|
List<CodePhaseAttr> codePhaseAttrDOList = (ArrayList<CodePhaseAttr>)phase_attrMap.get("phaseAttr");//阶段属性
|
|
//复制模板按钮
|
List<CodeClassifyTemplateButton> codeClassifyTemplateButtonDOList = copyTemplateButton(oldOid,newOid);
|
|
// baseMapper.insert(codeClassifyTemplateDOList);
|
this.saveBatch(codeClassifyTemplateDOList);
|
codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList);
|
iFlowClient.processBatchSave(codeClassifyProcessTempDOList);
|
codeClstempattrService.saveBatch(codeClassifyTemplateAttrDOList);
|
codeTempphaseServiceImpl.saveBatch(codeClassifyPhaseDOList);
|
codePhaseattrServiceImpl.saveBatch(codePhaseAttrDOList);
|
//一起保存数据
|
// WebUtil.setPersistence(false);//不执行保存
|
// //保存模板
|
// BatchCBO batchCBOTemplate = codeClassifyTemplateMapper.batchInsert(codeClassifyTemplateDOList);
|
// //保存模板属性
|
// if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrDOList)) {
|
// BatchCBO batchCBOTemplateAttr = codeClassifyTemplateAttrDaoI.batchInsert(codeClassifyTemplateAttrDOList);
|
// batchCBOTemplate.copyFromOther(batchCBOTemplateAttr);
|
// }
|
//
|
// //保存模板流程
|
// if(!CollectionUtils.isEmpty(codeClassifyProcessTempDOList)) {
|
// BatchCBO batchCBOTemplateProcessAttr = codeClassifyProcessTempDaoI.batchInsert(codeClassifyProcessTempDOList);
|
// batchCBOTemplate.copyFromOther(batchCBOTemplateProcessAttr);
|
// }
|
//
|
// //模板阶段
|
// if(!CollectionUtils.isEmpty(codeClassifyPhaseDOList)) {
|
// BatchCBO batchCBOTemplatePhaseAttr = codeTemplatePhaseDaoI.batchInsert(codeClassifyPhaseDOList);
|
// batchCBOTemplate.copyFromOther(batchCBOTemplatePhaseAttr);
|
// }
|
//
|
// //模板阶段属性
|
// if(!CollectionUtils.isEmpty(codePhaseAttrDOList)) {
|
// BatchCBO batchCBOTemplatePhaseAttrAttr = codePhaseAttrDaoI.batchInsert(codePhaseAttrDOList);
|
// batchCBOTemplate.copyFromOther(batchCBOTemplatePhaseAttrAttr);
|
// }
|
//
|
// //模板按钮
|
// if(!CollectionUtils.isEmpty(codeClassifyTemplateButtonDOList)) {
|
// BatchCBO batchCBOTemplateButtonAttr = codeClassifyTemplateButtonDaoI.batchInsert(codeClassifyTemplateButtonDOList);
|
// batchCBOTemplate.copyFromOther(batchCBOTemplateButtonAttr);
|
// }
|
//
|
//
|
// WebUtil.setPersistence(true);//执行保存
|
//
|
// boService.persistenceBatch(batchCBOTemplate);//一起执行保存
|
return R.success("复制成功！");
|
}
|
|
|
private HashMap<String,Object> getVersionValue(int verRuleName) {
|
HashMap<String,Object> obj = new HashMap<>(2);
|
obj.put("VersionSeq",1);
|
if (verRuleName == 0) {
|
obj.put("VersionVal","1");
|
} else if (verRuleName == 1) {
|
obj.put("VersionVal","a");
|
} else if (verRuleName == 2) {
|
obj.put("VersionVal","0");
|
}
|
|
return obj;
|
}
|
|
/**
|
* 复制模板流程
|
*/
|
public List<ProcessTemplate> copyTemplateProcess(String templateOldOid,String templateNewOid){
|
Map<String,Object> wrapperMap = new HashMap();
|
wrapperMap.put("template_id",templateOldOid);
|
R<List<ProcessTemplate>> listR = iFlowClient.selectByWrapper(wrapperMap);
|
if(!listR.isSuccess()){
|
throw new VciBaseException("查询模板流程时出错，请重试！");
|
}
|
List<ProcessTemplate> codeClsflowtempEntities = listR.getData();
|
for (ProcessTemplate codeClassifyProcessTempDO:codeClsflowtempEntities){
|
codeClassifyProcessTempDO.setId(null);
|
codeClassifyProcessTempDO.setTemplateId(templateNewOid);
|
//modify by lihang - @20220406 设置模板主键位置出错，导致升版的模板中的流程是空的。
|
}
|
return codeClsflowtempEntities;
|
}
|
|
|
/**
|
* 复制模板阶段，模板属性
|
* @param templateOldOid
|
* @param templateNewOid
|
* @return map phase:(List<CodeTemplatePhaseDO>) phaseAttr:(List<CodePhaseAttrDO>)
|
*/
|
public Map copyTemplatePhase_attr(String templateOldOid,String templateNewOid){
|
//模板阶段
|
// VciQueryWrapperForDO phaseWrapper = new VciQueryWrapperForDO(CodeTemplatePhaseDO.class);
|
// phaseWrapper.addQueryMap("codeClassifyTemplateOid",templateOldOid);
|
Map<String,Object> condition = new HashMap<>(1);
|
condition.put("codeclassifyTemplateOid",templateOldOid);
|
List<CodeTemplatePhase> codeTempphaseEntities = codeTempphaseMapper.selectByMap(condition);
|
// List<CodeTemplatePhaseDO> codeClassifyPhaseDOList = codeTemplatePhaseDaoI.selectByWrapper(phaseWrapper);//要保存的新的模板流程
|
Map<String,String> phaseKeyMap = new HashMap<String,String>();//需要复制的模板阶段属性,key:value,模板阶段老oid:模板属性新oid
|
List<String> phaseOidList = new ArrayList<String>();
|
for (CodeTemplatePhase codeTemplatePhaseDO:codeTempphaseEntities){
|
String oldoid = codeTemplatePhaseDO.getOid();
|
String newOid = VciBaseUtil.getPk();
|
codeTemplatePhaseDO.setOid(newOid);
|
codeTemplatePhaseDO.setCodeClassifyTemplateOid(templateNewOid);
|
phaseKeyMap.put(oldoid,newOid);
|
phaseOidList.add(oldoid);
|
}
|
|
//模板阶段的属性
|
List<CodePhaseAttr> codePhaseAttrDOList = new ArrayList<CodePhaseAttr>();
|
|
if(!CollectionUtils.isEmpty(phaseOidList)){//size()==0下边方法会报错
|
// Map<String,String> conditionMap = new HashMap<>();
|
// conditionMap.put("codephaseoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(phaseOidList.toArray(new String[0])) + ")");
|
// codePhaseAttrDOList = codePhaseAttrDaoI.selectByCondition(conditionMap,new PageHelper(-1));
|
codePhaseAttrDOList = codePhaseattrMapper.selectByPhaseaIds(VciBaseUtil.toInSql(phaseOidList.toArray(new String[0])));
|
}
|
for (CodePhaseAttr codePhaseAttrDO:codePhaseAttrDOList){
|
String oldPhaseoid = codePhaseAttrDO.getCodePhaseOid();
|
// String newOid = VciBaseUtil.getPk();
|
codePhaseAttrDO.setOid(null);
|
codePhaseAttrDO.setCodePhaseOid(phaseKeyMap.get(oldPhaseoid));
|
// codePhaseattrMapper.insert(codePhaseAttrDO);
|
}
|
Map phaseMap = new HashMap();
|
phaseMap.put("phase",codeTempphaseEntities);
|
phaseMap.put("phaseAttr",codePhaseAttrDOList);
|
return phaseMap;
|
}
|
|
/**
|
* 复制模板按钮
|
*/
|
public List<CodeClassifyTemplateButton> copyTemplateButton(String templateOldOid,String templateNewOid){
|
|
Map<String,Object> condition = new HashMap<>(1);
|
condition.put("classifyTemplateOid",templateOldOid);
|
// VciQueryWrapperForDO buttonWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateButtonDO.class);
|
// buttonWrapper.addQueryMap("classifyTemplateOid",templateOldOid);
|
List<CodeClassifyTemplateButton> codeTempbuttonEntities = codeTempbuttonMapper.selectByMap(condition);
|
// List<CodeClassifyTemplateButtonDO> codeClassifyTemplateButtonDOList = codeClassifyTemplateButtonDaoI.selectByWrapper(buttonWrapper);
|
for (CodeClassifyTemplateButton codeClassifyTemplateButtonDO:codeTempbuttonEntities){
|
// String newOid = VciBaseUtil.getPk();
|
codeClassifyTemplateButtonDO.setOid(null);
|
codeClassifyTemplateButtonDO.setClassifyTemplateOid(templateNewOid);
|
}
|
return codeTempbuttonEntities;
|
}
|
|
|
/**
|
* 复制模板属性
|
*/
|
public List<CodeClassifyTemplateAttr> copyTemplateAttr(String templateOldOid,String templateNewOid){
|
|
// VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
|
// codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid);
|
|
// Map<String,Object> condition = new HashMap<>(1);
|
// condition.put("classifyTemplateOid",templateOldOid);
|
QueryWrapper<CodeClassifyTemplateAttr> wrapper=new QueryWrapper<>();
|
wrapper.eq("classifyTemplateOid",templateOldOid);
|
|
// List<CodeClassifyTemplateAttr> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery);
|
List<CodeClassifyTemplateAttr> codeClstempattrEntities = codeClstempattrMapper.selectList(wrapper);
|
|
for (CodeClassifyTemplateAttr codeClassifyTemplateAttrDO :codeClstempattrEntities){
|
// String attrOid = VciBaseUtil.getPk();
|
codeClassifyTemplateAttrDO.setOid(null);
|
codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
|
// codeClstempattrMapper.insert(codeClassifyTemplateAttrDO);
|
}
|
return codeClstempattrEntities;
|
}
|
|
|
/**
|
* 分类模板列表
|
*
|
* @param conditionMap 查询条件
|
* @param pageHelper 分页对象
|
* @return 显示对象
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
@Override
|
public DataGrid<CodeClassifyTemplateVO> gridCodeClassifyTemplate(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
|
DataGrid<CodeClassifyTemplateVO> dataGrid=new DataGrid<CodeClassifyTemplateVO>();
|
//没有传分类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());
|
query.setDescs("versionValue");
|
}
|
|
// List<CodeClstemplateVO> doList = codeClstemplateMapper.selectPlCodeClstemplatePage(Condition.getPage(query), codeClstemplateVO);
|
|
IPage<CodeClassifyTemplate> doList = baseMapper.
|
selectPage(Condition.getPage(query), Condition.getQueryWrapper(codeClstemplateQuery));
|
if (!CollectionUtils.isEmpty(doList.getRecords())) {
|
// QueryWrapper<CodeClstemplateVO> codeClstemplateVOQueryWrapper = new QueryWrapper<>();
|
// codeClstemplateVOQueryWrapper.allEq(plCodeClstemplate);
|
// List<CodeClstemplateEntity> codeClstemplateEntity = new ArrayList<>();
|
// BeanUtils.copyProperties(doList,codeClstemplateEntity);
|
|
dataGrid.setData(codeClassifyTemplateDO2VOs(doList.getRecords()));
|
dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(codeClassifyTemplateMapper.selectCount(Condition.getQueryWrapper(codeClstemplateQuery)))));
|
}
|
return dataGrid;
|
}
|
|
|
/**
|
* 增加分类模板对象
|
* @param codeClassifyTemplateDTO 分类模板对象数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
public R<CodeClassifyTemplateVO> addSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
|
VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"需要添加的数据对象");
|
|
QueryWrapper<CodeClassifyTemplate> wrapper = new QueryWrapper<>();
|
wrapper.eq("CODECLASSIFYOID",codeClassifyTemplateDTO.getCodeclassifyoid());
|
Long aLong = baseMapper.selectCount(wrapper);
|
if(aLong > 0){
|
return R.fail("该分类下已有子模版，无法新增，仅能进行升版操作！");
|
}
|
//将DTO转换为DO
|
CodeClassifyTemplate codeClassifyTemplateDO = new CodeClassifyTemplate();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDO);
|
|
//查询分类以及上级分类的业务类型btmtypeid、btmtypename
|
List<CodeClassify> codeClassifyDOList = codeClassifyService.selectAllLevelParents(codeClassifyTemplateDTO.getCodeclassifyoid());
|
|
//所有分类都没有业务类型，返回提示
|
if(codeClassifyDOList.size()==0){
|
return R.fail(DATA_OID_NOT_EXIST);
|
}
|
|
//设置btmtypeid和name
|
CodeClassify codeClassifyDO = codeClassifyDOList.stream().filter(s -> StringUtils.isNotBlank(s.getBtmTypeId())).findFirst().get();
|
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<CodeClassifyTemplateAttrDO> attrDOList = new ArrayList<>();
|
|
// CodeClassifyTemplateAttrDO codeAttr = new CodeClassifyTemplateAttrDO();
|
// codeAttr.setId("id");
|
// codeAttr.setName("企业编码");
|
// codeAttr.setAttributeDataType("VTString");
|
// codeAttr.setAttrTableWidth(150);
|
// codeAttr.setOrderNum(1);
|
// codeAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
|
// codeAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
|
// codeAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
|
// attrDOList.add(codeAttr);
|
//
|
//
|
// CodeClassifyTemplateAttrDO groupAttr = new CodeClassifyTemplateAttrDO();
|
// groupAttr.setId("name");
|
// groupAttr.setName("集团码");
|
// groupAttr.setAttributeDataType("VTString");
|
// groupAttr.setAttrTableWidth(150);
|
// groupAttr.setOrderNum(2);
|
// groupAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
|
// groupAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
|
// groupAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
|
// attrDOList.add(groupAttr);
|
//
|
// CodeClassifyTemplateAttrDO descAttr = new CodeClassifyTemplateAttrDO();
|
// descAttr.setId("description");
|
// descAttr.setName("描述");
|
// descAttr.setAttrTableWidth(150);
|
// descAttr.setAttributeDataType("VTString");
|
// descAttr.setOrderNum(3);
|
// descAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
|
// descAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
|
// descAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
|
// attrDOList.add(descAttr);
|
//
|
// CodeClassifyTemplateAttrDO statusAttr = new CodeClassifyTemplateAttrDO();
|
// statusAttr.setId("lcstatus");
|
// statusAttr.setName("状态");
|
// statusAttr.setAttrTableWidth(70);
|
// statusAttr.setOrderNum(4);
|
// statusAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
|
// statusAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
|
// statusAttr.setAttributeDataType("VTString");
|
// statusAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
|
// attrDOList.add(statusAttr);
|
//
|
//
|
// CodeClassifyTemplateAttrDO secAttr = new CodeClassifyTemplateAttrDO();
|
// secAttr.setId("secretgrade");
|
// secAttr.setName("密级");
|
// secAttr.setAttrTableWidth(70);
|
// secAttr.setAttributeDataType(VciFieldTypeEnum.VTInteger.name());
|
// secAttr.setEnumId("Enumsecretgrade");
|
// secAttr.setEnumName("密级");
|
// secAttr.setOrderNum(4);
|
// secAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
|
// secAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
|
// secAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
|
// attrDOList.add(secAttr);
|
|
return R.data(codeClassifyTemplateDO2VO(codeClassifyTemplateDO));
|
}
|
|
/**
|
* 修改分类模板对象
|
* @param codeClassifyTemplateDTO 分类模板对象数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
public R editSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
|
VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"数据对象",codeClassifyTemplateDTO.getOid(),"分类模板对象主键");
|
//检查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<String,Object> condition = new HashMap<>(2);
|
// condition.put("oid",codeClassifyTemplateDOCopyFromDTO.getOid());
|
// condition.put("ts",codeClassifyTemplateDOCopyFromDTO.getTs());
|
CodeClassifyTemplate detail = baseMapper
|
.selectById(codeClassifyTemplateDOCopyFromDTO.getOid());
|
// boolean tsBoolean = boService.checkTs(codeClassifyTemplateAttrDOListemplateDOCopyFromDTO);
|
if(detail.getTs().compareTo(codeClassifyTemplateDOCopyFromDTO.getTs()) != 0){//不是最新的不让改
|
return R.fail("当前数据不是最新，请刷新后再修改！");
|
}
|
|
//将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<CodeClassifyTemplateVO> childTemplates(String codeClassifyOid){
|
List<CodeClassifyTemplateVO> codeClassifyTemplateVOList=new ArrayList<>();
|
// Map<String/**模板的主键**/,String/**分类的主键**/> childHasTemplateMap =baseMapper
|
// .selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED,
|
// codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue());
|
List<Map<String,String>> childHasTemplateList =baseMapper
|
.selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED,
|
codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue());
|
Map<String/**模板的主键**/,String/**分类的主键**/> childHasTemplateMap = new HashMap<>();
|
if(!CollectionUtils.isEmpty(childHasTemplateList)){
|
childHasTemplateList.stream().forEach(cbo->{
|
childHasTemplateMap.put(cbo.get("OID"),cbo.get("CLSOID"));
|
});
|
}
|
|
Set<String> templateOid = childHasTemplateMap.keySet();
|
List<CodeClassifyTemplate> classifyTemplateDOS=new ArrayList<>();
|
if(!CollectionUtils.isEmpty(templateOid)) {
|
classifyTemplateDOS= this.listCodeClassifyTemplateDOByOidCollections(templateOid);
|
}else{
|
classifyTemplateDOS=selectOnlyTemplateByClassifyOid(codeClassifyOid);
|
}
|
List<CodeClassifyTemplateVO> templateVOList = codeClassifyTemplateDO2VOs(classifyTemplateDOS, true);
|
if(!CollectionUtils.isEmpty(templateVOList)){
|
codeClassifyTemplateVOList.addAll(templateVOList);
|
}
|
return codeClassifyTemplateVOList;
|
}
|
|
|
/**
|
* 使用分类主键递归查询
|
* @param codeClassifyOid 分类的主键
|
* @return 模板的数据对象
|
*/
|
private List<CodeClassifyTemplate> selectOnlyTemplateByClassifyOid(String codeClassifyOid){
|
//1.直接查询，看看这个分类下面有没有发布状态的模板
|
//2.如果没有，则往上找分类的内容，这个分类层级不会太多，所以直接递归即可
|
//3.如果分类下面添加了模板，但是没有发布，则说明模板可能还在编辑的状态，依然使用上级分类
|
|
// Map<String,String> conditionMap = new HashMap<>();
|
// conditionMap.put("codeClassifyOid",codeClassifyOid);
|
// conditionMap.put("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue());
|
QueryWrapper<CodeClassifyTemplate> wrapper=new QueryWrapper<>();
|
wrapper.eq("codeClassifyOid",codeClassifyOid)
|
.eq("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue());
|
|
List<CodeClassifyTemplate> templateDOS = baseMapper.selectList(wrapper);
|
if(CollectionUtils.isEmpty(templateDOS)){
|
//递归找上级的模板
|
CodeClassify classifyDO = codeClassifyMapper.selectById(codeClassifyOid);
|
// codeClassifyDaoI.selectByPrimaryKey(codeClassifyOid);
|
if(Func.isEmpty(classifyDO)&&StringUtils.isBlank(classifyDO.getParentCodeClassifyOid())){
|
//说明已经是顶了，也没找到的话，那就返回了
|
return new ArrayList<>();
|
}
|
if(StringUtils.isNotBlank(classifyDO.getParentCodeClassifyOid())) {
|
return selectOnlyTemplateByClassifyOid(classifyDO.getParentCodeClassifyOid());
|
}else{
|
return new ArrayList<>();
|
}
|
}else{
|
return templateDOS;
|
}
|
}
|
|
/**
|
* 使用主题库的分类主键，获取生效的模板
|
*
|
* @param codeClassifyOid 主题库分类主键
|
* @param hasAttribute 是否包含属性
|
* @return 模板的信息
|
*/
|
@Override
|
public List<CodeClassifyTemplateVO> listReleaseTemplateByClassifyOid(String codeClassifyOid, boolean hasAttribute) {
|
VciBaseUtil.alertNotNull(codeClassifyOid,"主题库分类主键");
|
List<CodeClassifyTemplate> templateDOS = selectOnlyTemplateByClassifyOid(codeClassifyOid);
|
if(CollectionUtils.isEmpty(templateDOS)){
|
throw new VciBaseException("当前分类，以及其上级分类都没有设置模板");
|
}
|
List<CodeClassifyTemplateVO> templateVOList = codeClassifyTemplateDO2VOs(templateDOS, true);
|
return sortTemplateByRevision(templateVOList);
|
}
|
|
/**
|
* 用模板的版本来排序
|
* @param templateVOList 模板的显示对象
|
* @return 排序后的列表
|
*/
|
@Override
|
public List<CodeClassifyTemplateVO> sortTemplateByRevision(List<CodeClassifyTemplateVO> templateVOList){
|
if(!CollectionUtils.isEmpty(templateVOList) && templateVOList.size() >1){
|
//获取版本号最大的那个
|
templateVOList = templateVOList.stream().sorted((o1,o2)->
|
Integer.valueOf(o1.getRevisionSeq()).compareTo(Integer.valueOf(o2.getRevisionValue()))
|
).collect(Collectors.toList());
|
}
|
return templateVOList;
|
}
|
|
/**
|
* 主键获取分类模板对象(包含属性）
|
*
|
* @param oid 主键
|
* @return 分类模板对象显示对象
|
* @throws VciBaseException 参数为空，数据不存在时会抛出异常
|
*/
|
@Override
|
public CodeClassifyTemplateVO getObjectHasAttrByOid(String oid) throws VciBaseException {
|
List<CodeClassifyTemplate> doList = new ArrayList<>();
|
doList.add(selectByOid(oid));
|
List<CodeClassifyTemplateVO> templateVOS = codeClassifyTemplateDO2VOs(doList, true);
|
return CollectionUtils.isEmpty(templateVOS)?null:templateVOS.get(0);
|
}
|
}
|
