/*
 *      Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: Chill 庄骞 (smallchill@163.com)
 */
package com.vci.ubcs.code.service.impl;

import com.alibaba.nacos.api.utils.StringUtils;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.dto.CodeClstemplateDTO;
import com.vci.ubcs.code.entity.CodeClstempattrEntity;
import com.vci.ubcs.code.entity.CodeClstemplateEntity;
import com.vci.ubcs.code.enumpack.CodeClassifyTemplateLC;
import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
import com.vci.ubcs.code.mapper.CodeClstempattrMapper;
import com.vci.ubcs.code.mapper.CodeClstemplateMapper;
import com.vci.ubcs.code.service.ICodeClstemplateService;
import com.vci.ubcs.code.vo.CodeClstempattrVO;
import com.vci.ubcs.code.vo.CodeClstemplateVO;
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.Tree;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_RELEASED;
import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.LC_STATUS;
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<CodeClstemplateMapper, CodeClstemplateEntity> implements ICodeClstemplateService {

	/**
	 * 模板属性的服务
	 */
	@Lazy
	@Autowired(required = false)
	CodeClstempattrServiceImpl codeClstempattrService;

	/**
	 * 对象的操作
	 */
	@Autowired(required = false)
	private RevisionModelUtil revisionModelUtil;

	@Autowired(required = false)
	private CodeClstempattrMapper codeClstempattrMapper;
	@Autowired(required = false)
	private CodeTempphaseServiceImpl codeTempphaseServiceImpl;
	@Autowired(required = false)
	private CodeTempbuttonServiceImpl codeTempbuttonServiceImpl;
	@Autowired(required = false)
	private CodeClsflowtempServiceImpl codeClsflowtempServiceImpl;
	@Override
	public IPage<CodeClstemplateVO> selectPlCodeClstemplatePage(IPage<CodeClstemplateVO> page, CodeClstemplateVO plCodeClstemplate) {
		return page.setRecords(baseMapper.selectPlCodeClstemplatePage(page, plCodeClstemplate));
	}

	/**
	 * 查询分类模板对象 树
	 * @param treeQueryObject 树查询对象
	 * @return 分类模板对象 显示树
	 */
	@Override
	public List<Tree> treeCodeClassifyTemplate(TreeQueryObject treeQueryObject) {
		List<CodeClstemplateEntity> doList =selectCodeClassifyTemplateDOByTree(treeQueryObject);

		List<CodeClstemplateVO> voList = codeClassifyTemplateDO2VOs(doList);
		TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
		treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
		return revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClstemplateVO s) ->{
			//可以在这里处理树节点的显示
			return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
				.getLcStatus()) ? (" 【停用】 ") : "");
		});
	}

	/**
	 * 根据树形查询对象来查询数据对象
	 *
	 * @param treeQueryObject 树形查询对象
	 * @return 查询结果,数据对象
	 */
	@Override
	public List<CodeClstemplateEntity> 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();
		return baseMapper.selectList(Condition.getQueryWrapper(codeClstemplateEntity));
