Circumstances challenge you, but you are who make the difference.

After blogging for a while to gather  enough feedback for my master studies in BPM,  I have my own conclusions. Now I am able to write my research paper and know enough too about how some open source business works(any other thing is an add).

I want to thank Intalio people for their open source Tempo project, along their other shareware tools.  I am also grateful to Sencha for its Ext js project, I haven’t seen before a better documented and full of samples jscript project.

Thank you also to every people who have interested in reading and commenting this blog, no matter their purposes I have learned from all.

Things change in time, who knows?.

 Solomon said: “To every thing there is a season, and a time to every purpose under the heaven“

I’ll be busy for a time writing things down. See you soon!

Best Regards.

It is very interesting to receive anonymous comments like the title of this post. Thank you very much for the alert.

For unaware readers, I think all people interested in this blog content should read Intalio Community Edition Eclipse Based License along with Sencha (Exjs) Open GPL license.

About me, I am not distributing anything which is not compliant with above mentioned licenses.

I really like Intalio works and Extjs works. Ethically I am trying to avoid anything that might interfere their business but this blog might serve as a demo of what great things you can accomplish with both.

For a discussion on this matter please visit these sites and search google. About  current blog I would be glad to receive feed back on techs.

Enjoy!!!

Best Regards.

First Request: Pagination out of order.

Solution: I decided to go back to old Action, TasksCollector, TaskHolder classes from tempo ui-fw. As I explained in other post I use JsonUpdate Servlet before because I started inspired in the portlet view. Now as this Open InfoManager is just another face of Tempo UI-FW the best choice is to do things as they planned.

Key points of change for back-end:

1. org.intalio.tempo.uiframework.actions.TaskCollector class

ParameterMap -> Substitution of page parameters by start and limit.

Ext js Paging Bar makes use of start and limit for pagination.

Method collectTasks -> meaning of taskPerPage is now limit, page corresponds   to start.

Add two lines for task type PATask ->

hasAttachments= (myTask.getAttachments().size()>0);
tasksHolder.add(new TaskHolder<Task>(task, URIUtils.getResolvedTaskURLAsString(_request, fmanager, task, token, user),hasAttachments));

That was in order to have a new attribute for the view model hasAttachments which is used by UI implementation.

Add getter -> getTotalRows

In order to feed back the view with the total amount of rows available.

2. org.intalio.tempo.uiframework.model.TaskHolder

Member Field addition -> hasAttachments along set and get.

Constructor overload -> to include hasAttachments for PATasks.

3. org.intalio.tempo.uiframework.actions.TasksAction

Add another param to model -> totalRows

model.put(“totalRows”, collector.getTotalRows());

Key points of change to updates.jsp view:

A key design element for Open InfoManager is to use the majority of views for data formating and exchange only.

updates.jsp view was very suitable to use without affecting the overall behavior of Tempo UI-FW and ease reusability.

I just substitute table buildings for json array, objects and properties. The only thing which is exchange here is Data not UI building blocks.

ie: for PATasks

<json:array name=”tasks” var=”taskHolder” items=”${tasks}”>
<json:object>
<json:property name=”taskId” value=”${taskHolder.task.ID}” />
<json:property name=”taskUrl” value=”${taskHolder.formManagerURL}” />
<json:property name=”description” value=”${taskHolder.task.description}” />
<json:property name=”creationDate” >
<fmt:formatDate pattern=”yyyy-MM-dd hh:mm:ss”  value=”${taskHolder.task.creationDate}” />
</json:property>
<json:property name=”deadline” >
<fmt:formatDate pattern=”yyyy-MM-dd hh:mm:ss” value=”${taskHolder.task.deadline}” />
</json:property>
<json:property name=”state” value=”${taskHolder.task.state}” />
<c:choose>
<c:when test=”${taskHolder.task.priority != ’0′}”>
<json:property name=”priority” value=”${taskHolder.task.priority}” />
</c:when>
</c:choose>
<json:property name=”hasattachments” value=”${taskHolder.hasAttachments}” />
</json:object>
</json:array>

