在activiti.xml配置文件中增加以下配置
<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration"> <property name="eventListeners"> <list> <bean class="com.centusoft.framework.workflow.listener.user.ProcessEventListener"></bean> </list> </property> </bean>
创建监听类
ProcessEventListener.java
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.activiti.engine.HistoryService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.TaskService;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.event.ActivitiEvent;
import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEntityEventImpl;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.task.TaskDefinition;
import org.apache.commons.lang3.text.StrSubstitutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.sf.json.JSONObject;
public class ProcessEventListener implements ActivitiEventListener {
private static final Logger logger = LoggerFactory.getLogger(ProcessEventListener.class);
public void onEvent(ActivitiEvent event) {
ActivitiEventType eventType = event.getType();
if(event instanceof ActivitiEntityEventImpl) {
ActivitiEntityEventImpl aei = (ActivitiEntityEventImpl) event;
if(aei.getEntity() instanceof TaskEntity) {
if (eventType == ActivitiEventType.TASK_ASSIGNED && aei.getEntity() instanceof TaskEntity) {
TaskEntity task = (TaskEntity) aei.getEntity();
logger.info("监听任务创建:"+task.getAssignee()+"|"+task.getName()+"|"+task.getId()+"|"+task.getTaskDefinitionKey());
toAutoAudit(task);
}
}
if (ActivitiEventType.ACTIVITY_STARTED.equals(eventType)) {
logger.info("流程启动");
} else if (eventType == ActivitiEventType.ENTITY_CREATED ) {
logger.info("任务创建");
} else if (eventType == ActivitiEventType.ENTITY_INITIALIZED) {
} else if (event.getType() == ActivitiEventType.ENTITY_DELETED) {
} else if (event.getType() == ActivitiEventType.ENTITY_UPDATED) {
} else {
}
}
}
public boolean isFailOnException() {
return false;
}
/**
* 执行自动处理方法
* @Description TODO
* @param delegateTask 任务对象
* @return void
* @Author 何湘简
* @Date 2021年7月8日 下午9:52:40
*/
public void toAutoAudit(TaskEntity delegateTask) {
Map<String, Map<String, String>> allNodeMap= FlowNodeRelation.getActivitiyAllNode(delegateTask.getProcessDefinitionId());
SystemService systemService = ApplicationContextUtil.getContext().getBean(
SystemService.class);
ProcessEngine processEngine = ApplicationContextUtil.getContext().getBean(
ProcessEngine.class);
CeX2ProcessRestServiceI ceX2ProcessRestService = ApplicationContextUtil.getContext().getBean(
CeX2ProcessRestServiceI.class);
HistoryService historyService = ApplicationContextUtil.getContext().getBean(
HistoryService.class);
String reg = "\\$\\{(.*?)\\}";
Pattern pattern = Pattern.compile(reg);
String assignee=delegateTask.getAssignee();
TaskEntity taskEntity=(TaskEntity)delegateTask;
TaskDefinition taskDefinition=taskEntity.getTaskDefinition();
TaskService taskService = processEngine.getTaskService();
Map<String, Object> variableAll = taskService.getVariables(delegateTask.getId());
StrSubstitutor sub = new StrSubstitutor(variableAll);
Map<String, Object> par = new HashMap<String, Object>();
par.put("taskId", delegateTask.getId());
par.put("processInstanceId", delegateTask.getProcessInstanceId());
par.put("executionId", delegateTask.getExecutionId());
par.put("processDefinitionId", delegateTask.getProcessDefinitionId());
par.putAll(variableAll);
//查询当前节点的自动审核配置
String sql=" select n.EXCEPTION_TYPE,"
+ " n.EXCEPTION_USER,"
+ " n.EXCEPTION_NODE,"
+ " n.EXCEPTION_NODE_VARIABLE,"
+ " n.AUTO_AUDIT,"
+ " n.AUTO_NODE,"
+ " n.AUTO_VARIABLE from t_p_processnode n "
+ " where n.versions=? and n.PROCESSNODECODE=? ";
List<Map<String, Object>> nodeTreeList = systemService.findForJdbc(sql, Integer.valueOf(delegateTask.getProcessDefinitionId().split(":")[1]),delegateTask.getTaskDefinitionKey());
Map<String, Object> nowOutNode = new HashMap<String, Object>();
if(allNodeMap.containsKey(delegateTask.getTaskDefinitionKey()) && nodeTreeList!=null && nodeTreeList.size()>0) {
nowOutNode=nodeTreeList.get(0);
if(!StringUtil.isNotEmpty(assignee) && taskDefinition.getCandidateGroupIdExpressions().size()==0) {
//转交给指定人员处理，默认system
if("0".equals(nowOutNode.get("EXCEPTION_TYPE"))) {
//如果是表达式则需要替换表单式的变量
delegateTask.setAssignee(sub.replace(oConvertUtils.getString(nowOutNode.get("EXCEPTION_USER"),"system")));//指定办理人
}
//自动跳转到下一节点审批
if("1".equals(nowOutNode.get("EXCEPTION_TYPE")) && StringUtil.isNotEmpty(nowOutNode.get("EXCEPTION_NODE"))) {
par.put("activityId", nowOutNode.get("EXCEPTION_NODE").toString());
//如果节点变量不为空的话，需要把变量的值存入数据库，否则就会报错，因为在跳转到目标节点后如果没有赋值就会抛异常
if(StringUtil.isNotEmpty(nowOutNode.get("VARIABLE"))&&StringUtil.isNotEmpty(nowOutNode.get("EXCEPTION_NODE_VARIABLE"))) {
Matcher matcher = pattern.matcher(nowOutNode.get("variable").toString());
if(matcher.find()){
String mg = matcher.group(1);
par.put(mg, sub.replace(oConvertUtils.getString(nowOutNode.get("EXCEPTION_NODE_VARIABLE").toString(),"system")));
}
}
//执行跳转逻辑
JSONObject jumpNodeJson = JSONObject.fromObject(ceX2ProcessRestService.doJumpNode(par));
if(jumpNodeJson.getBoolean("success")) {
return;
}
}
}
//当重复审批时，自动审批,自动流转到下一节点，只能跳转一次
if("1".equals(nowOutNode.get("AUTO_AUDIT")) && StringUtil.isNotEmpty(assignee)) {
System.out.println("");
//查询当前办理人是否重复审批该节点，如果是则直接跳过
List<HistoricTaskInstance> taskList = historyService.createHistoricTaskInstanceQuery().
processInstanceId(delegateTask.getProcessInstanceId())
.taskAssignee(assignee)
// .taskDefinitionKey(delegateTask.getTaskDefinitionKey())
.list();
if(taskList!=null&&taskList.size()>0) {
JSONObject jumpNodeJson = forJumpNode(par, delegateTask.getId(), pattern, nowOutNode,allNodeMap);
if(jumpNodeJson.getBoolean("success")) {
return;
}
}
}
}
}
/**
* 循环判断跳转节点，直到最后一个不能跳转的节点，因为存在所有节点都是同一个人审批，那么久需要循环处理，直到找到最后一个可以跳转的节点
* @Description TODO
* @param variableAll
* @param task
* @param pattern
* @param nowOutNode
* @return
* @return JSONObject
* @Author 何湘简
* @Date 2021年7月7日 下午1:41:33
*/
private JSONObject forJumpNode(Map<String, Object> variableAll, String taskId, Pattern pattern,
Map<String, Object> nowOutNode,Map<String, Map<String, String>> allNodeMap) {
StrSubstitutor sub = new StrSubstitutor(variableAll);
CeX2ProcessRestServiceI ceX2ProcessRestService = ApplicationContextUtil.getContext().getBean(
CeX2ProcessRestServiceI.class);
JSONObject jumpNodeJson=new JSONObject();
Map<String, Object> par = new HashMap<String, Object>();
par.putAll(variableAll);
par.put("taskId", taskId);
par.put("activityId", nowOutNode.get("AUTO_NODE").toString());
//如果存在该节点就需要判断该节点是否设置自动审核的功能
// if(allNodeMap.containsKey(nowOutNode.get("AUTO_NODE").toString())) {
// jumpNodeJson = forJumpNode(variableAll, taskId, pattern, nowOutNode,allNodeMap);
//如果节点变量不为空的话，需要把变量的值存入数据库，否则就会报错，因为在跳转到目标节点后如果没有赋值就会抛异常
if(StringUtil.isNotEmpty(nowOutNode.get("VARIABLE"))&&StringUtil.isNotEmpty(nowOutNode.get("AUTO_VARIABLE"))) {
Matcher matcher = pattern.matcher(nowOutNode.get("VARIABLE").toString());
if(matcher.find()){
String mg = matcher.group(1);
//获取表达式中的内容
// String result = (String) ExpressionEvaluator.evaluate(mg, listVariables);
//获取表达式对象，替换表达式的值，默认为system审核
par.put(mg, sub.replace(oConvertUtils.getString(nowOutNode.get("AUTO_VARIABLE").toString(),"system")));
}
}
//执行跳转逻辑
jumpNodeJson=JSONObject.fromObject(ceX2ProcessRestService.doJumpNode(par));
// }
return jumpNodeJson;
}
}
本文由 admin 创作，采用 知识共享署名4.0
国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为:2022-08-09 22:50:43