package org.jeecg.modules.base.controller;

import java.text.ParseException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.system.vo.SelectTreeModel;
import org.jeecg.modules.base.entity.FactoryModel;
import org.jeecg.modules.base.service.IEnterpriseService;
import org.jeecg.modules.base.service.IFactoryModelService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.modules.quartz.entity.QuartzJob;
import org.jeecg.modules.quartz.service.IQuartzJobService;
import org.jeecg.common.system.base.entity.DataVersion;
import org.jeecg.modules.system.service.IDataVersionService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

 /**
 * @Description: 工厂建模
 * @Author: jeecg-boot
 * @Date:   2022-11-08
 * @Version: V1.0
 */
@Api(tags="工厂建模")
@RestController
@RequestMapping("/base/factoryModel")
@Slf4j
public class FactoryModelController extends JeecgController<FactoryModel, IFactoryModelService>{
	@Autowired
	private IFactoryModelService factoryModelService;
	@Autowired
	private IEnterpriseService enterpriseService;
	@Autowired
	private ISysUserService sysUserService;
	@Autowired
	private IDataVersionService dataVersionService;
	@Autowired
	private IQuartzJobService quartzJobService;
	 /**
	  * 获取初始信息
	  *
	  *
	  */
	 @GetMapping("/getFactoryInfo")
	 public Result<?> getFactoryInfo(){
		 Map<String,Object> infoMap = new HashMap<>(2);
		 LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//		 infoMap.put("enterpriseId",loginUser.getEnterpriseId());
		 infoMap.put("version",factoryModelService.getUsableVersion().get(0));
		 return Result.OK(infoMap);
	 }
	 /**
	  * 生效车间列表
	  * @return
	  */
	 @GetMapping("getUsableWorkShopList")
	 public Result<?> getUsableList(){
	 	return Result.OK(factoryModelService.getUsableWorkShopList());
	 }
	 /**
	  * 根据版本获取版本号
	  *
	  *
	  */
	 @GetMapping("/getVersionStatusByVersion")
	 public Result<?> getVersionStatusByVersion(@RequestParam(value = "version",required = false) Integer version){
	 	return Result.OK(factoryModelService.getVersionStatusByVersion(version));
	 }
	 /**
	  * 获取初始版本号
	  *
	  *
	  */
	 @GetMapping("/getInitVersion")
	 public Result<?> getUsableVersion(){
		 return Result.OK(factoryModelService.getInitVersion());
	 }
	 /**
	  * 获取所有版本号
	  *
	  *
	  */
	 @GetMapping("/getVersionList")
	 public Result<?> getAllVersion(){
		 return Result.OK(factoryModelService.getVersionList());
	 }
	 /**
	  * //根据企业id及版本号查询工厂树
	  *
	  * @param enterpriseId
	  * @param version
	  * @return
	  */
	@GetMapping("/loadTree")//根据使用者的id查其所在工厂的树
    public Result<?> loadTree(@RequestParam(value = "enterpriseId", required = false)String enterpriseId,
							  @RequestParam(value = "version", required = false) Integer version){
		List<SelectTreeModel> list = new ArrayList<>();
		SelectTreeModel selectTreeModel = new SelectTreeModel();
		selectTreeModel.setKey(enterpriseId);
		selectTreeModel.setChildren(factoryModelService.loadTree(enterpriseId,version));
		selectTreeModel.setTitle("工厂建模");
		list.add(selectTreeModel);
		return Result.OK(list);
	}