Key points of change to UI presentation:

1. taskboard.DataLayer.js

Change proxy instantiation for each task type -> now type and update params are added to url , ie:

this.proxy = new Ext.data.HttpProxy({url:updateUrl+”&type=PIPATask&update=true”});

2. tasks.jsp view

Change updateUrl definition -> now it points to tasks.htm as old good UI-FW does.

var updateUrl  =”tasks.htm”+”?user=”+currentUser+”&token=”+participantToken;

Change serverDateFormat Format definition -> Now it matches with expected by client code.

var serverDateFormat = ‘Y-m-d H:i:s’;

Well, that’s enough for a post, next one will deal with Search Solution.

Best Regards.

These days reading the Bruce Silver book “BPMN Method and Style” I tried to test Intalio Designer capabilities for handling the following scenario:

A client post a form to initiate a process, if the process is not completed after a period of time, the former client must be interrogated if she wish to wait for other period of time or wants to cancel the process. If she decides to wait she must give the period of time in order to set it. If she cancels then all parallel subprocesses are canceled and process finishes.

Following Bruce Silver (you can check picture 10-31 of his book), a BPMN 2.0 Non Interrupting Event Subprocess is a suitable solution for establishing a handler for  timer events  in order to take actions if your subprocess haven’t finished in the desired amount of time. Bruce Silver says also that Terminate End Event must be used to finish all parallel flows and then go on with the normal execution of the rest of the process until its completion .

My first concern was that Intalio Designer lacks BPMN 2.0 Event Subprocesses, so I had to try with a “workaround for non-interrupting event with short-running handler” (See Figure 10-30 . BPMN 1.x workaround for non-interrupting event with short-running handler).

Here it is my test Process

Test Results:

1. Subprocess with the timer handler behaves as expected: Submits the creation  of the human task and waits for its response. If the user cancels then rises an exception which is caught by a boundary exception handler and a terminated end event is reached. If the user give more time the timer is reset for the period amount supplied.

2. If the happy path executes before the given time, all parallel subprocesses are abandoned.

3. In both cases the process completes with a TERMINATED end state.

4. Non concluded human tasks were not retired from the Users’ Task Lists.

I am wondering if there is a better way to model this scenario?,

also if the TERMINATED end state of the process is OK or should  the runner engine be fixed to COMPLETED?,

and finally if tasks should be  explicitly retired using invocations to Task Manager Service or there is a property(ies) to set in order to get the engine get rid of the non finished human tasks? (I would like that Intalio Designer (or whatever designer) generates the needed code for this, is it not zero code or less effort or it maybe zero code too).

Best Regards.

What do you think if you have some users having their task list embeded in their custom daily app which redirect the task execution links to a proper app  complex ui view? Once the user is done, she hits a complete task button to inform the app to bring the scenario result to the owner process apart from the old custom application’s behaviour.

Advantages (from user’s perspective):

• Transparent workflow integration for the business user. She just use the same old application.
• Application task’s user scenarios driven by external workflow process execution.
• Complex business tasks which can not be done using a simple form can be done using the proper application ui devices.
• … do you see another?

Dissaventages ( or difficulties from IT perspective):

• Task list integration.
• Necessity to develop Application components for workflow integration.
• Filter tasks in order to present just those available to the current application.
• There is no current Designer tooling support so it is needed a workaround to change task’s execution links.
• … many more you are thinking about … for instance?

Here you can see part of a complex task which involve preparing a product list for a contract attachment. Product Selection from an enterprise portfolio arranged by categories.

Best Regards.

I have received many complains about the veracity of the last two posts.  Where is the functionality? they say …

To get it you have to download the delegation capabilities and merge with the current open infomanager application copy that you already have.

The first link shows only 4 downloads up to date, the second 86.

