package org.jeecg.modules.activiti.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.google.common.collect.Lists;
|
import org.activiti.bpmn.model.*;
|
import org.activiti.engine.RepositoryService;
|
import org.activiti.engine.RuntimeService;
|
import org.activiti.engine.TaskService;
|
import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
|
|
import org.jeecg.common.base.entity.ActNode;
|
import org.jeecg.common.base.entity.Department;
|
import org.jeecg.common.base.entity.Role;
|
import org.jeecg.common.system.vo.LoginUser;
|
|
import org.jeecg.modules.activiti.mapper.ActNodeMapper;
|
import org.jeecg.modules.activiti.service.IActNodeService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.script.ScriptEngine;
|
import javax.script.ScriptEngineManager;
|
import javax.script.ScriptException;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Description: 流程节点扩展表
|
* @Author: pmc
|
* @Date: 2020-03-30
|
* @Version: V1.0
|
*/
|
@Service
|
public class ActNodeServiceImpl extends ServiceImpl<ActNodeMapper, ActNode> implements IActNodeService {
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private RuntimeService runtimeService;
|
@Autowired
|
private RepositoryService repositoryService;
|
|
public List<String> getRoleByUserName(String username) {
|
return this.baseMapper.getRoleByUserName(username);
|
}
|
public void deleteByNodeId(String id,String procDefId) {
|
this.remove(new LambdaQueryWrapper<ActNode>().eq(ActNode::getNodeId,id).eq(ActNode::getProcDefId,procDefId));
|
}
|
|
public List<LoginUser> findUserByNodeId(String nodeId,String procDefId) {
|
List<LoginUser> users = this.baseMapper.findUserByNodeId(nodeId,procDefId);
|
if (users.size()==0) users = Lists.newArrayList();
|
return users;
|
}
|
|
public List<Role> findRoleByNodeId(String nodeId, String procDefId) {
|
return this.baseMapper.findRoleByNodeId(nodeId,procDefId);
|
}
|
|
public List<Department> findDepartmentByNodeId(String nodeId, String procDefId) {
|
return this.baseMapper.findDepartmentByNodeId(nodeId,procDefId);
|
}
|
public List<Department> findDepartmentManageByNodeId(String nodeId,String procDefId) {
|
return this.baseMapper.findDepartmentManageByNodeId(nodeId,procDefId);
|
}
|
public List<String> findFormVariableByNodeId(String nodeId,String procDefId) {
|
return this.baseMapper.findFormVariableByNodeId(nodeId,procDefId);
|
}
|
|
public Boolean hasChooseDepHeader(String nodeId,String procDefId) {
|
List<ActNode> listNode = findByNodeIdAndType(nodeId, procDefId,4);
|
if(listNode!=null&&listNode.size()>0){
|
return true;
|
}
|
return false;
|
}
|
public Boolean hasChooseSponsor(String nodeId,String procDefId) {
|
List<ActNode> listNode = findByNodeIdAndType(nodeId, procDefId,3);
|
if(listNode!=null&&listNode.size()>0){
|
return true;
|
}
|
return false;
|
}
|
public Boolean hasFormVariable(String nodeId,String procDefId) {
|
List<ActNode> listNode = findByNodeIdAndType(nodeId,procDefId, 6);
|
if(listNode!=null&&listNode.size()>0){
|
return true;
|
}
|
return false;
|
}
|
|
public List<ActNode> findByNodeIdAndType(String nodeId, int type) {
|
return list(new LambdaQueryWrapper<ActNode>().eq(ActNode::getNodeId,nodeId).eq(ActNode::getType,type));
|
}
|
|
public List<ActNode> findByNodeIdAndType(String nodeId,String procDefId, int type) {
|
return list(new LambdaQueryWrapper<ActNode>().eq(ActNode::getNodeId,nodeId).eq(ActNode::getProcDefId,procDefId).eq(ActNode::getType,type));
|
}
|
|
public List<String> findDepartmentIdsByNodeId(String nodeId,String procDefId) {
|
List<Department> departmentByNodeId = this.findDepartmentByNodeId(nodeId,procDefId);
|
return departmentByNodeId.stream().map(Department::getId).distinct().collect(Collectors.toList());
|
}
|
|
public List<LoginUser> queryAllUser() {
|
return this.baseMapper.queryAllUser();
|
}
|
|
public List<LoginUser> findUserByRoleId(String id) {
|
return this.baseMapper.findUserByRoleId(id);
|
}
|
|
public List<LoginUser> findUserDepartmentId(String id) {
|
return this.baseMapper.findUserDepartmentId(id);
|
}
|
public List<LoginUser> findUserDepartmentManageId(String id) {
|
return this.baseMapper.findUserDepartmentManageId(id);
|
}
|
/**
|
*
|
* (下一个任务节点信息)
|
* <br/> https://www.cnblogs.com/feiZhou/p/9344027.html
|
* @param activityImpl
|
* 流程节点信息
|
* @param activityId
|
* 当前流程节点Id信息
|
* @param variables
|
* 流程变量
|
* @param processInstanceId
|
* 流程实例ID
|
* @return
|
*/
|
public FlowElement nextTaskDefinition(FlowElement activityImpl, String activityId,
|
Map<String, Object> variables, String processInstanceId) {
|
|
FlowElement ac = null;
|
|
// 如果遍历节点为用户任务并且节点不是当前节点信息
|
if (UserTask.class.isInstance(activityImpl) && !activityId.equals(activityImpl.getId())) {
|
// 获取该节点下一个节点信息
|
return activityImpl;
|
|
} else if (!EndEvent.class.isInstance(activityImpl)) {
|
// 当前节点是不结束节点的情况
|
|
ExclusiveGateway gateway = (ExclusiveGateway) activityImpl;
|
// 获取节点所有流向线路信息
|
List<SequenceFlow> outTransitions = gateway.getOutgoingFlows();
|
List<SequenceFlow> outTransitionsTemp = null;
|
for (SequenceFlow tr : outTransitions) {
|
// 这里遍历的当然节点所有流程线的的终点节点
|
ac = tr.getTargetFlowElement(); // 获取线路的终点节点
|
// 如果流向线路为排他网关
|
if (ExclusiveGateway.class.isInstance(ac)) {
|
outTransitionsTemp = ((ExclusiveGateway) ac).getOutgoingFlows();
|
|
// 如果排他网关只有一条线路信息
|
if (outTransitionsTemp.size() == 1) {
|
return nextTaskDefinition( outTransitionsTemp.get(0).getTargetFlowElement(), activityId,
|
variables, processInstanceId);
|
} else if (outTransitionsTemp.size() > 1) { // 如果排他网关有多条线路信息
|
|
FlowElement nextActivityImpl = getNextActivityImplByLineCondition(outTransitionsTemp,
|
variables);
|
return nextTaskDefinition(nextActivityImpl, activityId, variables, processInstanceId);
|
|
}
|
} else if (UserTask.class.isInstance(ac)) {// 下一个节点是用户任务
|
Boolean currenLineConditionResule = getCurrenLineConditionResule(tr, variables);
|
if (currenLineConditionResule) {
|
return ac;
|
}
|
} else if (EndEvent.class.isInstance(ac)) {
|
if (getCurrenLineConditionResule(tr, variables)) {
|
return ac;
|
}
|
|
}
|
|
}
|
}
|
return null;
|
}
|
/**
|
* (判断当前流程线是否满足流程参数条件)
|
* @param outTransition
|
* @param variables
|
* @return
|
*/
|
public Boolean getCurrenLineConditionResule(SequenceFlow outTransition, Map<String, Object> variables) {
|
|
boolean stringtoBoolean = true;
|
String conStr = outTransition.getConditionExpression(); //.getProperty("conditionText"); // 获取线路判断条件信息
|
// s: ${money>1000 or price >12}
|
// variables (money=1100)
|
// variables (price=100)
|
// 去掉${和}
|
String ElStr = "";
|
if (conStr != null) {// 有条件
|
ElStr = String.valueOf(conStr);
|
ElStr = ElStr.substring(2, ElStr.length() - 1);
|
try {
|
stringtoBoolean = StringtoBoolean(ElStr, variables);
|
} catch (ScriptException e) {
|
e.printStackTrace();
|
}
|
return stringtoBoolean;
|
} else {// 没有条件
|
return stringtoBoolean;
|
}
|
}
|
/**
|
* (如果是排他网关判断,获取排他网关对应的用户任务节点)
|
* @param outTransitionsTemp
|
* @param variables
|
* @return
|
*/
|
public FlowElement getNextActivityImplByLineCondition(List<SequenceFlow> outTransitionsTemp,
|
Map<String, Object> variables) {
|
|
for (SequenceFlow tr1 : outTransitionsTemp) {
|
String conStr = tr1.getConditionExpression(); // 获取线路判断条件信息
|
// s: ${money>1000 or price >12}
|
// variables (money=1100)
|
// variables (price=100)
|
// 去掉${和}
|
String ElStr = "";
|
if (conStr != null) {// 有条件
|
ElStr = String.valueOf(conStr);
|
ElStr = ElStr.substring(2, ElStr.length() - 1);
|
try {
|
boolean stringtoBoolean = StringtoBoolean(ElStr, variables);
|
if (stringtoBoolean) {
|
return tr1.getTargetFlowElement();
|
}
|
} catch (ScriptException e) {
|
continue;
|
}
|
} else {// 没有条件
|
return tr1.getTargetFlowElement();
|
}
|
}
|
return null;
|
}
|
/**
|
* (字符串表达式计算逻辑值)
|
* @param str
|
* @param var
|
* @return
|
* @throws ScriptException
|
*/
|
public static boolean StringtoBoolean(String str, Map<String,Object> var) throws ScriptException {
|
ScriptEngineManager manager = new ScriptEngineManager();
|
ScriptEngine engine = manager.getEngineByName("js");
|
Set<String> keys = var.keySet();
|
for (String key : keys) {
|
engine.put(key,var.get(key));
|
}
|
str= str.replaceAll(" or ", " || ").replaceAll(" and ", " && ");
|
Object result = engine.eval(str);
|
return Boolean.parseBoolean(String.valueOf(result));
|
|
}
|
|
public List<ActNode> findByNodeId(String nodeId) {
|
return this.baseMapper.findByNodeId(nodeId);
|
}
|
}
|