	 /**
	  * //根据工厂id查所有子工厂及车间
	  *
	  * @param pageNo
	  * @param pageSize
	  * @param parentId
	  * @param version
	  * @return
	  */
	@GetMapping("/list")//根据工厂id查所有子工厂及车间
	public Result<?> list(Map map,
						  @RequestParam(name ="pageNo", defaultValue="1") Integer pageNo,
						  @RequestParam(name ="pageSize", defaultValue="10") Integer pageSize,
						  @RequestParam(name = "parentId",required = false) String parentId,
						  @RequestParam(name="version",required = false) Integer version,
						  @RequestParam(name="selected",required = false) String selected
						  ){
		List<String> ids =  new ArrayList<>();
		if(selected!=null){
			ids = Arrays.asList(selected.split(","));
		}
		Page<Map<String,Object>> page = new Page(pageNo, pageSize);
		IPage<Map<String,Object>> pageList = factoryModelService.getFactoryList(page,version,parentId,ids);
		return Result.OK(pageList);
	}
	 /**
	  * 查所有部门
	  *
	  * @param
	  * @return
	  */
	@GetMapping("/departList")
	public Result<?> departList(){
		return Result.OK(factoryModelService.getDepartList());
	}
	 /**
	  * 根据客户id查客户所在公司id
	  *
	  * @param uid
	  * @return
	  */
	@GetMapping("/enterprise/{uid}")
	public Result<?> getEidByUid(@PathVariable("uid") String uid){
		return Result.OK(factoryModelService.getEidByUid(uid));
	}
	 /**
	  * 表单校验
	  *
	  * @param name
	  * @param parentId
	  * @param version
	  * @return
	  */
	 @GetMapping("/check")
	 public Result<?> checkName(@RequestParam(name="name",required = true) String name,
								@RequestParam(name="version",required = false) Integer version,
								@RequestParam(name="parentId",required = true) String parentId){
		 QueryWrapper<FactoryModel> queryWrapper = new QueryWrapper<>();
		 if(!StringUtils.isBlank(name)){
			 queryWrapper.eq("name",name);
		 }
		 if(version!=null){
			 queryWrapper.eq("version",version);
		 }
		 if(!StringUtils.isBlank(parentId)){
			 queryWrapper.eq("parent_id",parentId);
		 }
		 queryWrapper.eq("del_flag","0");
		 return Result.OK(factoryModelService.list(queryWrapper));
	 }
	 /**
	  *
	  * 查当前生效企业下有无部门历史版本
	  *
	  */
	 @Transactional
	 @GetMapping(value = "/getNewVersionPermission")
	 public Result<?> getNewVersionPermission(){
		 List<String> usableEnterpriseIds = enterpriseService.getUsableIdList();
		 return Result.OK(factoryModelService.list(new QueryWrapper<FactoryModel>().in("enterprise_id",usableEnterpriseIds).eq("del_flag",0)));
	 }
	 /**
	  *
	  * 查当前生效企业下有无部门历史版本
	  *
	  */
	 @Transactional
	 @GetMapping(value = "/getUpdateVersionPermission")
	 public Result<?> getUpdatePermission(@RequestParam("version") Integer version){
		 List<String> usableEnterpriseIds = enterpriseService.getUsableIdList();
		 return Result.OK(factoryModelService.list(new QueryWrapper<FactoryModel>()
				 .in("enterprise_id",usableEnterpriseIds)
				 .eq("version",version)
				 .eq("del_flag",0)));
	 }
	/**
	 *   添加
	 *
	 * @param map
	 * @return
	 */
	@AutoLog(value = "工厂建模-添加")
	@ApiOperation(value="工厂建模-添加", notes="工厂建模-添加")
	@PostMapping(value = "/add")
	@Transactional
	public Result<String> add(@RequestBody Map<String,Object> map) {
		FactoryModel factoryModel = new FactoryModel();
		factoryModel.setCode(String.valueOf(map.get("code")))
				.setName(String.valueOf(map.get("name")))
				.setVersion(Integer.parseInt(String.valueOf(map.get("version"))))
				.setParentId(String.valueOf(map.get("parentId")))
				.setEnterpriseId(String.valueOf(map.get("enterpriseId")))
				.setFactoryElementCategoryId(String.valueOf(map.get("factoryElementCategoryId")))
				.setRemark(String.valueOf(map.get("remark")))
				.setDepartId(String.valueOf(map.get("departId")))
				.setVirtualFlag(Integer.parseInt(String.valueOf(map.get("virtualFlag"))))
				.setDelFlag(0);
		factoryModelService.save(factoryModel);
		QueryWrapper<FactoryModel> queryWrapper = new QueryWrapper<FactoryModel>()
				.eq("code",factoryModel.getCode())
				.eq("version",factoryModel.getVersion())
				.eq("del_flag",0);
		FactoryModel selectFactoryModel = factoryModelService.getOne(queryWrapper,true);
		DataVersion dataVersion = new DataVersion();
		dataVersion.setBusinessId(selectFactoryModel.getId())
				.setBusinessType("工厂建模")
				.setVersion(selectFactoryModel.getVersion())
				.setVersionStatus(String.valueOf(map.get("versionStatus")))
				.setDelFlag(0)
				.setEffectiveType("0")
				.setIsLastUsable("0");
		dataVersionService.save(dataVersion);
		QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>()
				.eq("business_id",selectFactoryModel.getId()).eq("del_flag",0);
		DataVersion selectDataVersion = dataVersionService.getOne(queryWrapper1,true);
		selectFactoryModel.setDataVersionId(selectDataVersion.getId());
		factoryModelService.saveOrUpdate(selectFactoryModel);
		return Result.OK("添加成功！");
	}
	/**
	 *  编辑
	 *
	 * @param factoryModel
	 * @return
	 */
	@AutoLog(value = "工厂建模-编辑")
	@ApiOperation(value="工厂建模-编辑", notes="工厂建模-编辑")
	@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
	public Result<String> edit(@RequestBody FactoryModel factoryModel) {
		factoryModelService.updateById(factoryModel);
		return Result.OK("编辑成功!");
	}
	 /**
	  *  升版
	  *
	  * @param map
	  * @return
	  */
	 @PostMapping("/updateVersion")
	 @Transactional
	 public  Result<?> updateVersion(@RequestBody Map<String,Object> map){
		 Integer version = Integer.parseInt((String)map.get("version"));
		 List<String> list = enterpriseService.getUsableIdList();
		 Integer newVersion =factoryModelService.getVersionList().stream().findFirst().get()+1;
		 list.forEach(id->{
			 recurrenceUpdata(id,id,version,newVersion);
		 });
		 return Result.OK("升版成功",newVersion);
	 }
	 /**
	  * 立即生效
	  * 需要一次完成
	  * @param map
	  * @param
	  * @return
	  */
	 @PostMapping("/updateVersionStatusToUsable")
	 @Transactional
	 public Result<?> updateVersionStatusToUsable(@RequestBody Map<String,Object> map){
		 QuartzJob quartzJob = quartzJobService.getOne(new QueryWrapper<QuartzJob>()
				 .eq("job_class_name","org.jeecg.modules.quartz.job.FactoryModelSetUsableJob"),true);
		 if(ObjectUtils.isNotNull(quartzJob)){
			 quartzJobService.deleteAndStopJob(quartzJob);
		 }
		 //获取版本号
		 Integer version = Integer.parseInt((String)map.get("version"));
		 //获取上次生效版本并将其是否上次生效位置置为否
		 List<FactoryModel> lastUsableList = factoryModelService.getLastUsableList(null);
		 if(CollectionUtils.isNotEmpty(lastUsableList)){
			 List<DataVersion> lastUsableVersionList = dataVersionService.list( new QueryWrapper<DataVersion>()
					 .in("business_id",lastUsableList.stream()
							 .map(FactoryModel::getId)
							 .collect(Collectors.toList())).eq("del_flag",0));
			 lastUsableVersionList.stream().forEach(dataVersion -> {
				 dataVersion.setIsLastUsable("0");
			 });
			 dataVersionService.updateBatchById(lastUsableVersionList);
		 }
		 //获取生效版本及版本信息并将其置为失效
		 List<FactoryModel> usableList = factoryModelService.getUsableList(null);
		 if(CollectionUtils.isNotEmpty(usableList)){
			 List<DataVersion> usableDataVersionList = dataVersionService.list(new QueryWrapper<DataVersion>()
					 .in("business_id",usableList.stream()
							 .map(FactoryModel::getId)
							 .collect(Collectors.toList())));
			 usableDataVersionList.stream().forEach(dataVersion -> {
				 dataVersion
						 .setVersionStatus("3")
						 .setIsLastUsable("1")
						 .setExpiredTime(new Date(System.currentTimeMillis()));
			 });
			 dataVersionService.updateBatchById(usableDataVersionList);
		 }
		 //获取待生效版本及版本信息并将其置为生效
		 List<DataVersion> dataVersionList = dataVersionService.list(new QueryWrapper<DataVersion>()
				 .in("business_id",factoryModelService
						 .getAllDepartByPid(version)
						 .stream().map(FactoryModel::getId)
						 .collect(Collectors.toList())));
		 dataVersionList.stream().forEach(dataVersion -> {
			 dataVersion.setVersionStatus("2")
					 .setEffectiveType("2")
					 .setEffectiveTime(new Date(System.currentTimeMillis()))
					 .setIsLastUsable("0");
		 });
		 //存入数据库
		 dataVersionService.updateBatchById(dataVersionList);
		 return  Result.OK("生效成功");
	 }
	 /**
	  * 定时生效
	  * 需要一次性完成
	  * @param quartzJob
	  * @param
	  * @return
	  */
	 @PostMapping("/updateVersionStatusToUsableBySetTime")
	 @Transactional
	 public Result<?> updateVersionStatusToUsableBySetTime(@RequestBody QuartzJob quartzJob) throws ParseException {
		 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
		 DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("ss mm HH dd MM ? yyyy");
		 String jobClassName = quartzJob.getJobClassName();
		 String time = quartzJob.getCronExpression();
		 System.out.println(time);
		 LocalDateTime localDateTime = LocalDateTime.parse(time,dateTimeFormatter);
		 String cronStr=dateTimeFormatter1.format(localDateTime);
		 quartzJob.setCronExpression(cronStr);
		 QueryWrapper<QuartzJob> queryWrapper = new QueryWrapper();
		 queryWrapper.eq("JOB_CLASS_NAME",jobClassName);
		 List<QuartzJob> quartzJobs = quartzJobService.list(queryWrapper);
		 if(CollectionUtils.isEmpty(quartzJobs)){
			 quartzJobService.saveAndScheduleJob(quartzJob);
			 quartzJobs = quartzJobService.list(queryWrapper);
			 quartzJob.setId(quartzJobs.get(0).getId());
			 quartzJobService.resumeJob(quartzJob);
			 return  Result.OK(quartzJob);
		 }else{
			 quartzJob.setId(quartzJobs.get(0).getId());
			 quartzJobService.resumeJob(quartzJob);
			 return Result.OK(quartzJob);
		 }
	 }
	 /**
	  * 获取当前生效版本和上一次生效版本的版本号
	  *
	  * @return
	  */
	 @GetMapping("/getNowAndLastUsableVersion")
	 public Result<?> getNowAndLastUsableVersion(){
		 return Result.OK(factoryModelService.getNowAndLastUsableVersion());
	 }
	 /**
	  * 判断是否有亲子关系
	  *
	  * @param map
	  * @return
	  */
	 @PostMapping("/checkPositionInfo")
	 public Result<?> checkPositionInfo(@RequestBody Map<String,String> map){
		 String dropedKey=map.get("dropedKey");
		 String changeKey=map.get("changeKey");
		 return Result.OK(isChildren(changeKey,dropedKey)||isChildren(dropedKey,changeKey));
	 }
	 /**
	  * 拖拽节点
	  *
	  * @param map
	  * @return
	  */
	 @PostMapping("/dropAndChangeNode")
	 @Transactional
	 public Result<?> dropAndChangeNode(@RequestBody Map<String,String> map){
		 String dropedKey=map.get("dropedKey");
		 String changeKey=map.get("changeKey");
		 String dropedParentId = map.get("dropedParentId");
		 String changeParentId = map.get("changeParentId");
		 FactoryModel dropedFactory = factoryModelService.getById(dropedKey);
		 FactoryModel changeFactory = factoryModelService.getById(changeKey);
		 String dropedCode = dropedFactory.getCode();
		 String changeCode = changeFactory.getCode();
		 String status = map.get("status");
		 if("1".equals(status)||"3".equals(status)){
			 dropedFactory.setId(changeKey).setParentId(changeParentId).setCode(changeCode);
			 changeFactory.setId(dropedKey).setParentId(dropedParentId).setCode(dropedCode);
			 List<FactoryModel> list = new ArrayList<>();
			 list.add(dropedFactory);
			 list.add(changeFactory);
			 factoryModelService.updateBatchById(list);
		 }else if("4".equals(status)){
			 //互换位置
			 String finalCode="";
			 List<FactoryModel> changeChildList = factoryModelService
					 .list(new QueryWrapper<FactoryModel>()
							 .eq("parent_id",changeKey)
							 .eq("del_flag",0));
			 if(CollectionUtils.isNotEmpty(changeChildList)){
				 TreeSet<Integer> childIntCodeSet = new TreeSet<>(Comparator.reverseOrder());
				 changeChildList.stream().forEach(factoryModel -> {
					 String code = factoryModel.getCode();
					 Integer subCode = Integer.parseInt(code.substring(code.lastIndexOf(".")+1));
					 childIntCodeSet.add(subCode);
				 });
				 Integer finalIntSubfix=childIntCodeSet.first()+1;
				 finalCode = changeCode+".0"+finalIntSubfix;
			 }
			 else {
				 finalCode = changeCode+".01";
			 }
			 dropedFactory.setParentId(changeKey).setCode(finalCode);
			 factoryModelService.updateById(dropedFactory);
			 //重新计算调整位置后各孩子的code
			 changeEveryChildCode(dropedKey,finalCode);
		 }else if("2".equals(status)){
			 String prefix = changeCode.substring(0,changeCode.lastIndexOf("."));
			 Integer changeSubfix = Integer.parseInt(changeCode.substring(changeCode.lastIndexOf(".")+1));
			 List<FactoryModel> changeChildList = factoryModelService.list(new QueryWrapper<FactoryModel>()
					 .eq("parent_id",changeParentId)
					 .eq("del_flag",0));
			 changeChildList.stream().forEach(factoryModel -> {
				 String code = factoryModel.getCode();
				 String id = factoryModel.getId();
				 Integer numSubfix = Integer.parseInt(code.substring(code.lastIndexOf(".")+1));
				 if(numSubfix>changeSubfix){
					 numSubfix = numSubfix+1;
					 String finalCode = prefix+".0"+numSubfix;
					 factoryModel.setCode(finalCode);
					 changeEveryChildCode(id,finalCode);
				 }
			 });
			 factoryModelService.saveOrUpdateBatch(changeChildList);
			 Integer numDropedSubfix = changeSubfix+1;
			 String finalDropedCode = prefix+".0"+numDropedSubfix;
			 dropedFactory.setCode(finalDropedCode).setParentId(changeParentId);
			 changeEveryChildCode(dropedKey,finalDropedCode);
			 factoryModelService.saveOrUpdate(dropedFactory);
		 }else if("5".equals(status)){
			 String prefix = changeCode.substring(0,changeCode.lastIndexOf("."));
			 Integer changeSubfix = Integer.parseInt(changeCode.substring(changeCode.lastIndexOf(".")+1));
			 List<FactoryModel> changeChildList = factoryModelService.list(new QueryWrapper<FactoryModel>()
					 .eq("parent_id",changeParentId)
					 .eq("del_flag",0));
			 changeChildList.stream().forEach(factoryModel -> {
				 String code = factoryModel.getCode();
				 String id = factoryModel.getId();
				 Integer numSubfix = Integer.parseInt(code.substring(code.lastIndexOf(".")+1));
				 if(numSubfix>=changeSubfix){
					 numSubfix = numSubfix+1;
					 String finalCode = prefix+".0"+numSubfix;
					 factoryModel.setCode(finalCode);
					 changeEveryChildCode(id,finalCode);
				 }
			 });
			 factoryModelService.saveOrUpdateBatch(changeChildList);
			 Integer numDropedSubfix = changeSubfix;
			 String finalDropedCode = prefix+".0"+numDropedSubfix;
			 dropedFactory.setCode(finalDropedCode).setParentId(changeParentId);
			 changeEveryChildCode(dropedKey,finalDropedCode);
			 factoryModelService.saveOrUpdate(dropedFactory);
		 }

		 return Result.OK("树结构调整成功");

	 }
	 /**
	 * 通过id删除
	 *
	 * @param id
	 * @return
	 */
	@AutoLog(value = "工厂建模-通过id删除")
	@ApiOperation(value="工厂建模-通过id删除", notes="工厂建模-通过id删除")
	@DeleteMapping(value = "/delete")
	public Result<String> delete(@RequestParam(name="id",required=true) String id) {
		dataVersionService.update(new UpdateWrapper<DataVersion>()
				.set("del_flag",1)
				.eq("business_id",id));
		factoryModelService.update(new UpdateWrapper<FactoryModel>().eq("id",id).set("del_flag",1));
		return Result.OK("删除成功!");
	}

