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.concurrent.CopyOnWriteArrayList;
|
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.jeecg.common.api.vo.Result;
|
import org.jeecg.common.system.vo.SelectTreeModel;
|
import org.jeecg.modules.base.entity.Enterprise;
|
import org.jeecg.modules.base.service.IEnterpriseService;
|
|
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.modules.system.entity.Administrator;
|
import org.jeecg.common.system.base.entity.DataVersion;
|
import org.jeecg.modules.system.service.IAdministratorService;
|
import org.jeecg.modules.system.service.IDataVersionService;
|
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-21
|
* @Version: V1.0
|
*/
|
@Api(tags="企业架构")
|
@RestController
|
@RequestMapping("/base/enterprise")
|
@Slf4j
|
public class EnterpriseController extends JeecgController<Enterprise, IEnterpriseService> {
|
@Autowired
|
private IEnterpriseService enterpriseService;
|
@Autowired
|
private IDataVersionService dataVersionService;
|
@Autowired
|
private IQuartzJobService quartzJobService;
|
@Autowired
|
private IAdministratorService administratorService;
|
/**
|
*
|
* 获取集团架构树
|
*
|
*/
|
@GetMapping("/enterpriseTree")
|
public Result<?> getEnterpriseTree(@RequestParam(value = "version", required = false) Integer version){
|
SelectTreeModel selectTreeModel = new SelectTreeModel();
|
selectTreeModel.setKey("0");
|
selectTreeModel.setTitle("集团架构");
|
List<SelectTreeModel> finallyList = new ArrayList<>();
|
selectTreeModel.setChildren(enterpriseService.getEnterpriseVersionTree("0",version));
|
finallyList.add(selectTreeModel);
|
return Result.OK(finallyList);
|
}
|
/**
|
* 分页列表查询
|
*
|
* @param map
|
* @param pageNo
|
* @param pageSize
|
* @param parentId
|
* @return
|
*/
|
//@AutoLog(value = "企业架构-分页列表查询")
|
@ApiOperation(value="企业架构-分页列表查询", notes="企业架构-分页列表查询")
|
@GetMapping(value = "/list")
|
public Result<IPage<Map<String,Object>>> queryPageList(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
|
) {
|
Page<Map<String,Object>> page = new Page(pageNo, pageSize);
|
IPage<Map<String,Object>> pageList = enterpriseService.getEnterpriseListByPid(page,version,parentId);
|
return Result.OK(pageList);
|
}
|
/**
|
*
|
* 查询当前生效版本列表
|
*
|
*/
|
@GetMapping("getUsableList")
|
public Result<?> getUsableList(){
|
return Result.OK(enterpriseService.getUsableList());
|
}
|
|
/**
|
*
|
* 查所有企业列表
|
*
|
*/
|
@GetMapping("/mapList")
|
public Result<?> getEnterpriseList(){
|
return Result.OK(enterpriseService.getEnterprise());
|
}
|
|
/**
|
* 添加需要一次性完成
|
*
|
* @param map
|
* @return
|
*/
|
@AutoLog(value = "企业架构-添加")
|
@ApiOperation(value="企业架构-添加", notes="企业架构-添加")
|
@PostMapping(value = "/add")
|
@Transactional
|
public Result<String> add(@RequestBody Map<String,Object> map) {
|
Enterprise enterprise = new Enterprise();
|
//(设置保存的工作中心数据）
|
enterprise.setCode(String.valueOf(map.get("code")))
|
.setName(String.valueOf(map.get("name")))
|
.setRemark(String.valueOf(map.get("remark")))
|
.setVersion(Integer.parseInt(String.valueOf(map.get("version"))))
|
.setStatus(String.valueOf(map.get("status")))
|
.setParentId(String.valueOf(map.get("parentId")))
|
.setDelFlag(0);
|
enterpriseService.save(enterprise);
|
QueryWrapper<Enterprise> queryWrapper = new QueryWrapper<Enterprise>()
|
.eq("code",enterprise.getCode()).eq("version",enterprise.getVersion()).eq("del_flag",0);
|
Enterprise selectEnterprise = enterpriseService.getOne(queryWrapper,true);
|
DataVersion dataVersion = new DataVersion();
|
dataVersion.setBusinessId(selectEnterprise.getId())
|
.setBusinessType("集团架构")
|
.setVersion(selectEnterprise.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",selectEnterprise.getId()).eq("del_flag",0);
|
DataVersion selectDataVersion = dataVersionService.getOne(queryWrapper1,true);
|
selectEnterprise.setDataVersionId(selectDataVersion.getId());
|
enterpriseService.saveOrUpdate(selectEnterprise);
|
return Result.OK("添加成功！");
|
}
|
/**
|
* 升版
|
* 需要一次完成
|
* @param map
|
* @param
|
* @return
|
*/
|
@PostMapping("/updateVersion")
|
@Transactional
|
public Result<?> updateVersion(@RequestBody Map<String,Object> map){
|
Integer version = Integer.parseInt((String)map.get("version"));
|
Integer newVersion = enterpriseService.getAllVersion().stream().findFirst().get()+1;
|
//该方法在api区
|
recurrenceUpdata("0","0",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.EnterpriseSetUsableJob"),true);
|
if(ObjectUtils.isNotNull(quartzJob)){
|
quartzJobService.deleteAndStopJob(quartzJob);
|
}
|
//获取版本号
|
Integer version = Integer.parseInt((String)map.get("version"));
|
//获取上次生效版本并将其是否上次生效位置置为否
|
List<Enterprise> lastUsableList = enterpriseService.getLastUsableList();
|
if(CollectionUtils.isNotEmpty(lastUsableList)){
|
List<DataVersion> lastUsableVersionList = dataVersionService.list( new QueryWrapper<DataVersion>()
|
.in("business_id",lastUsableList.stream()
|
.map(Enterprise::getId)
|
.collect(Collectors.toList())).eq("del_flag",0));
|
lastUsableVersionList.stream().forEach(dataVersion -> {
|
dataVersion.setIsLastUsable("0");
|
});
|
dataVersionService.updateBatchById(lastUsableVersionList);
|
}
|
//获取生效版本及版本信息并将其置为失效
|
List<Enterprise> usableList = enterpriseService.getUsableList();
|
if(CollectionUtils.isNotEmpty(usableList)){
|
List<DataVersion> usableDataVersionList = dataVersionService.list(new QueryWrapper<DataVersion>()
|
.in("business_id",usableList.stream()
|
.map(Enterprise::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",enterpriseService
|
.list(
|
new QueryWrapper<Enterprise>()
|
.eq("version",version)
|
.eq("del_flag",0)
|
)
|
.stream().map(Enterprise::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);
|
}
|
}
|
/**
|
* 编辑
|
*
|
* @param enterprise
|
* @return
|
*/
|
@AutoLog(value = "企业架构-编辑")
|
@ApiOperation(value="企业架构-编辑", notes="企业架构-编辑")
|
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> edit(@RequestBody Enterprise enterprise) {
|
enterpriseService.updateById(enterprise);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
*
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "企业架构-通过id删除")
|
@ApiOperation(value="企业架构-通过id删除", notes="企业架构-通过id删除")
|
@DeleteMapping(value = "/delete")
|
@Transactional
|
public Result<String> delete(@RequestParam(name="id",required=true) String id) {
|
dataVersionService.update(new UpdateWrapper<DataVersion>()
|
.set("del_flag",1)
|
.eq("business_id",id));
|
enterpriseService.update(new UpdateWrapper<Enterprise>().
|
set("del_flag",1)
|
.eq("id",id));
|
return Result.OK("删除成功!");
|
}
|
|
|
/**
|
* 批量删除
|
*
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "企业架构-批量删除")
|
@ApiOperation(value="企业架构-批量删除", notes="企业架构-批量删除")
|
@DeleteMapping(value = "/deleteBatch")
|
@Transactional
|
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(","))));
|
enterpriseService.
|
update(new UpdateWrapper<Enterprise>()
|
.set("del_flag",1)
|
.in("id",Arrays.asList(ids.split(","))));
|
return Result.OK("删除成功");
|
}
|
|
/**
|
* 通过id查询
|
*
|
* @param id
|
* @return
|
*/
|
@ApiOperation(value="企业架构-通过id查询", notes="企业架构-通过id查询")
|
@GetMapping(value = "/queryById")
|
public Result<Enterprise> queryById(@RequestParam(name="id",required=true) String id) {
|
Enterprise enterprise = enterpriseService.getById(id);
|
if(enterprise==null) {
|
return Result.error("未找到对应数据");
|
}
|
return Result.OK(enterprise);
|
}
|
|
/**
|
* 导出excel
|
*
|
* @param request
|
* @param enterprise
|
*/
|
@RequestMapping(value = "/exportXls")
|
public ModelAndView exportXls(HttpServletRequest request, Enterprise enterprise) {
|
return super.exportXls(request, enterprise, Enterprise.class, "企业架构");
|
}
|
|
/**
|
* 通过excel导入数据
|
*
|
* @param request
|
* @param response
|
* @return
|
*/
|
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
|
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
|
return super.importExcel(request, response, Enterprise.class);
|
}
|
/**
|
* 表单验证
|
*
|
*
|
*/
|
@GetMapping("/check")
|
public Result<?> check(@RequestParam(name="name",required = false) String name,
|
@RequestParam(name="version",required = false) Integer version,
|
@RequestParam(name="parentId",required = true) String parentId
|
){
|
QueryWrapper<Enterprise> 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(enterpriseService.list(queryWrapper));
|
}
|
/**
|
* 获取初始版本号
|
*
|
*
|
*/
|
@GetMapping("/getInitVersion")
|
public Result<?> getUsableVersion(){
|
return Result.OK(enterpriseService.getInitVersion());
|
}
|
/**
|
* 获取所有版本号
|
*
|
*
|
*/
|
@GetMapping("/getVersionList")
|
public Result<?> getAllVersion(){
|
return Result.OK(enterpriseService.getAllVersion());
|
}
|
/**
|
* 获取当前生效版本和上一次生效版本的版本号
|
*
|
* @return
|
*/
|
@GetMapping("/getNowAndLastUsableVersion")
|
public Result<?> getNowAndLastUsableVersion(){
|
return Result.OK(enterpriseService.getNowAndLastUsableVersion());
|
}
|
/**
|
* 删除消息提醒
|
*
|
* @param delIndexList
|
* @return
|
*/
|
@PostMapping("/checkDel")
|
@Transactional
|
public Result<?> checkDel(@RequestBody List<String> delIndexList){
|
List<Administrator> administrators = administratorService
|
.list(new QueryWrapper<Administrator>()
|
.in("enterprise_id",delIndexList)
|
.eq("del_flag",0)
|
);
|
List<String> list1 = administrators.stream().map(Administrator::getEnterpriseId).collect(Collectors.toList());
|
Set<String> set = new TreeSet<>();
|
set.addAll(list1);
|
if(CollectionUtils.isNotEmpty(set)){
|
List<Enterprise> enterpriseList = enterpriseService.listByIds(set);
|
final String[] listMessage = {""};
|
if(CollectionUtils.isNotEmpty(enterpriseList)){
|
enterpriseList.stream().forEach(enterprise -> {
|
listMessage[0] = listMessage[0] +enterprise.getCode()+",";
|
});
|
String trueMessage = "编号为"+listMessage[0]
|
.substring(0, listMessage[0].length()-1)+"的数据被引用，确认删除吗？";
|
return Result.OK(trueMessage);
|
}
|
}
|
return Result.OK("选中数据没有被引用，可以安全删除，确认删除吗？");
|
}
|
/**
|
* 拖拽节点
|
*
|
* @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");
|
Enterprise dropedEnterprise = enterpriseService.getById(dropedKey);
|
Enterprise changeEnterprise = enterpriseService.getById(changeKey);
|
String dropedCode = dropedEnterprise.getCode();
|
String changeCode = changeEnterprise.getCode();
|
String status = map.get("status");
|
if("1".equals(status)||"3".equals(status)){
|
dropedEnterprise.setId(changeKey).setParentId(changeParentId).setCode(changeCode);
|
changeEnterprise.setId(dropedKey).setParentId(dropedParentId).setCode(dropedCode);
|
List<Enterprise> list = new ArrayList<>();
|
list.add(dropedEnterprise);
|
list.add(changeEnterprise);
|
enterpriseService.updateBatchById(list);
|
}else if("4".equals(status)){
|
//互换位置
|
String finalCode="";
|
List<Enterprise> changeChildList = enterpriseService
|
.list(new QueryWrapper<Enterprise>()
|
.eq("parent_id",changeKey)
|
.eq("del_flag",0));
|
if(CollectionUtils.isNotEmpty(changeChildList)){
|
TreeSet<Integer> childIntCodeSet = new TreeSet<>(Comparator.reverseOrder());
|
changeChildList.stream().forEach(sysDepart -> {
|
String orgCode = sysDepart.getCode();
|
Integer subCode = Integer.parseInt(orgCode.substring(orgCode.lastIndexOf(".")+1));
|
childIntCodeSet.add(subCode);
|
});
|
Integer finalIntSubfix=childIntCodeSet.first()+1;
|
finalCode = changeCode+".0"+finalIntSubfix;
|
}
|
else {
|
finalCode = changeCode+".01";
|
}
|
dropedEnterprise.setParentId(changeKey).setCode(finalCode);
|
enterpriseService.updateById(dropedEnterprise);
|
//重新计算调整位置后各孩子的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<Enterprise> changeChildList = enterpriseService.list(new QueryWrapper<Enterprise>()
|
.eq("parent_id",changeParentId)
|
.eq("del_flag",0));
|
changeChildList.stream().forEach(enterprise -> {
|
String code = enterprise.getCode();
|
String id = enterprise.getId();
|
Integer numSubfix = Integer.parseInt(code.substring(code.lastIndexOf(".")+1));
|
if(numSubfix>changeSubfix){
|
numSubfix = numSubfix+1;
|
String finalCode = prefix+".0"+numSubfix;
|
enterprise.setCode(finalCode);
|
changeEveryChildCode(id,finalCode);
|
}
|
});
|
enterpriseService.saveOrUpdateBatch(changeChildList);
|
Integer numDropedSubfix = changeSubfix+1;
|
String finalDropedCode = prefix+".0"+numDropedSubfix;
|
dropedEnterprise.setCode(finalDropedCode).setParentId(changeParentId);
|
changeEveryChildCode(dropedKey,finalDropedCode);
|
enterpriseService.saveOrUpdate(dropedEnterprise);
|
}else if("5".equals(status)){
|
String prefix = changeCode.substring(0,changeCode.lastIndexOf("."));
|
Integer changeSubfix = Integer.parseInt(changeCode.substring(changeCode.lastIndexOf(".")+1));
|
List<Enterprise> changeChildList = enterpriseService.list(new QueryWrapper<Enterprise>()
|
.eq("parent_id",changeParentId)
|
.eq("del_flag",0));
|
changeChildList.stream().forEach(enterprise -> {
|
String code = enterprise.getCode();
|
String id = enterprise.getId();
|
Integer numSubfix = Integer.parseInt(code.substring(code.lastIndexOf(".")+1));
|
if(numSubfix>=changeSubfix){
|
numSubfix = numSubfix+1;
|
String finalCode = prefix+".0"+numSubfix;
|
enterprise.setCode(finalCode);
|
changeEveryChildCode(id,finalCode);
|
}
|
});
|
enterpriseService.saveOrUpdateBatch(changeChildList);
|
Integer numDropedSubfix = changeSubfix;
|
String finalDropedCode = prefix+".0"+numDropedSubfix;
|
dropedEnterprise.setCode(finalDropedCode).setParentId(changeParentId);
|
changeEveryChildCode(dropedKey,finalDropedCode);
|
enterpriseService.saveOrUpdate(dropedEnterprise);
|
}
|
|
return Result.OK("树结构调整成功");
|
|
}
|
/**
|
* 判断是否有亲子关系
|
*
|
* @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));
|
}
|
|
/*-----------------------------------------------以下为提供方便的api-------------------------------*/
|
/**
|
* 升版单个树节点并返回升版后新节点Id
|
* @param sourceEnterprise
|
* @param newParentId
|
* @param newVersion
|
* @return newEnterPriseId
|
*
|
*/
|
public String updataOneNode
|
(
|
Enterprise sourceEnterprise,
|
String newParentId,
|
Integer newVersion
|
){
|
//1.取出旧版本信息;2.创建将新版本集团架构及其版本号并存入数据库
|
// 1.
|
DataVersion oldDataVersion = dataVersionService
|
.getOne(new QueryWrapper<DataVersion>()
|
.eq("business_id",sourceEnterprise.getId())
|
.eq("del_flag",0),true);
|
sourceEnterprise.setId(null)
|
.setParentId(newParentId)
|
.setVersion(newVersion);
|
//2.
|
enterpriseService.save(sourceEnterprise);
|
Enterprise newEnterprise = enterpriseService
|
.getOne(new QueryWrapper<Enterprise>()
|
.eq("code",sourceEnterprise.getCode())
|
.eq("version",newVersion)
|
.eq("del_flag",0),true);
|
DataVersion newDataVersion = new DataVersion();
|
newDataVersion
|
.setVersion(newVersion)
|
.setBusinessType("集团架构")
|
.setBusinessId(newEnterprise.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();
|
enterpriseService.update(new UpdateWrapper<Enterprise>()
|
.set("data_version_id",newDataVersionId)
|
.eq("id",newEnterprise.getId()));
|
return newEnterprise.getId();
|
}
|
/**
|
* 递归升版多个节点
|
* @param parentId
|
* @param newParentId
|
* @param version
|
* @param newVersion
|
* @return
|
*/
|
public void recurrenceUpdata(String parentId,String newParentId,Integer version,Integer newVersion){
|
CopyOnWriteArrayList<Enterprise> childList = new CopyOnWriteArrayList<>();
|
childList.addAll(enterpriseService.list(new QueryWrapper<Enterprise>()
|
.eq("parent_id",parentId)
|
.eq("version",version)
|
.eq("del_flag",0)));
|
if(CollectionUtils.isNotEmpty(childList)){
|
childList.stream().forEach(childEnterprise ->{
|
//把child的Id存下来,因为在流里边操作对象容易扯着蛋
|
String childNewId= childEnterprise.getId();
|
//将数据存入数据库
|
String childNewParentId=updataOneNode(childEnterprise,newParentId,newVersion);
|
//递归
|
recurrenceUpdata(childNewId,childNewParentId,version,newVersion);
|
} );
|
}
|
|
}
|
/**
|
* 拖拽交换两个树的位置
|
* @param dropedEnterprise
|
* @param changeEnterprise
|
* @return
|
*/
|
public void changePosition(Enterprise dropedEnterprise,Enterprise changeEnterprise){
|
String dropedId = dropedEnterprise.getId();
|
String changeId = changeEnterprise.getId();
|
String dropedParentId = dropedEnterprise.getParentId();
|
String changeParentId = changeEnterprise.getParentId();
|
String dropedCode = dropedEnterprise.getCode();
|
String changeCode = changeEnterprise.getCode();
|
//存在父换子
|
if(dropedId.equals(changeParentId)){
|
dropedEnterprise.setParentId(changeId);
|
changeEnterprise.setParentId(dropedParentId).setCode(dropedCode);
|
enterpriseService.saveOrUpdate(changeEnterprise);
|
enterpriseService.saveOrUpdate(dropedEnterprise);
|
changeEveryChildCode(changeId,dropedCode);
|
}
|
//存在子换父
|
else if(changeId.equals(dropedParentId)){
|
dropedEnterprise.setParentId(changeParentId).setCode(changeCode);
|
changeEnterprise.setParentId(dropedId);
|
enterpriseService.saveOrUpdate(dropedEnterprise);
|
enterpriseService.saveOrUpdate(changeEnterprise);
|
changeEveryChildCode(dropedId,changeCode);
|
}
|
else {
|
dropedEnterprise.setParentId(changeParentId).setCode(changeCode);
|
changeEnterprise.setParentId(dropedParentId).setCode(dropedCode);
|
enterpriseService.saveOrUpdate(dropedEnterprise);
|
enterpriseService.saveOrUpdate(changeEnterprise);
|
changeEveryChildCode(changeId,dropedCode);
|
changeEveryChildCode(dropedId,changeCode);
|
}
|
}
|
/**
|
* 递归调整树节点的code
|
* @param parentId
|
* @param prefix
|
* @return
|
*/
|
public void changeEveryChildCode(String parentId,String prefix){
|
List<Enterprise> children = enterpriseService.list(new QueryWrapper<Enterprise>()
|
.eq("parent_id",parentId)
|
.eq("del_flag",0));
|
if(CollectionUtils.isNotEmpty(children)){
|
for(Enterprise enterprise:children){
|
String id = enterprise.getId();
|
String oldCode = enterprise.getCode();
|
String subfix = oldCode.substring(oldCode.lastIndexOf(".")+1);
|
String realCode = prefix+"."+subfix;
|
enterpriseService.update(new UpdateWrapper<Enterprise>().set("code",realCode).eq("id",id));
|
changeEveryChildCode(id,realCode);
|
}
|
}
|
}
|
/**
|
* 递归判断是否为后辈公司
|
* @param parentId
|
* @param id
|
* @return
|
*/
|
public boolean isChildren(String parentId,String id){
|
boolean tag = false;
|
List<String> idList = enterpriseService.list(new QueryWrapper<Enterprise>()
|
.eq("parent_id",parentId)
|
.eq("del_flag",0))
|
.stream()
|
.map(Enterprise::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;
|
}
|
|
}
|