Open InfoManager is not yet a stand alone app but a Wrapper to tempo UI-FW, it only shows the posibility to customize (better said: completely change) the look and feel of the tempo  task manager user interface along with examples of how you can use the current service layer framework to accomplish task management operations from the back-end instead of invoking them from the client UI as tempo UI-FW actually does …. although they go through the proxy.jsp.

You can make it a stand alone application with some minor changes and have the Task List Manager  into it as a module along many other modules that you develop as this blog shows in other posts. Having the Task List Manager as an independent Module would allow you to serve it also as a portlet to be integrated with a portal.

Best Regards.

Whenever the reassigment is done through the Escalate TMP operation task’s state always is set to READY due to the fact that the BPEL copy ever do it with a READY constant, I think that this is following standard documents on Human Workflow.

I just added the <role> parameter to the escalate.ftl template and modified the escalate method of the TaskActionHelper class.Now the delegate method of my TaskActionHelper class invokes the escalate one.

If you want to change the assigment of a READY state for a task on escalation you will need to modify the TMP BPEL end point invocation to include the state in the escalateRequest, then provide a business logic to guide Task States assigments before invoking Escalation.

For those who want to escalate (in the extjs ui future: delegate) a READY task you can change the line 145 of the file openinfomanager/modules/taskboard/taskboard.TaskController.js like this:

actionArr=['execute','claim','delegate'];

in order to make available to users Delegation of New Tasks.

ESCALATE through TMP is the right way for a reassignment. Remember that TMP is the process in charge of Task life cycle.

Best Regards.

For all those who miss reassignment and searching capabilities in the extjs Task List Manager Interface (the taskboard module of Open InfoManager) I decided finally to provide them to the style of Tempo UI-FW. (You must know that I’m developing this project in my free time).

Now you can reassign your claimed tasks tho other coworkers by their user name or assigned  role. The first will be in Claimed state, the second in Ready State.

Searching is accomplished using the Search bar controls the Search Combo and the  TwinTriggerField, when task list is filtered the refreshing process stops until the filter is cleared.

Keeping the UI unaware of the backend implementation.

As I want to keep this interface unaware of the framework inner workings, all the webservice invocation occurs at server side in:

org.openinfomanager.taskservices.TaskActionHelper (abstracts operations on tasks but getAvailableTasks, this borrow a lot of TMS client test code from Tempo).

org.intalio.tempo.uiframework.service.JsonUpdate (this servlet along the Liferay portlet inspired me to develop the extjs based ui, it gets the list of task for the current user).

TaskActionHelper is invoked by a Servlet named RestTaskService who is a very good candidate for a Spring Multiaction Controller. (Maybe it would be best to take the tempo ui-fw SecuredController class and convert it to the desired Multiaction Controller).

All this is in the JsonNew eclipse project. To avoid using all the tempo code I just make a new eclipse project and incorporate the needed libraries from the same ui-fw compilation along its classes and some other as freemarker. Beware that TMS client needs tempo-tms.. jars above version 6.0.4.004

But Far …

Desired delegation implementation must go through a delegation process invocation … Now it just invoke the reassign operation on TMS service which could be change to scalate operation invocation on TMP (you might check tempo test cases for differences). You can test both approaches and give me your feedback.

Pushing the project Forward.

For all those who liked this interface contribution, I encourage you to join to this effort, maybe your are not proficient as programmer or process designer, maybe you are. If you are, you can contribute with code or just opinions on code, you may contribute a simple delegation process. If you are just an user you may feedback your user experience in usability. If you are a tempo project contributor you can help me clarifying concepts or giving a constructive criticism.

You can also comment on this on Intalio Forums.

English Intalio Forum posts:

A new UI experience for community users.

New UI experience for Community users

Spanish Intalio Forum post:

Interfaz basada en Extjs para tempo.

All comments are welcome!!!

You can download new features from here.

Inside you will find the jsonnew project (you must correct jar links) and openinfomanager modifications (just overwrite your openinfomanager copy).

Best Regards.

Well, to the point …

Closing a Finished Task’s Tab and refreshing the current Task List  View is a requirement that this ui doesn’t fulfill but you will see how easy is it to achive.