	/**
	 *  批量删除
	 *
	 * @param ids
	 * @return
	 */
	@AutoLog(value = "工厂建模-批量删除")
	@ApiOperation(value="工厂建模-批量删除", notes="工厂建模-批量删除")
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_factory_model:deleteBatch")
	@DeleteMapping(value = "/deleteBatch")
	public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
		dataVersionService.update(new UpdateWrapper<DataVersion>()
				.set("del_flag",1)
				.in("business_id",Arrays.asList(ids.split(","))));
		this.factoryModelService.update(new UpdateWrapper<FactoryModel>()
				.in("id",Arrays.asList(ids.split(",")))
				.set("del_flag",1));
		return Result.OK("批量删除成功!");
	}

	/**
	 * 通过id查询
	 *
	 * @param id
	 * @return
	 */
	//@AutoLog(value = "工厂建模-通过id查询")
	@ApiOperation(value="工厂建模-通过id查询", notes="工厂建模-通过id查询")
	@GetMapping(value = "/queryById")
	public Result<FactoryModel> queryById(@RequestParam(name="id",required=true) String id) {
		FactoryModel factoryModel = factoryModelService.getById(id);
		if(factoryModel==null) {
			return Result.error("未找到对应数据");
		}
		return Result.OK(factoryModel);
	}
    /**
    * 导出excel
    *
    * @param request
    * @param factoryModel
    */
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_factory_model:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, FactoryModel factoryModel) {
		return super.exportXls(request, factoryModel, FactoryModel.class, "工厂建模");
    }

    /**
      * 通过excel导入数据
    *
    * @param request
    * @param response
    * @return
    */
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_factory_model:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
		return super.importExcel(request, response, FactoryModel.class);
    }
	 /*-----------------------------------------------以下为提供方便的api-------------------------------*/
	 /**
	  * 升版单个树节点并返回升版后新节点Id
	  * @param sourceFactoryModel
	  * @param newParentId
	  * @param newVersion
	  * @return newEnterPriseId
	  *
	  */
	 public String updataOneNode
	 (
			 FactoryModel sourceFactoryModel,
			 String newParentId,
			 Integer newVersion
	 ){
		 //1.取出旧版本信息;2.创建将新版本工厂建模及其版本号并存入数据库
		 // 1.
		 DataVersion oldDataVersion = dataVersionService
				 .getOne(new QueryWrapper<DataVersion>()
						 .eq("business_id",sourceFactoryModel.getId())
						 .eq("del_flag",0),true);
		 sourceFactoryModel.setId(null)
				 .setParentId(newParentId)
				 .setVersion(newVersion);
		 //2.
		 factoryModelService.save(sourceFactoryModel);
		 FactoryModel newFactoryModel = factoryModelService
				 .getOne(new QueryWrapper<FactoryModel>()
						 .eq("code",sourceFactoryModel.getCode())
						 .eq("version",newVersion)
						 .eq("del_flag",0),true);
		 DataVersion newDataVersion = new DataVersion();
		 newDataVersion
				 .setVersion(newVersion)
				 .setBusinessType("工厂建模")
				 .setBusinessId(newFactoryModel.getId())
				 .setIsLastUsable("0")
				 .setVersionStatus("1")
				 .setDelFlag(0)
				 .setSourceVersionId(oldDataVersion.getId());
		 dataVersionService.save(newDataVersion);
		 //将版本号存入关联的工厂建模
		 String newDataVersionId = dataVersionService
				 .getOne(new QueryWrapper<DataVersion>()
						 .eq("business_id",newDataVersion.getBusinessId())
						 .eq("del_flag",0)).getId();
		factoryModelService.update(new UpdateWrapper<FactoryModel>()
				 .set("data_version_id",newDataVersionId)
				 .eq("id",newFactoryModel.getId()));
		 return newFactoryModel.getId();
	 }
	 /**
	  * 递归升版多个节点
	  * @param parentId
	  * @param newParentId
	  * @param version
	  * @param newVersion
	  * @return
	  */
	 public void recurrenceUpdata(String parentId,String newParentId,Integer version,Integer newVersion){
		 List<FactoryModel> childList = factoryModelService
				 .list(new QueryWrapper<FactoryModel>()
				 .eq("parent_id",parentId)
				 .eq("version",version)
				 .eq("del_flag",0));
		 if(CollectionUtils.isNotEmpty(childList)){
		 	for(int i=0;i<childList.size();i++){
				String childNewId= childList.get(i).getId();
				String childNewParentId=updataOneNode(childList.get(i),newParentId,newVersion);
				recurrenceUpdata(childNewId,childNewParentId,version,newVersion);
			}
		 }

	 }
	 /**
	  *  递归判断是否存在直系亲属关系
	  * @param parentId
	  * @param id
	  * @return
	  */
	 public boolean isChildren(String parentId,String id){
		 boolean tag = false;
		 List<String> idList = factoryModelService.list(new QueryWrapper<FactoryModel>()
				 .eq("parent_id",parentId)
				 .eq("del_flag",0))
				 .stream()
				 .map(FactoryModel::getId)
				 .collect(Collectors.toList());
		 if(CollectionUtils.isNotEmpty(idList)){
			 for(String strId:idList){
				 if(strId.equals(id)){
					 return true;
				 }
				 else if(!tag){
					 tag = isChildren(strId,id);
				 }
			 }
		 }
		 return tag;
	 }
	 /**
	  *  递归调整树节点的code
	  * @param parentId
	  * @param prefix
	  * @return
	  */
	 public void changeEveryChildCode(String parentId,String prefix){
		 List<FactoryModel> children = factoryModelService.list(new QueryWrapper<FactoryModel>()
				 .eq("parent_id",parentId)
				 .eq("del_flag",0));
		 if(CollectionUtils.isNotEmpty(children)){
			 for(FactoryModel factoryModel:children){
				 String id = factoryModel.getId();
				 String oldCode = factoryModel.getCode();
				 String subfix = oldCode.substring(oldCode.lastIndexOf(".")+1);
				 String realCode = prefix+"."+subfix;
				 factoryModelService.update(new UpdateWrapper<FactoryModel>().set("code",realCode).eq("id",id));
				 changeEveryChildCode(id,realCode);
			 }
		 }
	 }
}