@Override // 默认销售负责人负责的工单列表
public String execute() throws Exception {
List<Issue> dbIssues = new ArrayList<Issue>();
HttpSession session = request.getSession();
// 获取当前登录用户
User sessionUser = (User) session.getAttribute(LicenseWorkFlowConstants.SESSION_USER);
// 获取流程定义列表
List<ProcessDefinition> pdList =
issueService.getRepositoryService().createProcessDefinitionQuery().list();
// 获取流程实例列表
List<ProcessInstance> piList =
issueService.getExecutionService().createProcessInstanceQuery().list();
// 获取该用户组内的任务
List<Task> taskList = issueService.getTaskService().findGroupTasks(sessionUser.getName());
// 查询库中所有的工单
dbIssues = issueService.getAllIssues();
// 获取流程寮例历史记录列表
List<HistoryProcessInstance> hplist =
issueService.getHistoryService().createHistoryProcessInstanceQuery().list();
String processDefinitionId = ""; // 流程定义标识
if (pdList != null && pdList.size() > 0) {
processDefinitionId = ((ProcessDefinition) (pdList.get(0))).getId();
}
// 遍历系统中的工单
for (Issue issue : dbIssues) {
// 设置工单的流程节点
String activeName = issueService.getActiveName(issue.getProcessInstanceId());
IssueVO issueVO = new IssueVO();
issueVO.setWorkFlowNodeName(activeName);
// 遍历当前登录用户的task列表
for (Task task : taskList) {
// 获取执行
Execution execution =
issueService.getExecutionService().findExecutionById(task.getExecutionId());
ExecutionImpl execImpl = (ExecutionImpl) execution;
// 获取执行的流程实例
ProcessInstance processInstance = execImpl.getProcessInstance();
if (issue.getProcessInstanceId().equals(processInstance.getId())) {
// 显示审核链接
issueVO.setShowAudit(true);
// 当前工单要审核的task
issueVO.setIssueTask(task);
break;
} else {
issueVO.setShowAudit(false);
}
}
LicenseWorkFlowConstants.issuePOTOVOCopier.copy(issue, issueVO, null);
issues.add(issueVO);
}
return "index";
}
public JbpmConstantsElResolver(ScopeInstanceImpl scopeInstance) {
if (scopeInstance instanceof ExecutionImpl) {
this.execution = (ExecutionImpl) scopeInstance;
this.processInstance = execution.getProcessInstance();
} else {
this.task = (TaskImpl) scopeInstance;
this.execution = task.getExecution();
if (this.execution != null) {
this.processInstance = execution.getProcessInstance();
}
}
}
public Object set(String key, Object value) {
if (CONTEXTNAME_EXECUTION.equals(key)) {
throw new JbpmException("can't set execution");
}
execution.setVariable(key, value);
return null;
}
public void signal(ExecutionImpl execution, String signalName, Map<String, ?> parameters)
throws Exception {
Activity activity = execution.getActivity();
if (parameters != null) {
execution.setVariables(parameters);
}
execution.fire(signalName, activity);
Transition transition = null;
if ((signalName == null)
&& (activity.getOutgoingTransitions() != null)
&& (activity.getOutgoingTransitions().size() == 1)) {
transition = activity.getOutgoingTransitions().get(0);
} else {
transition = activity.findOutgoingTransition(signalName);
}
if (transition != null) {
execution.historyActivityEnd(signalName);
execution.take(transition);
} else {
execution.waitForSignal();
}
}
public void execute(ExecutionImpl execution) {
execution.historyActivityStart();
execution.waitForSignal();
}
public Set<String> keys() {
Set<String> keys = new HashSet<String>(execution.getVariableKeys());
keys.add(CONTEXTNAME_EXECUTION);
return keys;
}
public boolean has(String key) {
if (CONTEXTNAME_EXECUTION.equals(key)) {
return true;
}
return execution.hasVariable(key);
}
public Object get(String key) {
if (CONTEXTNAME_EXECUTION.equals(key)) {
return execution;
}
return execution.getVariable(key);
}
public void execute(ExecutionImpl execution) {
Activity activity = execution.getActivity();
// evaluate the conditions and select the forking transitions
List<Transition> forkingTransitions = new ArrayList<Transition>();
for (Transition transition : activity.getOutgoingTransitions()) {
Condition condition = ((TransitionImpl) transition).getCondition();
if (condition == null || condition.evaluate(execution)) {
forkingTransitions.add(transition);
}
}
switch (forkingTransitions.size()) {
case 0:
// if no outgoing transitions should be forked, end this execution
execution.end();
break;
case 1:
// if there is exactly one transition to be taken, just use the incoming execution
execution.take(forkingTransitions.get(0));
break;
default:
// if there are more transitions, perform full fork
ExecutionImpl concurrentRoot;
if (Execution.STATE_ACTIVE_ROOT.equals(execution.getState())) {
concurrentRoot = execution;
execution.setState(Execution.STATE_INACTIVE_CONCURRENT_ROOT);
execution.setActivity(null);
} else if (Execution.STATE_ACTIVE_CONCURRENT.equals(execution.getState())) {
concurrentRoot = execution.getParent();
execution.end();
} else {
throw new AssertionError(execution.getState());
}
Map<Transition, ExecutionImpl> concurrentExecutions =
new HashMap<Transition, ExecutionImpl>();
for (Transition transition : forkingTransitions) {
ExecutionImpl concurrentExecution = concurrentRoot.createExecution(transition.getName());
concurrentExecution.setActivity(activity);
concurrentExecution.setState(Execution.STATE_ACTIVE_CONCURRENT);
concurrentExecutions.put(transition, concurrentExecution);
}
for (Entry<Transition, ExecutionImpl> entry : concurrentExecutions.entrySet()) {
entry.getValue().take(entry.getKey());
if (concurrentRoot.isEnded()) break;
}
}
}