Whenever a task is finished the response page’s body fires the event onload with the statement parent.hideWindow so we can use it in order to close the current tab and refresh the Task List View.

First add this code to modules/taskboard/taskboard.TaskController.js file before the last } :

this.forceRefresh= function(){
taskGrid.loadData();clearActions();
refreshDelayed.delay(refreshData.interval);
}

Then open the file resources/openinfomanager.main.js and do the following modifications:

1. Before the this.run method add

this.taskController = new Object();

2. Replace inside the this.run method:

var taskController = new TaskController();
var taskDeskPanel = taskController.initTaskBoard();

for

this.taskController = new TaskController();
var taskDeskPanel = this.taskController.initTaskBoard();

3. Add as last statement of the this.run method this:

Ext.applyIf(window,{hideWindow:openInfomanager.closeTabPanel});

4. Finally add this method after the this.loadObject final method:

this.closeTabPanel=function(){
var activeTab=this.mainPanel.getActiveTab();
if(activeTab.closable){
this.mainPanel.remove(activeTab);
this.taskController.forceRefresh();
}
}

That’s all.

Clear your navigator cache and reload /openinfomanager.

The whole taskboard changed this way is here. It is along web-inf/jsp/task.jsp and resources/onpeninfomanager.main.js.

task.jsp has some minor corrections.

In order to get this working with Intalio Ajax Forms it is necessary to replace the string document.location.href = “/ui-fw/script/empty.jsp” in deployed processes Packages.js for parent.hideWindow() .

Waiting for your feed back …

Best Regards.

A common request for Task List Managers  is to show or hide some properties.

The available properties are in the json response of the servlet class at the Server side.

org.intalio.tempo.uiframework.service.JsonUpdate.java

ie: jtask.put(“creationDate”, dateFormatter.format(paTask.getCreationDate()));

where jtask is a json object: JSONObject jtask = new JSONObject();

Note:  It would be better to separate Task’s definitions retrieved from TMS service (the model) from the final view rendering for each task list entry (the view). This task is nice handled by Spring MVC. I have already used JSON tags in other projects successfully.

At the client side: The base model to show a task item at the grid is known in Ext js as Column Model, it defines the Title (header) of the column, its width, the record source binding  named dataIndex, and some other properties as if the column is sortable or not, etc.

You can find this Column Model Definitions for PATasks, PIPATasks and notification in the file modules/taskboard/taskboard.ViewModel.js

For instance this is the column model definition of processes (PIPA) at line 171.

var cmProcesses = new Ext.grid.ColumnModel([

...

{
header:  gridHeaderDescription,
width:400,
sortable: true,
dataIndex: 'description',
id:'task-title'
},

...

]);

The client code parses server responses using the Record definitions found at the file taskboard.DataLayer.js

ie:

• TaskRecord = Ext.data.Record.create([
• {name: 'id', type:'string',mapping:'taskId'},
• {name: 'description', type:'string'},
• {name: 'priority', type:'int'},
• {name: 'taskurl', type:'string',mapping:'taskUrl'},//Thu Jan 14 13:52:28 CST 2010 === serverDateFormat
• {name: 'creationdate', type:'date', dateFormat: serverDateFormat,mapping:'creationDate'},//dateFormat: 'Y-m-d H:i:s'
• {name: 'deadline', type:'date', dateFormat: serverDateFormat},//dateFormat: 'Y-m-d H:i:s'
• {name: 'state', type:'string'},
• {name: 'hasattachments', type:'boolean'}
• ]);

Then you have to ensure that your server class is sending to the client all the task’s properties you want and adjust your Record definitions to include all received properties and finally enabled the grid to show them using the appropriate Column Model definition.

Server side:

1. org.intalio.tempo.uiframework.service.JsonUpdate.java

Client side:

1. taskboard.DataLayer.js //For Record definitions
2. taskboard.ViewModel.js//For Column Model Definitions

Best Regards.