[jboss-svn-commits] JBL Code SVN: r32431 - in labs/jbossrules/trunk/drools-process/drools-process-task: src/main/java/org/drools/process/workitem/wsht and 4 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Mon Apr 5 19:22:23 EDT 2010
Author: KrisVerlaenen
Date: 2010-04-05 19:22:22 -0400 (Mon, 05 Apr 2010)
New Revision: 32431
Added:
labs/jbossrules/trunk/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandlerTest.java
Modified:
labs/jbossrules/trunk/drools-process/drools-process-task/pom.xml
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandler.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/MessagingTaskEventListener.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/TaskEventKey.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/CommandName.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/MinaTaskClient.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskClientHandler.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServerHandler.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServiceSession.java
labs/jbossrules/trunk/drools-process/drools-process-task/src/main/resources/META-INF/orm.xml
Log:
JBRULES-2471: Human task handler does not support restarting session for already created tasks
- using generic event listener that listens for all completed human tasks
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/pom.xml
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/pom.xml 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/pom.xml 2010-04-05 23:22:22 UTC (rev 32431)
@@ -61,7 +61,7 @@
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
- <version>1.0.77</version>
+ <version>1.1.117</version>
<scope>test</scope>
</dependency>
<dependency>
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandler.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandler.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandler.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -14,7 +14,6 @@
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.drools.SystemEventListenerFactory;
-import org.drools.eventmessaging.EventKey;
import org.drools.eventmessaging.EventResponseHandler;
import org.drools.eventmessaging.Payload;
import org.drools.runtime.KnowledgeRuntime;
@@ -27,6 +26,7 @@
import org.drools.task.I18NText;
import org.drools.task.OrganizationalEntity;
import org.drools.task.PeopleAssignments;
+import org.drools.task.Status;
import org.drools.task.SubTasksStrategy;
import org.drools.task.SubTasksStrategyFactory;
import org.drools.task.Task;
@@ -40,7 +40,6 @@
import org.drools.task.service.ContentData;
import org.drools.task.service.MinaTaskClient;
import org.drools.task.service.TaskClientHandler;
-import org.drools.task.service.TaskClientHandler.AddTaskResponseHandler;
import org.drools.task.service.TaskClientHandler.GetContentResponseHandler;
import org.drools.task.service.TaskClientHandler.GetTaskResponseHandler;
import org.drools.task.service.responsehandlers.AbstractBaseResponseHandler;
@@ -51,7 +50,6 @@
private int port = 9123;
private MinaTaskClient client;
private KnowledgeRuntime session;
- private Map<Long, Long> idMapping = new HashMap<Long, Long>();
public CommandBasedWSHumanTaskHandler(KnowledgeRuntime session) {
this.session = session;
@@ -75,6 +73,13 @@
"Could not connect task client");
}
}
+ TaskEventKey key = new TaskEventKey(TaskCompletedEvent.class, -1);
+ TaskCompletedHandler eventResponseHandler = new TaskCompletedHandler();
+ client.registerForEvent(key, true, eventResponseHandler);
+ key = new TaskEventKey(TaskFailedEvent.class, -1);
+ client.registerForEvent(key, true, eventResponseHandler);
+ key = new TaskEventKey(TaskSkippedEvent.class, -1);
+ client.registerForEvent(key, true, eventResponseHandler);
}
public void executeWorkItem(WorkItem workItem, WorkItemManager manager) {
@@ -178,9 +183,7 @@
e.printStackTrace();
}
}
- TaskWorkItemAddTaskResponseHandler taskResponseHandler =
- new TaskWorkItemAddTaskResponseHandler(this.client, workItem.getId());
- client.addTask(task, content, taskResponseHandler);
+ client.addTask(task, content, null);
}
public void dispose() {
@@ -190,62 +193,18 @@
}
public void abortWorkItem(WorkItem workItem, WorkItemManager manager) {
- Long taskId = idMapping.get(workItem.getId());
- if (taskId != null) {
- synchronized (idMapping) {
- idMapping.remove(taskId);
- }
- client.skip(taskId, "Administrator", null);
- }
+ GetTaskResponseHandler abortTaskResponseHandler = new AbortTaskResponseHandler();
+ client.getTaskByWorkItemId(workItem.getId(), abortTaskResponseHandler);
}
-
- public class TaskWorkItemAddTaskResponseHandler extends AbstractBaseResponseHandler implements AddTaskResponseHandler {
-
- private long workItemId;
-
- public TaskWorkItemAddTaskResponseHandler(MinaTaskClient client, long workItemId) {
- this.workItemId = workItemId;
- }
-
- public void execute(long taskId) {
- synchronized ( idMapping ) {
- idMapping.put(workItemId, taskId);
- }
-// System.out.println("Created task " + taskId + " for work item " + workItemId);
-
- EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId );
- TaskCompletedHandler eventResponseHandler =
- new TaskCompletedHandler(workItemId, taskId);
- client.registerForEvent( key, true, eventResponseHandler );
- key = new TaskEventKey(TaskFailedEvent.class, taskId );
- client.registerForEvent( key, true, eventResponseHandler );
- key = new TaskEventKey(TaskSkippedEvent.class, taskId );
- client.registerForEvent( key, true, eventResponseHandler );
- }
- }
private class TaskCompletedHandler extends AbstractBaseResponseHandler implements EventResponseHandler {
- private long workItemId;
- private long taskId;
- public TaskCompletedHandler(long workItemId, long taskId) {
- this.workItemId = workItemId;
- this.taskId = taskId;
- }
-
public void execute(Payload payload) {
TaskEvent event = ( TaskEvent ) payload.get();
- if ( event.getTaskId() != taskId ) {
- // defensive check that should never happen, just here for testing
- setError(new IllegalStateException("Expected task id and arrived task id do not march"));
- return;
- }
- if (event instanceof TaskCompletedEvent) {
- GetTaskResponseHandler getTaskResponseHandler = new GetCompletedTaskResponseHandler();
- client.getTask(taskId, getTaskResponseHandler);
- } else {
- session.getWorkItemManager().abortWorkItem(workItemId);
- }
+ long taskId = event.getTaskId();
+ GetTaskResponseHandler getTaskResponseHandler =
+ new GetCompletedTaskResponseHandler();
+ client.getTask(taskId, getTaskResponseHandler);
}
}
@@ -253,16 +212,22 @@
public void execute(Task task) {
long workItemId = task.getTaskData().getWorkItemId();
- String userId = task.getTaskData().getActualOwner().getId();
- Map<String, Object> results = new HashMap<String, Object>();
- results.put("ActorId", userId);
- long contentId = task.getTaskData().getOutputContentId();
- if (contentId != -1) {
- GetContentResponseHandler getContentResponseHandler =
- new GetResultContentResponseHandler(task, results);
- client.getContent(contentId, getContentResponseHandler);
+ if (task.getTaskData().getStatus() == Status.Completed) {
+ System.out.println("Notification of completed task " + workItemId);
+ String userId = task.getTaskData().getActualOwner().getId();
+ Map<String, Object> results = new HashMap<String, Object>();
+ results.put("ActorId", userId);
+ long contentId = task.getTaskData().getOutputContentId();
+ if (contentId != -1) {
+ GetContentResponseHandler getContentResponseHandler =
+ new GetResultContentResponseHandler(task, results);
+ client.getContent(contentId, getContentResponseHandler);
+ } else {
+ session.getWorkItemManager().completeWorkItem(workItemId, results);
+ }
} else {
- session.getWorkItemManager().completeWorkItem(workItemId, results);
+ System.out.println("Notification of completed task " + workItemId);
+ session.getWorkItemManager().abortWorkItem(workItemId);
}
}
}
@@ -302,4 +267,14 @@
}
}
}
+
+ private class AbortTaskResponseHandler extends AbstractBaseResponseHandler implements GetTaskResponseHandler {
+
+ public void execute(Task task) {
+ if (task != null) {
+ client.skip(task.getId(), "Administrator", null);
+ }
+ }
+ }
+
}
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -31,8 +31,7 @@
private String ipAddress = "127.0.0.1";
private int port = 9123;
private MinaTaskClient client;
- private Map<Long, WorkItemManager> managers = new HashMap<Long, WorkItemManager>();
- private Map<Long, Long> idMapping = new HashMap<Long, Long>();
+ private WorkItemManager manager = null;
public void setConnection(String ipAddress, int port) {
this.ipAddress = ipAddress;
@@ -51,10 +50,30 @@
throw new IllegalArgumentException(
"Could not connect task client");
}
+ TaskEventKey key = new TaskEventKey(TaskCompletedEvent.class, -1);
+ TaskCompletedHandler eventResponseHandler =
+ new TaskCompletedHandler(manager, client);
+ client.registerForEvent(key, true, eventResponseHandler);
+ key = new TaskEventKey(TaskFailedEvent.class, -1);
+ client.registerForEvent(key, true, eventResponseHandler);
+ key = new TaskEventKey(TaskSkippedEvent.class, -1);
+ client.registerForEvent(key, true, eventResponseHandler);
}
}
+
+ public void setManager(WorkItemManager manager) {
+ this.manager = manager;
+ }
public void executeWorkItem(WorkItem workItem, WorkItemManager manager) {
+ if (this.manager == null) {
+ this.manager = manager;
+ } else {
+ if (this.manager != manager) {
+ throw new IllegalArgumentException(
+ "This WSHumanTaskHandler can only be used for one WorkItemManager");
+ }
+ }
connect();
Task task = new Task();
String taskName = (String) workItem.getParameter("TaskName");
@@ -155,10 +174,7 @@
e.printStackTrace();
}
}
- TaskWorkItemAddTaskResponseHandler taskResponseHandler =
- new TaskWorkItemAddTaskResponseHandler(this.client, this.managers,
- this.idMapping, manager, workItem.getId());
- client.addTask(task, content, taskResponseHandler);
+ client.addTask(task, content, null);
}
public void dispose() {
@@ -168,93 +184,26 @@
}
public void abortWorkItem(WorkItem workItem, WorkItemManager manager) {
- Long taskId = idMapping.get(workItem.getId());
- if (taskId != null) {
- synchronized (idMapping) {
- idMapping.remove(taskId);
- }
- synchronized (managers) {
- managers.remove(taskId);
- }
- client.skip(taskId, "Administrator", null);
- }
+ GetTaskResponseHandler abortTaskResponseHandler =
+ new AbortTaskResponseHandler(client);
+ client.getTaskByWorkItemId(workItem.getId(), abortTaskResponseHandler);
}
-
- public static class TaskWorkItemAddTaskResponseHandler extends AbstractBaseResponseHandler implements AddTaskResponseHandler {
- private Map<Long, WorkItemManager> managers;
- private Map<Long, Long> idMapping;
- private WorkItemManager manager;
- private long workItemId;
- private MinaTaskClient client;
-
- public TaskWorkItemAddTaskResponseHandler(MinaTaskClient client,
- Map<Long, WorkItemManager> managers, Map<Long, Long> idMapping,
- WorkItemManager manager, long workItemId) {
- this.client = client;
- this.managers = managers;
- this.idMapping = idMapping;
- this.manager = manager;
- this.workItemId = workItemId;
- }
-
- public void execute(long taskId) {
- synchronized ( managers ) {
- managers.put(taskId, this.manager);
- }
- synchronized ( idMapping ) {
- idMapping.put(workItemId, taskId);
- }
-// System.out.println("Created task " + taskId + " for work item " + workItemId);
-
- EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId );
- TaskCompletedHandler eventResponseHandler =
- new TaskCompletedHandler(workItemId, taskId, managers, client);
- client.registerForEvent( key, true, eventResponseHandler );
- key = new TaskEventKey(TaskFailedEvent.class, taskId );
- client.registerForEvent( key, true, eventResponseHandler );
- key = new TaskEventKey(TaskSkippedEvent.class, taskId );
- client.registerForEvent( key, true, eventResponseHandler );
- }
- }
private static class TaskCompletedHandler extends AbstractBaseResponseHandler implements EventResponseHandler {
- private long workItemId;
- private long taskId;
- private Map<Long, WorkItemManager> managers;
+ private WorkItemManager manager;
private MinaTaskClient client;
- public TaskCompletedHandler(long workItemId, long taskId, Map<Long, WorkItemManager> managers,
- MinaTaskClient client) {
- this.workItemId = workItemId;
- this.taskId = taskId;
- this.managers = managers;
+ public TaskCompletedHandler(WorkItemManager manager, MinaTaskClient client) {
+ this.manager = manager;
this.client = client;
}
public void execute(Payload payload) {
TaskEvent event = ( TaskEvent ) payload.get();
- if ( event.getTaskId() != taskId ) {
- // defensive check that should never happen, just here for testing
- setError(new IllegalStateException("Expected task id and arrived task id do not march"));
- return;
- }
- if (event instanceof TaskCompletedEvent) {
- synchronized ( this.managers ) {
- WorkItemManager manager = this.managers.get(taskId);
- if (manager != null) {
- GetTaskResponseHandler getTaskResponseHandler =
- new GetCompletedTaskResponseHandler(manager, client);
- client.getTask(taskId, getTaskResponseHandler);
- }
- }
- } else {
- synchronized ( this.managers ) {
- WorkItemManager manager = this.managers.get(taskId);
- if (manager != null) {
- manager.abortWorkItem(workItemId);
- }
- }
- }
+ long taskId = event.getTaskId();
+ GetTaskResponseHandler getTaskResponseHandler =
+ new GetCompletedTaskResponseHandler(manager, client);
+ client.getTask(taskId, getTaskResponseHandler);
}
}
@@ -270,16 +219,20 @@
public void execute(Task task) {
long workItemId = task.getTaskData().getWorkItemId();
- String userId = task.getTaskData().getActualOwner().getId();
- Map<String, Object> results = new HashMap<String, Object>();
- results.put("ActorId", userId);
- long contentId = task.getTaskData().getOutputContentId();
- if (contentId != -1) {
- GetContentResponseHandler getContentResponseHandler =
- new GetResultContentResponseHandler(manager, task, results);
- client.getContent(contentId, getContentResponseHandler);
+ if (task.getTaskData().getStatus() == Status.Completed) {
+ String userId = task.getTaskData().getActualOwner().getId();
+ Map<String, Object> results = new HashMap<String, Object>();
+ results.put("ActorId", userId);
+ long contentId = task.getTaskData().getOutputContentId();
+ if (contentId != -1) {
+ GetContentResponseHandler getContentResponseHandler =
+ new GetResultContentResponseHandler(manager, task, results);
+ client.getContent(contentId, getContentResponseHandler);
+ } else {
+ manager.completeWorkItem(workItemId, results);
+ }
} else {
- manager.completeWorkItem(workItemId, results);
+ manager.abortWorkItem(workItemId);
}
}
}
@@ -320,4 +273,20 @@
}
}
}
+
+ private static class AbortTaskResponseHandler extends AbstractBaseResponseHandler implements GetTaskResponseHandler {
+
+ private MinaTaskClient client;
+
+ public AbortTaskResponseHandler(MinaTaskClient client) {
+ this.client = client;
+ }
+
+ public void execute(Task task) {
+ if (task != null) {
+ client.skip(task.getId(), "Administrator", null);
+ }
+ }
+ }
+
}
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/MessagingTaskEventListener.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/MessagingTaskEventListener.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/MessagingTaskEventListener.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -39,8 +39,18 @@
EventKey key = new TaskEventKey(TaskCompletedEvent.class, event.getTaskId() );
List<EventTriggerTransport> targets = keys.getTargets( key );
if ( targets == null ){
- return;
- }
+ key = new TaskEventKey(TaskCompletedEvent.class, -1);
+ targets = keys.getTargets( key );
+ if (targets == null) {
+ return;
+ }
+ } else {
+ key = new TaskEventKey(TaskCompletedEvent.class, -1);
+ List<EventTriggerTransport> additionalTargets = keys.getTargets( key );
+ if (additionalTargets != null) {
+ targets.addAll(additionalTargets);
+ }
+ }
Payload payload = new EventPayload( event );
for ( Iterator<EventTriggerTransport> it = targets.iterator(); it.hasNext(); ) {
EventTriggerTransport target = it.next();
@@ -58,7 +68,17 @@
EventKey key = new TaskEventKey(TaskFailedEvent.class, event.getTaskId() );
List<EventTriggerTransport> targets = keys.getTargets( key );
if ( targets == null ){
- return;
+ key = new TaskEventKey(TaskFailedEvent.class, -1);
+ targets = keys.getTargets( key );
+ if (targets == null) {
+ return;
+ }
+ } else {
+ key = new TaskEventKey(TaskFailedEvent.class, -1);
+ List<EventTriggerTransport> additionalTargets = keys.getTargets( key );
+ if (additionalTargets != null) {
+ targets.addAll(additionalTargets);
+ }
}
Payload payload = new EventPayload( event );
for ( Iterator<EventTriggerTransport> it = targets.iterator(); it.hasNext(); ) {
@@ -77,7 +97,17 @@
EventKey key = new TaskEventKey(TaskSkippedEvent.class, event.getTaskId() );
List<EventTriggerTransport> targets = keys.getTargets( key );
if ( targets == null ){
- return;
+ key = new TaskEventKey(TaskSkippedEvent.class, -1);
+ targets = keys.getTargets( key );
+ if (targets == null) {
+ return;
+ }
+ } else {
+ key = new TaskEventKey(TaskSkippedEvent.class, -1);
+ List<EventTriggerTransport> additionalTargets = keys.getTargets( key );
+ if (additionalTargets != null) {
+ targets.addAll(additionalTargets);
+ }
}
Payload payload = new EventPayload( event );
for ( Iterator<EventTriggerTransport> it = targets.iterator(); it.hasNext(); ) {
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/TaskEventKey.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/TaskEventKey.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/event/TaskEventKey.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -10,7 +10,7 @@
public class TaskEventKey implements EventKey, Externalizable {
private Class<? extends TaskEvent> event;
- private long taskId;
+ private long taskId = -1;
public TaskEventKey() {
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/CommandName.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/CommandName.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/CommandName.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -72,6 +72,9 @@
QueryTasksAssignedAsTaskStakeholder,
QueryTaskSummaryResponse,
+ QueryTaskByWorkItemId,
+ QueryTaskByWorkItemIdResponse,
+
RegisterForEventRequest,
EventTriggerResponse,
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/MinaTaskClient.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/MinaTaskClient.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/MinaTaskClient.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -367,6 +367,18 @@
session.write( cmd );
}
+ public void getTaskByWorkItemId(long workItemId,
+ GetTaskResponseHandler responseHandler) {
+ List<Object> args = new ArrayList<Object>(1);
+ args.add(workItemId);
+ Command cmd = new Command( counter.getAndIncrement(),
+ CommandName.QueryTaskByWorkItemId,
+ args);
+ handler.addResponseHandler( cmd.getId(),
+ responseHandler);
+ session.write(cmd);
+ }
+
public void getTasksAssignedAsBusinessAdministrator(String userId,
String language,
TaskSummaryResponseHandler responseHandler) {
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskClientHandler.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskClientHandler.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskClientHandler.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -165,6 +165,18 @@
}
break;
}
+ case QueryTaskByWorkItemIdResponse: {
+ GetTaskResponseHandler responseHandler = (GetTaskResponseHandler) responseHandlers.remove(cmd.getId());
+ if (responseHandler != null) {
+ if (!cmd.getArguments().isEmpty() && cmd.getArguments().get(0) instanceof RuntimeException) {
+ responseHandler.setError((RuntimeException) cmd.getArguments().get(0));
+ } else {
+ Task result = (Task) cmd.getArguments().get(0);
+ responseHandler.execute(result);
+ }
+ }
+ break;
+ }
case EventTriggerResponse: {
EventResponseHandler responseHandler = (EventResponseHandler) responseHandlers.remove(cmd.getId());
if (responseHandler != null) {
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServerHandler.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServerHandler.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServerHandler.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -180,6 +180,17 @@
session.write(resultsCmnd);
break;
}
+ case QueryTaskByWorkItemId: {
+ response = CommandName.QueryTaskByWorkItemIdResponse;
+ Task result = taskSession.getTaskByWorkItemId((Long) cmd.getArguments().get(0));
+ List args = new ArrayList(1);
+ args.add(result);
+ Command resultsCmnd = new Command(cmd.getId(),
+ CommandName.QueryTaskByWorkItemIdResponse,
+ args);
+ session.write(resultsCmnd);
+ break;
+ }
case QueryTasksOwned: {
response = CommandName.QueryTaskSummaryResponse;
List<TaskSummary> results = taskSession.getTasksOwned((String) cmd.getArguments().get(0),
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServiceSession.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServiceSession.java 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/java/org/drools/task/service/TaskServiceSession.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -490,6 +490,13 @@
return (List<DeadlineSummary>) em.createNamedQuery("UnescalatedDeadlines").getResultList();
}
+ public Task getTaskByWorkItemId(final long workItemId) {
+ final Query task = em.createNamedQuery("TaskByWorkItemId");
+ task.setParameter("workItemId", workItemId);
+
+ return (Task) task.getSingleResult();
+ }
+
public List<TaskSummary> getTasksOwned(final String userId, final String language) {
final Query tasksOwned = em.createNamedQuery("TasksOwned");
tasksOwned.setParameter("userId", userId);
Modified: labs/jbossrules/trunk/drools-process/drools-process-task/src/main/resources/META-INF/orm.xml
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/main/resources/META-INF/orm.xml 2010-04-05 23:16:16 UTC (rev 32430)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/main/resources/META-INF/orm.xml 2010-04-05 23:22:22 UTC (rev 32431)
@@ -532,4 +532,15 @@
</query>
<!-- hint name="org.hibernate.timeout" value="200"/ -->
</named-query>
+ <named-query name="TaskByWorkItemId">
+ <query>
+select
+ t
+from
+ Task t
+where
+ t.taskData.workItemId = :workItemId
+ </query>
+ <!-- hint name="org.hibernate.timeout" value="200"/ -->
+ </named-query>
</entity-mappings>
Added: labs/jbossrules/trunk/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandlerTest.java
===================================================================
--- labs/jbossrules/trunk/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandlerTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/CommandBasedWSHumanTaskHandlerTest.java 2010-04-05 23:22:22 UTC (rev 32431)
@@ -0,0 +1,776 @@
+package org.drools.process.workitem.wsht;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+import org.apache.mina.transport.socket.nio.NioSocketConnector;
+import org.drools.KnowledgeBaseFactory;
+import org.drools.SystemEventListenerFactory;
+import org.drools.WorkingMemory;
+import org.drools.impl.EnvironmentFactory;
+import org.drools.process.instance.WorkItem;
+import org.drools.process.instance.WorkItemManagerFactory;
+import org.drools.process.instance.impl.WorkItemImpl;
+import org.drools.runtime.KnowledgeSessionConfiguration;
+import org.drools.runtime.StatefulKnowledgeSession;
+import org.drools.runtime.process.WorkItemHandler;
+import org.drools.task.AccessType;
+import org.drools.task.BaseTest;
+import org.drools.task.Status;
+import org.drools.task.Task;
+import org.drools.task.query.TaskSummary;
+import org.drools.task.service.ContentData;
+import org.drools.task.service.MinaTaskClient;
+import org.drools.task.service.MinaTaskServer;
+import org.drools.task.service.PermissionDeniedException;
+import org.drools.task.service.TaskClientHandler;
+import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskSummaryResponseHandler;
+
+public class CommandBasedWSHumanTaskHandlerTest extends BaseTest {
+ private static final int DEFAULT_WAIT_TIME = 5000;
+ private static final int MANAGER_COMPLETION_WAIT_TIME = DEFAULT_WAIT_TIME;
+ private static final int MANAGER_ABORT_WAIT_TIME = DEFAULT_WAIT_TIME;
+
+ MinaTaskServer server;
+ MinaTaskClient client;
+ CommandBasedWSHumanTaskHandler handler;
+ StatefulKnowledgeSession ksession;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ server = new MinaTaskServer(taskService);
+ Thread thread = new Thread(server);
+ thread.start();
+ Thread.sleep(500);
+ client = new MinaTaskClient("client 1", new TaskClientHandler(SystemEventListenerFactory.getSystemEventListener()));
+ NioSocketConnector connector = new NioSocketConnector();
+ SocketAddress address = new InetSocketAddress("127.0.0.1", 9123);
+ client.connect(connector, address);
+
+ Properties properties = new Properties();
+ properties.setProperty("drools.workItemManagerFactory",
+ "org.drools.process.workitem.wsht.CommandBasedWSHumanTaskHandlerTest$TestWorkItemManagerFactory");
+ KnowledgeSessionConfiguration conf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration(properties);
+ ksession = KnowledgeBaseFactory.newKnowledgeBase().newStatefulKnowledgeSession(conf, EnvironmentFactory.newEnvironment());
+ handler = new CommandBasedWSHumanTaskHandler(ksession);
+ }
+
+ protected void tearDown() throws Exception {
+ handler.dispose();
+ client.disconnect();
+ server.stop();
+ super.tearDown();
+ }
+
+ public void testTask() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary task = tasks.get(0);
+ assertEquals("TaskName", task.getName());
+ assertEquals(10, task.getPriority());
+ assertEquals("Comment", task.getDescription());
+ assertEquals(Status.Reserved, task.getStatus());
+ assertEquals("Darth Vader", task.getActualOwner().getId());
+
+ System.out.println("Starting task " + task.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started task " + task.getId());
+
+ System.out.println("Completing task " + task.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.complete(task.getId(), "Darth Vader", null, operationResponseHandler);
+ operationResponseHandler.waitTillDone(15000);
+ System.out.println("Completed task " + task.getId());
+
+ assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+ }
+
+ public void testTaskMultipleActors() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader, Dalai Lama");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary task = tasks.get(0);
+ assertEquals("TaskName", task.getName());
+ assertEquals(10, task.getPriority());
+ assertEquals("Comment", task.getDescription());
+ assertEquals(Status.Ready, task.getStatus());
+
+ System.out.println("Claiming task " + task.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.claim(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Claimed task " + task.getId());
+
+ System.out.println("Starting task " + task.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started task " + task.getId());
+
+ System.out.println("Completing task " + task.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.complete(task.getId(), "Darth Vader", null, operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Completed task " + task.getId());
+
+ assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+ }
+
+ public void testTaskGroupActors() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("GroupId", "Crusaders");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ List<String> groupIds = new ArrayList<String>();
+ groupIds.add("Crusaders");
+ client.getTasksAssignedAsPotentialOwner(null, groupIds, "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary taskSummary = tasks.get(0);
+ assertEquals("TaskName", taskSummary.getName());
+ assertEquals(10, taskSummary.getPriority());
+ assertEquals("Comment", taskSummary.getDescription());
+ assertEquals(Status.Ready, taskSummary.getStatus());
+
+ System.out.println("Claiming task " + taskSummary.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.claim(taskSummary.getId(), "Darth Vader", operationResponseHandler);
+ PermissionDeniedException denied = null;
+ try {
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ } catch (PermissionDeniedException e) {
+ denied = e;
+ }
+
+ assertNotNull("Should get permissed denied exception", denied);
+ System.out.println("Claimed task " + taskSummary.getId());
+
+ //Check if the parent task is InProgress
+ BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(taskSummary.getId(), getTaskResponseHandler);
+ Task task = getTaskResponseHandler.getTask();
+ assertEquals(Status.Ready, task.getTaskData().getStatus());
+ }
+
+ public void testTaskSingleAndGroupActors() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task One");
+ workItem.setParameter("TaskName", "TaskNameOne");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("GroupId", "Crusaders");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ workItem = new WorkItemImpl();
+ workItem.setName("Human Task Two");
+ workItem.setParameter("TaskName", "TaskNameTwo");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ List<String> groupIds = new ArrayList<String>();
+ groupIds.add("Crusaders");
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", groupIds, "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(2, tasks.size());
+ }
+
+ public void testTaskFail() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary task = tasks.get(0);
+ assertEquals("TaskName", task.getName());
+ assertEquals(10, task.getPriority());
+ assertEquals("Comment", task.getDescription());
+ assertEquals(Status.Reserved, task.getStatus());
+ assertEquals("Darth Vader", task.getActualOwner().getId());
+
+ System.out.println("Starting task " + task.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started task " + task.getId());
+
+ System.out.println("Failing task " + task.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.fail(task.getId(), "Darth Vader", null, operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Failed task " + task.getId());
+
+ assertTrue(manager.waitTillAborted(MANAGER_ABORT_WAIT_TIME));
+ }
+
+ public void testTaskSkip() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary task = tasks.get(0);
+ assertEquals("TaskName", task.getName());
+ assertEquals(10, task.getPriority());
+ assertEquals("Comment", task.getDescription());
+ assertEquals(Status.Reserved, task.getStatus());
+ assertEquals("Darth Vader", task.getActualOwner().getId());
+
+ System.out.println("Skipping task " + task.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.skip(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Skipped task " + task.getId());
+
+ assertTrue(manager.waitTillAborted(MANAGER_ABORT_WAIT_TIME));
+ }
+
+ public void testTaskAbortSkippable() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ handler.abortWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(0, tasks.size());
+ }
+
+ public void testTaskAbortNotSkippable() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ workItem.setParameter("Skippable", "false");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+
+ handler.abortWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ }
+
+ public void testTaskData() throws Exception {
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskName");
+ workItem.setParameter("Comment", "Comment");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ workItem.setParameter("Content", "This is the content");
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary taskSummary = tasks.get(0);
+ assertEquals("TaskName", taskSummary.getName());
+ assertEquals(10, taskSummary.getPriority());
+ assertEquals("Comment", taskSummary.getDescription());
+ assertEquals(Status.Reserved, taskSummary.getStatus());
+ assertEquals("Darth Vader", taskSummary.getActualOwner().getId());
+
+ BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(taskSummary.getId(), getTaskResponseHandler);
+ Task task = getTaskResponseHandler.getTask();
+ assertEquals(AccessType.Inline, task.getTaskData().getDocumentAccessType());
+ long contentId = task.getTaskData().getDocumentContentId();
+ assertTrue(contentId != -1);
+ BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
+ client.getContent(contentId, getContentResponseHandler);
+ ByteArrayInputStream bis = new ByteArrayInputStream(getContentResponseHandler.getContent().getContent());
+ ObjectInputStream in = new ObjectInputStream(bis);
+ Object data = in.readObject();
+ in.close();
+ assertEquals("This is the content", data);
+
+ System.out.println("Starting task " + task.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started task " + task.getId());
+
+ System.out.println("Completing task " + task.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ ContentData result = new ContentData();
+ result.setAccessType(AccessType.Inline);
+ result.setType("java.lang.String");
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ ObjectOutputStream out = new ObjectOutputStream(bos);
+ out.writeObject("This is the result");
+ out.close();
+ result.setContent(bos.toByteArray());
+ client.complete(task.getId(), "Darth Vader", result, operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Completed task " + task.getId());
+
+ assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+ Map<String, Object> results = manager.getResults();
+ assertNotNull(results);
+ assertEquals("Darth Vader", results.get("ActorId"));
+ assertEquals("This is the result", results.get("Result"));
+ }
+
+ public void testOnAllSubTasksEndParentEndStrategy() throws Exception {
+
+ //Create the parent task
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskNameParent");
+ workItem.setParameter("Comment", "CommentParent");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ //Set the subtask policy
+ workItem.setParameter("SubTaskStrategies", "OnAllSubTasksEndParentEnd");
+ handler.executeWorkItem(workItem, manager);
+
+
+ Thread.sleep(500);
+
+ //Test if the task is succesfully created
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary task = tasks.get(0);
+ assertEquals("TaskNameParent", task.getName());
+ assertEquals(10, task.getPriority());
+ assertEquals("CommentParent", task.getDescription());
+ assertEquals(Status.Reserved, task.getStatus());
+ assertEquals("Darth Vader", task.getActualOwner().getId());
+
+ //Create the child task
+ workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskNameChild1");
+ workItem.setParameter("Comment", "CommentChild1");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ workItem.setParameter("ParentId", task.getId());
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ //Create the child task2
+ workItem = new WorkItemImpl();
+ workItem.setName("Human Task2");
+ workItem.setParameter("TaskName", "TaskNameChild2");
+ workItem.setParameter("Comment", "CommentChild2");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ workItem.setParameter("ParentId", task.getId());
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ //Start the parent task
+ System.out.println("Starting task " + task.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started task " + task.getId());
+
+ //Check if the parent task is InProgress
+ BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(task.getId(), getTaskResponseHandler);
+ Task parentTask = getTaskResponseHandler.getTask();
+ assertEquals(Status.InProgress, parentTask.getTaskData().getStatus());
+ assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
+
+ //Get all the subtask created for the parent task based on the potential owner
+ responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getSubTasksAssignedAsPotentialOwner(parentTask.getId(), "Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> subTasks = responseHandler.getResults();
+ assertEquals(2, subTasks.size());
+ TaskSummary subTaskSummary1 = subTasks.get(0);
+ TaskSummary subTaskSummary2 = subTasks.get(1);
+ assertNotNull(subTaskSummary1);
+ assertNotNull(subTaskSummary2);
+
+ //Starting the sub task 1
+ System.out.println("Starting sub task " + subTaskSummary1.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(subTaskSummary1.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started sub task " + subTaskSummary1.getId());
+
+ //Starting the sub task 2
+ System.out.println("Starting sub task " + subTaskSummary2.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(subTaskSummary2.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started sub task " + subTaskSummary2.getId());
+
+ //Check if the child task 1 is InProgress
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTaskSummary1.getId(), getTaskResponseHandler);
+ Task subTask1 = getTaskResponseHandler.getTask();
+ assertEquals(Status.InProgress, subTask1.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+ //Check if the child task 2 is InProgress
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTaskSummary2.getId(), getTaskResponseHandler);
+ Task subTask2 = getTaskResponseHandler.getTask();
+ assertEquals(Status.InProgress, subTask2.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+ // Complete the child task 1
+ System.out.println("Completing sub task " + subTask1.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.complete(subTask1.getId(), "Darth Vader", null, operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Completed sub task " + subTask1.getId());
+
+ // Complete the child task 2
+ System.out.println("Completing sub task " + subTask2.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.complete(subTask2.getId(), "Darth Vader", null, operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Completed sub task " + subTask2.getId());
+
+ //Check if the child task 1 is Completed
+
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTask1.getId(), getTaskResponseHandler);
+ subTask1 = getTaskResponseHandler.getTask();
+ assertEquals(Status.Completed, subTask1.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+ //Check if the child task 2 is Completed
+
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTask2.getId(), getTaskResponseHandler);
+ subTask2 = getTaskResponseHandler.getTask();
+ assertEquals(Status.Completed, subTask2.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+ // Check is the parent task is Complete
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(parentTask.getId(), getTaskResponseHandler);
+ parentTask = getTaskResponseHandler.getTask();
+ assertEquals(Status.Completed, parentTask.getTaskData().getStatus());
+ assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
+
+ assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+ }
+
+ public void testOnParentAbortAllSubTasksEndStrategy() throws Exception {
+
+ //Create the parent task
+ WorkItemImpl workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskNameParent");
+ workItem.setParameter("Comment", "CommentParent");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ //Set the subtask policy
+ workItem.setParameter("SubTaskStrategies", "OnParentAbortAllSubTasksEnd");
+ handler.executeWorkItem(workItem, manager);
+
+
+ Thread.sleep(500);
+
+ //Test if the task is succesfully created
+ BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> tasks = responseHandler.getResults();
+ assertEquals(1, tasks.size());
+ TaskSummary task = tasks.get(0);
+ assertEquals("TaskNameParent", task.getName());
+ assertEquals(10, task.getPriority());
+ assertEquals("CommentParent", task.getDescription());
+ assertEquals(Status.Reserved, task.getStatus());
+ assertEquals("Darth Vader", task.getActualOwner().getId());
+
+ //Create the child task
+ workItem = new WorkItemImpl();
+ workItem.setName("Human Task");
+ workItem.setParameter("TaskName", "TaskNameChild1");
+ workItem.setParameter("Comment", "CommentChild1");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ workItem.setParameter("ParentId", task.getId());
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ //Create the child task2
+ workItem = new WorkItemImpl();
+ workItem.setName("Human Task2");
+ workItem.setParameter("TaskName", "TaskNameChild2");
+ workItem.setParameter("Comment", "CommentChild2");
+ workItem.setParameter("Priority", "10");
+ workItem.setParameter("ActorId", "Darth Vader");
+ workItem.setParameter("ParentId", task.getId());
+ handler.executeWorkItem(workItem, manager);
+
+ Thread.sleep(500);
+
+ //Start the parent task
+ System.out.println("Starting task " + task.getId());
+ BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(task.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started task " + task.getId());
+
+ //Check if the parent task is InProgress
+ BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(task.getId(), getTaskResponseHandler);
+ Task parentTask = getTaskResponseHandler.getTask();
+ assertEquals(Status.InProgress, parentTask.getTaskData().getStatus());
+ assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
+
+ //Get all the subtask created for the parent task based on the potential owner
+ responseHandler = new BlockingTaskSummaryResponseHandler();
+ client.getSubTasksAssignedAsPotentialOwner(parentTask.getId(), "Darth Vader", "en-UK", responseHandler);
+ List<TaskSummary> subTasks = responseHandler.getResults();
+ assertEquals(2, subTasks.size());
+ TaskSummary subTaskSummary1 = subTasks.get(0);
+ TaskSummary subTaskSummary2 = subTasks.get(1);
+ assertNotNull(subTaskSummary1);
+ assertNotNull(subTaskSummary2);
+
+ //Starting the sub task 1
+ System.out.println("Starting sub task " + subTaskSummary1.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(subTaskSummary1.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started sub task " + subTaskSummary1.getId());
+
+ //Starting the sub task 2
+ System.out.println("Starting sub task " + subTaskSummary2.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.start(subTaskSummary2.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Started sub task " + subTaskSummary2.getId());
+
+ //Check if the child task 1 is InProgress
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTaskSummary1.getId(), getTaskResponseHandler);
+ Task subTask1 = getTaskResponseHandler.getTask();
+ assertEquals(Status.InProgress, subTask1.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+ //Check if the child task 2 is InProgress
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTaskSummary2.getId(), getTaskResponseHandler);
+ Task subTask2 = getTaskResponseHandler.getTask();
+ assertEquals(Status.InProgress, subTask2.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+ // Complete the parent task
+ System.out.println("Completing parent task " + parentTask.getId());
+ operationResponseHandler = new BlockingTaskOperationResponseHandler();
+ client.skip(parentTask.getId(), "Darth Vader", operationResponseHandler);
+ operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+ System.out.println("Completed parent task " + parentTask.getId());
+
+ //Check if the child task 1 is Completed
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTaskSummary1.getId(), getTaskResponseHandler);
+ subTask1 = getTaskResponseHandler.getTask();
+ assertEquals(Status.Completed, subTask1.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+ //Check if the child task 2 is Completed
+ getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+ client.getTask(subTaskSummary2.getId(), getTaskResponseHandler);
+ subTask2 = getTaskResponseHandler.getTask();
+ assertEquals(Status.Completed, subTask2.getTaskData().getStatus());
+ assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+ assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+ }
+
+ private static class TestWorkItemManager implements org.drools.process.instance.WorkItemManager {
+
+ private volatile boolean completed;
+ private volatile boolean aborted;
+ private volatile Map<String, Object> results;
+
+ public synchronized boolean waitTillCompleted(long time) {
+ if (!isCompleted()) {
+ try {
+ wait(time);
+ } catch (InterruptedException e) {
+ // swallow and return state of completed
+ }
+ }
+
+ return isCompleted();
+ }
+
+ public synchronized boolean waitTillAborted(long time) {
+ if (!isAborted()) {
+ try {
+ wait(time);
+ } catch (InterruptedException e) {
+ // swallow and return state of aborted
+ }
+ }
+
+ return isAborted();
+ }
+
+ public void abortWorkItem(long id) {
+ setAborted(true);
+ }
+
+ public synchronized boolean isAborted() {
+ return aborted;
+ }
+
+ private synchronized void setAborted(boolean aborted) {
+ this.aborted = aborted;
+ notifyAll();
+ }
+
+ public void completeWorkItem(long id, Map<String, Object> results) {
+ this.results = results;
+ setCompleted(true);
+ }
+
+ private synchronized void setCompleted(boolean completed) {
+ this.completed = completed;
+ notifyAll();
+ }
+
+ public synchronized boolean isCompleted() {
+ return completed;
+ }
+
+ public WorkItem getWorkItem(long id) {
+ return null;
+ }
+
+ public Set<WorkItem> getWorkItems() {
+ return null;
+ }
+
+ public Map<String, Object> getResults() {
+ return results;
+ }
+
+ public void internalAbortWorkItem(long id) {
+ }
+
+ public void internalAddWorkItem(WorkItem workItem) {
+ }
+
+ public void internalExecuteWorkItem(WorkItem workItem) {
+ }
+
+ public void registerWorkItemHandler(String workItemName, WorkItemHandler handler) {
+ }
+
+ }
+
+ private static TestWorkItemManager manager =
+ new CommandBasedWSHumanTaskHandlerTest.TestWorkItemManager();
+
+ public static class TestWorkItemManagerFactory implements WorkItemManagerFactory {
+
+ public org.drools.process.instance.WorkItemManager createWorkItemManager(WorkingMemory workingMemory) {
+ return (org.drools.process.instance.WorkItemManager)
+ CommandBasedWSHumanTaskHandlerTest.manager;
+ }
+
+ }
+
+}
More information about the jboss-svn-commits
mailing list