//		return codeClassifyTemplateMapper.selectByWrapper(queryWrapperForDO);
	}

	/**
	 * 批量数据对象转换为显示对象
	 * @param codeClassifyTemplateDOs 数据对象列表
	 * @return 显示对象
	 */
	@Override
	public List<CodeClstemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClstemplateEntity> codeClassifyTemplateDOs) {
		return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOs,false);
	}

	/**
	 * 批量数据对象转换为显示对象
	 * @param codeClassifyTemplateDOs 数据对象列表
	 * @param hasAttr 是否包含属性
	 * @return 显示对象
	 */
	@Override
	public List<CodeClstemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClstemplateEntity>  codeClassifyTemplateDOs,boolean hasAttr) {
		List<CodeClstemplateVO> voList = new ArrayList<CodeClstemplateVO>();
		if(!CollectionUtils.isEmpty(codeClassifyTemplateDOs)){
			for(CodeClstemplateEntity s: codeClassifyTemplateDOs){
				CodeClstemplateVO vo =  codeClassifyTemplateDO2VO(s);
				if(vo != null){
					voList.add(vo);
				}
			}
		}
		if(hasAttr){
			//一个分类里面总不能超过1000个生效的版本吧！！！
			VciBaseUtil.switchCollectionForOracleIn(voList.stream().map(CodeClstemplateVO::getOid).collect(Collectors.toList())).forEach(tempOids->{
				List<CodeClstempattrVO> attrVOList = codeClstempattrService.listCodeClassifyTemplateAttrByTemplateOids(tempOids);

				if(!CollectionUtils.isEmpty(attrVOList)){
					Map<String, List<CodeClstempattrVO>> 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 显示对象
	 */
	@Override
	public  CodeClstemplateVO codeClassifyTemplateDO2VO(CodeClstemplateEntity codeClassifyTemplateDO) {
		CodeClstemplateVO vo = new CodeClstemplateVO();
		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(CodeClstemplateDTO codeClstemplateDTO) {
		VciBaseUtil.alertNotNull(codeClstemplateDTO,"数据传输对象",codeClstemplateDTO.getOid(),"主键");
		CodeClstemplateEntity codeClstemplateEntity = baseMapper.selectById(codeClstemplateDTO.getOid());
		return checkIsCanDeleteForDO(codeClstemplateDTO,codeClstemplateEntity);
	}

	/**
	 * 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
	 * @param codeClstemplateDTO 数据传输对象
	 * @param codeClstemplateEntity 数据库中的数据对象
	 * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
	 */
	private R checkIsCanDeleteForDO(CodeClstemplateDTO codeClstemplateDTO, CodeClstemplateEntity codeClstemplateEntity) {
		CodeClstemplateEntity codeClassifyTemplateDOCopyFromDTO = new CodeClstemplateEntity();
		BeanUtilForVCI.copyPropertiesIgnoreCase(codeClstemplateDTO,codeClassifyTemplateDOCopyFromDTO);

		//检查ts
		Map<String,Object> condition = new HashMap<>(2);
		condition.put("oid",codeClstemplateDTO.getOid());
		condition.put("ts",codeClstemplateDTO.getTs());
		CodeClstemplateEntity detail = baseMapper
			.selectOne(Condition.getQueryWrapper(condition,CodeClstemplateEntity.class));
		if(detail == null){//不是最新的不让改
			return R.fail("当前数据不是最新，请刷新后再修改！");
		}
		//校验下级是否有引用
		if(checkChildIsLinked(codeClstemplateEntity.getOid())){
			return R.fail(DATA_CASCADE_LINKED_NOT_DELETE);
		}
		return R.status(checkHasChild(codeClstemplateEntity.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：失败
	 */
	@Override
	public R deleteCodeClassifyTemplate(CodeClstemplateDTO codeClstemplateDTO) {
		checkIsCanDelete(codeClstemplateDTO);
		VciBaseUtil.alertNotNull(codeClstemplateDTO,"分类模板对象数据对象",codeClstemplateDTO.getOid(),"分类模板对象的主键");

		CodeClstemplateEntity 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<CodeClstempattrEntity> codeClstempattrEntityList = codeClstempattrMapper.selectRefByOid(templateOid);

		if(!CollectionUtils.isEmpty(codeClstempattrEntityList)) {
			List<String> templateAttrOids = new ArrayList<String>();
			for (CodeClstempattrEntity 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  CodeClstemplateVO getObjectByOid(String oid) {
		return codeClassifyTemplateDO2VO(selectByOid(oid));
	}

	@Override
	public Collection<CodeClstemplateVO> listCodeClassifyTemplateByOids(List<String> oidCollections) {
		VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合");
		List<CodeClstemplateEntity> codeClassifyTemplateDOList = listCodeClassifyTemplateDOByOidCollections(oidCollections);
		return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOList);
	}

	/**
	 * 参照树 分类模板对象
	 * @param treeQueryObject 树形查询对象
	 * @return 分类模板对象显示树
	 * @throws VciBaseException 查询条件和分页出错的时候会抛出异常
	 */
	@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<CodeClstemplateEntity> listCodeClassifyTemplateDOByOidCollections(Collection<String> oidCollections){
		List<CodeClstemplateEntity> codeClassifyTemplateDOList = new ArrayList<CodeClstemplateEntity>();
		if(!CollectionUtils.isEmpty(oidCollections)){
			Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
			for(Collection<String> oids: oidCollectionsList){
				List<CodeClstemplateEntity> tempDOList =  baseMapper.selectBatchIds(oids); //codeClassifyTemplateMapper.selectByPrimaryKeyCollection(oids);
				if(!CollectionUtils.isEmpty(tempDOList)){
					codeClassifyTemplateDOList.addAll(tempDOList);
				}
			}
		}
		return  codeClassifyTemplateDOList;
	}

	/**
	 * 主键查询数据对象
	 * @param oid 主键
	 * @return  数据对象
	 */
	private CodeClstemplateEntity  selectByOid(String oid) {
		VciBaseUtil.alertNotNull(oid,"主键");
		CodeClstemplateEntity codeClstemplateEntity = baseMapper.selectById(oid.trim());
		if(codeClstemplateEntity == null || StringUtils.isBlank(codeClstemplateEntity.getOid())){
			throw new VciBaseException(DATA_OID_NOT_EXIST);
		}
		return codeClstemplateEntity;
	}

	/**
	 * 启用、停用
	 * @param oid
	 * @param lcStatus
	 * @return
	 */
	@Override
	public R updateLcStatus( String oid, String lcStatus){
		CodeClstemplateEntity codeClassifyTemplateDO = baseMapper.selectById(oid);
		//停用的时候，验证模板是否为已发布
		if(CodeClassifyTemplateLC.DISABLED.getValue().equals(lcStatus)){
//			CodeClstemplateEntity codeClassifyTemplateDO = baseMapper.selectById(oid);
			if(!CodeClassifyTemplateLC.RELEASED.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
				return R.fail("模板未启用，不能停用！");
			}
		}
		//启用、停用
		codeClassifyTemplateDO.setLcStatus(lcStatus);
		int u = baseMapper.updateById(codeClassifyTemplateDO);
//		codeClassifyTemplateMapper.updateLcStatus(oid,lcStatus);

		return u==0?R.fail("修改失败！"):R.success("修改成功");
	}

	/**
	 * 升版
	 * @param codeClassifyDTO
	 */
	@Override
	public R Upgrade(CodeClstemplateDTO codeClassifyDTO) {

		//旧的模板oid
		String templateOldOid = codeClassifyDTO.getOid();
		//只有已发布的才能升版
		CodeClstemplateEntity codeClassifyTemplateDOOld =  baseMapper.selectById(templateOldOid);
		if(!FRAMEWORK_RELEASE_RELEASED.equals(codeClassifyTemplateDOOld.getLcStatus())){
			return R.fail("该模板未发布，不能升版！");
		}

		//需要新增的升级模板
//		ClientBusinessObject clientBusinessObject_template = boService.selectCBOByOid(codeClassifyDTO.getOid(), "codeclstemplate");
		CodeClstemplateEntity codeCls_template = baseMapper.selectById(templateOldOid);
		CodeClstemplateEntity codeCls_template_insert = null;
//			ClientBusinessObject clientBusinessObject_template_insert = null;
//		try {
////			clientBusinessObject_template_insert = clientBusinessObjectOperation.reviseBusinessObject(clientBusinessObject_template, "");
////			codeCls_template_insert.setOid((new ObjectUtility()).getNewObjectID36());
////			toBo.setRevisionid((new ObjectUtility()).getNewObjectID36());
//			codeCls_template_insert.setNameOid(codeCls_template.getNameOid());
//			codeCls_template_insert.setBtmname(codeCls_template.getBtmname());
////			codeCls_template_insert.setIsLast(1);
////			codeCls_template_insert.setIsFirstr(0);
////			codeCls_template_insert.setIsFirstv(1);
////			codeCls_template_insert.setIsLastV(1);
//			codeCls_template_insert.setCreator(AuthUtil.getUser().getUserName());
//			codeCls_template_insert.setCreateTime(new Date());
//			codeCls_template_insert.setLastModifier(AuthUtil.getUser().getUserName());
//			codeCls_template_insert.setLastModifyTime(new Date());
//			codeCls_template_insert.setRevisionRule(codeCls_template.getRevisionRule());
//			codeCls_template_insert.setVersionRule(codeCls_template.getVersionRule());
//			RevisionValueObject rvObj = this.getNextRevision(fromBo.getBtmName(), fromBo.getNameoid(), item.revRuleName, item.revInput, revisionVal);
//			codeCls_template_insert.setRevisionSeq(rvObj.getRevisionSeq());
//			codeCls_template_insert.setRevisionValue(rvObj.getRevisionVal());
//			VersionValueObject versionObj = this.getVersionValue(item.verRuleName);
//			codeCls_template_insert.setVersionSeq(versionObj.getVersionSeq());
//			codeCls_template_insert.setVersionValue(versionObj.getVersionVal());
//			codeCls_template_insert.setLctId(codeCls_template.getLctId());
//			codeCls_template_insert.setLcStatus(this.getLcFirstStatus(item.lifeCycle));
//			codeCls_template_insert.setId(codeCls_template.getId());
//			codeCls_template_insert.setName(codeCls_template.getName());
//			codeCls_template_insert.setDescription(codeCls_template.getDescription());
//			codeCls_template_insert.setOwner(AuthUtil.getUser().getUserName());
////			codeCls_template_insert.setCheckinBy(userName);
//			codeCls_template_insert.setCopyFromVersion(codeCls_template.getOid());
//		}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("升版成功！");
		return R.success("升版成功！");
	}
}