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);
|
}
|
}
|
}
|
}
|
