package com.ruoyi.approve.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.approve.mapper.ApproveFlowDefinitionMapper;
|
import com.ruoyi.approve.mapper.ApproveFlowNodeDefinitionMapper;
|
import com.ruoyi.approve.mapper.ApproveProcessMapper;
|
import com.ruoyi.approve.pojo.ApproveFlowDefinition;
|
import com.ruoyi.approve.pojo.ApproveFlowNodeDefinition;
|
import com.ruoyi.approve.pojo.ApproveProcess;
|
import com.ruoyi.approve.vo.ApproveFlowDefinitionVO;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.framework.web.domain.AjaxResult;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.bind.annotation.*;
|
|
import java.time.LocalDateTime;
|
import java.util.Collections;
|
import java.util.List;
|
|
@RestController
|
@RequestMapping("/approveFlowDefinition")
|
public class ApproveFlowDefinitionController {
|
private final ApproveFlowDefinitionMapper definitionMapper;
|
private final ApproveFlowNodeDefinitionMapper nodeMapper;
|
private final ApproveProcessMapper processMapper;
|
|
public ApproveFlowDefinitionController(ApproveFlowDefinitionMapper definitionMapper,
|
ApproveFlowNodeDefinitionMapper nodeMapper,
|
ApproveProcessMapper processMapper) {
|
this.definitionMapper = definitionMapper;
|
this.nodeMapper = nodeMapper;
|
this.processMapper = processMapper;
|
}
|
|
@GetMapping("/list")
|
public AjaxResult list(Integer approveType) {
|
LambdaQueryWrapper<ApproveFlowDefinition> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(ApproveFlowDefinition::getTenantId, SecurityUtils.getLoginUser().getTenantId())
|
.eq(ApproveFlowDefinition::getDeleteFlag, 0)
|
.eq(approveType != null, ApproveFlowDefinition::getApproveType, approveType)
|
.orderByDesc(ApproveFlowDefinition::getIsDefault)
|
.orderByDesc(ApproveFlowDefinition::getUpdateTime);
|
return AjaxResult.success(definitionMapper.selectList(wrapper));
|
}
|
|
@GetMapping("/{id}")
|
public AjaxResult get(@PathVariable Long id) {
|
ApproveFlowDefinition definition = getOwned(id);
|
ApproveFlowDefinitionVO result = new ApproveFlowDefinitionVO();
|
result.setDefinition(definition);
|
result.setNodes(nodeMapper.selectList(new LambdaQueryWrapper<ApproveFlowNodeDefinition>()
|
.eq(ApproveFlowNodeDefinition::getFlowDefinitionId, id)
|
.eq(ApproveFlowNodeDefinition::getTenantId, definition.getTenantId())
|
.eq(ApproveFlowNodeDefinition::getDeleteFlag, 0)
|
.orderByAsc(ApproveFlowNodeDefinition::getNodeOrder)));
|
return AjaxResult.success(result);
|
}
|
|
@PostMapping
|
@Transactional(rollbackFor = Exception.class)
|
public AjaxResult add(@RequestBody ApproveFlowDefinitionVO request) {
|
saveDefinition(request, false);
|
return AjaxResult.success();
|
}
|
|
@PutMapping("/{id}")
|
@Transactional(rollbackFor = Exception.class)
|
public AjaxResult update(@PathVariable Long id, @RequestBody ApproveFlowDefinitionVO request) {
|
getOwned(id);
|
request.getDefinition().setId(id);
|
saveDefinition(request, true);
|
return AjaxResult.success();
|
}
|
|
@PutMapping("/{id}/enabled")
|
public AjaxResult enabled(@PathVariable Long id, @RequestParam Integer enabled) {
|
ApproveFlowDefinition definition = getOwned(id);
|
definition.setEnabled(enabled == null || enabled == 0 ? 0 : 1);
|
definition.setUpdateUser(SecurityUtils.getUserId());
|
definition.setUpdateTime(LocalDateTime.now());
|
definitionMapper.updateById(definition);
|
return AjaxResult.success();
|
}
|
|
@DeleteMapping("/{id}")
|
public AjaxResult delete(@PathVariable Long id) {
|
ApproveFlowDefinition definition = getOwned(id);
|
Long activeCount = processMapper.selectCount(new LambdaQueryWrapper<ApproveProcess>()
|
.eq(ApproveProcess::getTenantId, definition.getTenantId())
|
.eq(ApproveProcess::getFlowDefinitionId, id)
|
.eq(ApproveProcess::getApproveDelete, 0)
|
.in(ApproveProcess::getApproveStatus, 0, 1));
|
if (activeCount != null && activeCount > 0) throw new RuntimeException("该流程仍有进行中的审批，不能删除");
|
definition.setDeleteFlag(1);
|
definition.setUpdateUser(SecurityUtils.getUserId());
|
definition.setUpdateTime(LocalDateTime.now());
|
definitionMapper.updateById(definition);
|
return AjaxResult.success();
|
}
|
|
private void saveDefinition(ApproveFlowDefinitionVO request, boolean update) {
|
if (request == null || request.getDefinition() == null) throw new RuntimeException("流程定义不能为空");
|
List<ApproveFlowNodeDefinition> nodes = request.getNodes() == null ? Collections.emptyList() : request.getNodes();
|
if (nodes.isEmpty()) throw new RuntimeException("审批流程至少包含一个节点");
|
Long tenantId = SecurityUtils.getLoginUser().getTenantId();
|
Long userId = SecurityUtils.getUserId();
|
ApproveFlowDefinition definition = request.getDefinition();
|
definition.setTenantId(tenantId);
|
definition.setUpdateUser(userId);
|
definition.setUpdateTime(LocalDateTime.now());
|
definition.setDeleteFlag(0);
|
if (definition.getEnabled() == null) definition.setEnabled(1);
|
if (definition.getIsDefault() == null) definition.setIsDefault(0);
|
if (definition.getIsDefault() == 1) {
|
List<ApproveFlowDefinition> oldDefaults = definitionMapper.selectList(new LambdaQueryWrapper<ApproveFlowDefinition>()
|
.eq(ApproveFlowDefinition::getTenantId, tenantId)
|
.eq(ApproveFlowDefinition::getApproveType, definition.getApproveType())
|
.eq(ApproveFlowDefinition::getIsDefault, 1)
|
.eq(ApproveFlowDefinition::getDeleteFlag, 0));
|
oldDefaults.stream().filter(item -> !item.getId().equals(definition.getId())).forEach(item -> {
|
item.setIsDefault(0);
|
definitionMapper.updateById(item);
|
});
|
}
|
if (update) {
|
definitionMapper.updateById(definition);
|
nodeMapper.delete(new LambdaQueryWrapper<ApproveFlowNodeDefinition>()
|
.eq(ApproveFlowNodeDefinition::getFlowDefinitionId, definition.getId())
|
.eq(ApproveFlowNodeDefinition::getTenantId, tenantId));
|
} else {
|
definition.setCreateUser(userId);
|
definition.setCreateTime(LocalDateTime.now());
|
definitionMapper.insert(definition);
|
}
|
int order = 1;
|
for (ApproveFlowNodeDefinition node : nodes) {
|
node.setId(null);
|
node.setFlowDefinitionId(definition.getId());
|
node.setNodeOrder(order++);
|
node.setTenantId(tenantId);
|
node.setCreateUser(userId);
|
node.setUpdateUser(userId);
|
node.setCreateTime(LocalDateTime.now());
|
node.setUpdateTime(LocalDateTime.now());
|
node.setDeleteFlag(0);
|
if (node.getConditionOperator() == null) node.setConditionOperator("ALWAYS");
|
nodeMapper.insert(node);
|
}
|
}
|
|
private ApproveFlowDefinition getOwned(Long id) {
|
ApproveFlowDefinition definition = definitionMapper.selectOne(new LambdaQueryWrapper<ApproveFlowDefinition>()
|
.eq(ApproveFlowDefinition::getId, id)
|
.eq(ApproveFlowDefinition::getTenantId, SecurityUtils.getLoginUser().getTenantId())
|
.eq(ApproveFlowDefinition::getDeleteFlag, 0));
|
if (definition == null) throw new RuntimeException("流程定义不存在");
|
return definition;
|
}
|
}
|
