Example
A practical example of this could be when a plan has to be validated by a certain number of Managers before being carried out.
We’ve shown this example in a  new video tutorial, now available in the online BonitaSoft Documentation.

How validation works
Each of the Managers will validate the plan in turn, by clicking on a submit button in a form displayed in Bonita User Experience.
When all the Managers (5 in the case of the video tutorial) have validated the plan, the maximum number of loops has been reached.
The 5th and last validation will end the loop, terminate the task and finish the validation of the plan.

Configure the task
Take a look at our video tutorial, How to loop a task or a call activity, where the above example is illustrated.
It shows how to configure a loop on a human task using a Boolean variable (True/false variable).
Simply set up a Boolean variable on a pool first, see Define a boolean variable, then apply the Boolean variable to a task. You can  set a maximum number of loops for the task.

More tutorial videos are available in the BonitaSoft Documentation video library.

Have fun with Bonita!

The Documentation team has just finished updating tutorials and videos explaining the collaboration features in the Bonita Open Solution Subscription Pack.

The includes a repository management feature which allows processes and artifacts to be made accessible, to be synchronized and edited in real time on a shared SVN server.

Special features such as automatic synchronizing, locking processes in use or reverting to previous versions, are quick and easy to use.

All you need is a SVN repository to be set up and configured beforehand, and an internet connection.  All features are accessible from the Repository menu in Bonita Studio.

Design collaboration features

A series of videos briefly and concisely explains the different functions which are very useful in teamwork.

Check them out in the BonitaSoft documentation video library.

For example, by defining a “test context” and a “production context” and associating different variables to each context, there is no need to change variable values in connectors, forms, or other places where variables necessarily differ in different environments.

A context is a set of key-value pairings. Context keys (which will be replaced by a predefined value) can be used as input in most text variables.

When a process is associated with a context and then run, the context keys are replaced by the associated values defined for that context.

The online BonitaSoft documentation system includes both open source and Subscription Pack features, so we’ve added a new video tutorial in the online BonitaSoft documentation system that shows how to define contexts and associate a key-value pair with each one.  (Note that videos are found at the end of a feature documentation page.)

There’s also a video tutorial that shows an example of how to use contexts in the configuration of an email connector.

Is there a video tutorial you’d like to see? Let us know via reply to this post.

This should make it a bit easier to find the bit of information you need as you configure simulation.

You can use simulation in Bonita Open Solution to evaluate the way a process runs in multiple iterations, under different resource availabilities and different load profiles.

A simulation runs a specified number of iterations over a specified period of time, using either simulated data or assigned probabilities, and the cumulated result of all iterations is shown in a report.

At the process level, you’ll need to define resources needed needed at various steps in the process.

You can choose to define simulation parameters on individual tasks (e.g., data to fill variables, resources needed to complete a task, and more) and transitions (e.g., conditions using simulation variables, or probabilities that the process will take one path or another.)

And again at the process level, define a load profile which will be used to characterize the iterations of the process to be run in the simulation.

Running a simulation produces and exports a report which details what happened at the process and task level in the simulation.

Inside the documentation, there is a how-to tutorial for each of the simulation parameters that you might want to define (see below). There is also a new video available, Overview of Simulation Feature (thanks to Frederic Bouquet), that shows where to find the various places to configure simulation parameters and characteristics.

Overview of Simulation Feature is also available from the video library:

BOS 5.6 includes an example process called Delivery-Simulation, which illustrates how to configure a very simple simulation, using two processes with the same steps but slightly different flows. Try running both to see and compare the simulation reports.  You can find this example from the Welcome page of Bonita Studio:

More improvements are on the way.  Stay tuned!

Default Eclipse preferences TreeView

If you are not familiar with Eclipse preferences, you can have an in-depth look of how preferences works in this article by Lars Vogel.

First remove all the preferences you don’t need in your RCP. Some of these were brought in by 3rd party plug-ins such as JDT.

You’ll have to override the postWindowOpen() method of the WorkbenchWindowAdvisor application:

This gives you better visibility of your RCP preferences.

Next the idea is to build a new UI for this dialog, keeping the Eclipse PreferencePage mechanism. To show a quick preview of the result I made a mockup of this dialog using the WindowBuilder tool. With this tool, you can draw your UI very easily, though a background knowledge of SWT helps a lot.

WindowBuilder overview

Using mockups is a good practice to test your user interface and collect your team’s feedback. Here we clearly want to have an “OS X style” for our preferences. Once the mockup shows the interface the way you want it, you can  go ahead with your implementation using the code generated by WindowBuilder. The generated code is pretty clean and easy to modify.

Eclipse preference API

Next the goal is to integrate the PreferencePages to the new Dialog. In Eclipse you can define a preference page using an extension point. Thus a PreferencePage is bound to an ID. To find them you can use the PreferenceManager like this :

Then, once you retrieve the IPreferenceNode, you can create the page in a Composite:

In addition, I found it useful to reuse the Eclipse keyword contributions linked to those pages. To achieve this, I implemented my own listener inspired from the one in the default preference tree filter.

Here is a quick preview of the result:

I’ll be sharing more cool Eclipse stuff soon!

Here’s a short video that will introduce you to the built-in reporting features that Bonita Open Solution provides.

You’ll see the default user dashboard and how to configure it to include some basic reports such as: “Steps per priority”, “Average step pending time” and “Number of cases started”.

Extract valuable information from your application in a few clicks!

You can use this feature to monitor runtime issues – solving them leads to better performance management, for instance, detect tasks that are exceedingly time-consuming and perhaps improve the process design to get rid of the bottlenecks.

Also, reporting can provide additional information needed when performing load balancing. For example, by detecting a variation in the volume of cases started; you may allocate more or less resources to it (be it servers or human operators).

There are 3 different display views of the widget palette.  Right-click on the palette to see the options.  Use “customize” to select which widgets to hide from your custom palette (or to show them again).

If you want the maximum amount of space for your form grid, hide the palette completely.

This video shows how!

(For maximum whiteboard space, you can hide the Overview and Details panels too.)

What is the second thing you see when you start an Eclipse RCP product? The intro page. This page is the first interaction that the user has with your product. It deserves real effort to ensure that your users feel comfortable when opening the product. Also, you can leverage this page to add dynamic content, that can be used, for example, for direct communication between your company and your users. Then it can become a tool for both user-friendliness and marketing, with a relatively low effort. It’s worth it!

In this post we will describe how we leverage the intro page extensibility and API to develop a more ergonomic and marketing-friendly intro page. Everything you will read here can be found or taken directly from the Eclipse Help contents, but I’ll try to explain it more practically.

The intro page can also be defined using SWT, but in this post we will focus only on using (X)HTML to define intro pages, since it is more appropriate to the use case of “out-sourcing” the intro page to design or marketing.

What can you expect from your (X)HTML intro page

While using (X)HTML, you can also use JavaScript. Although most Java developers are not fond of JavaScript, we must admit that it is a very powerful language when it comes to playing with the content of a web page. JavaScript makes your page dynamic, and is something that most web-oriented people can tweak to create nice effects on your page (feedback, images in a carousel, powerful widgets…).

You also can expect 2-way communication between your intro page and your application:

That means that you’ll be able to trigger actions in your application from your intro page, for instance to create a new file, or open a wizard, or anything your application can do.

And you can also populate your page with data coming from your application. A use-case we chose for Bonita Studio is to show the “Recently opened” files on the intro page. This requires the page to look at the files in the workspace and show the ones last modified. We also use it to show the content of some RSS streams.

With all this stuff, you can create a highly dynamic page well integrated into your application! Here is a video of what we’ve got for the current release of Bonita Open Solution – 5.4.1:

Here is the recipe:

Define an intro for your product

This step is just about overriding the default Eclipse intro page for your product and defining contents for the intro. Since we want the intro page to be easily maintained by the design and marketing teams, we chose to use XHTML to define it. XHTML is much more accessible than Java and SWT for them . In this post, we will only focus only on using HTML or XHTML, skipping SWT.

In one of your plugin.xml files (for instance in the plugin that contains your html page), add:

This means that for org.bonitasoft.studio.product, you’ll show the intro as defined in content/introContent.xml, starting from the page with id root, in html mode (you can use swt if you want).

As you can see, this extension binds an introContent.xml file to your product. Now, add it to your bundle, along with the html file of the page. Note that the page that will be displayed as intro is the one with id root:

Intro plugin tree, and introContent.xml

Contents of the file

XHTML or HTML

In your introContent.xml, you have 2 ways to reference the file you want to show, depending on the attribute you use to locate the page in the page element of introContent.xml:

url=”myPage.html”

With a url, you will be able to show any HTML or JavaScript you want. Everything will be simply displayed in a web browser. You’ll be able to call some of your application code by clicking links. (See “Links to actions in your application”), however you won’t be able to add contents to that page at runtime depending on your application state. This method is preferable when you don’t need to fill the page with data from your application, since it provides full support for JavaScript.

content=”myPage.html”

The content of your HTML must be valid XHTML. Thus your file can have the same content as any HTML file, except that it has to start with the XHTML header (<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”> <html xmlns=”http://www.w3.org/1999/xhtml”>) and all your tags must be closed. If you are generally using Java, you probably often edit XML, then nothing shocking here. (By the way, I do not understand why XHTML is not the de facto standard nowadays…)

Your file must conform to the W3C specification. The W3C validator is very helpful while debugging it.

Since your XHTML intro page will be displayed in the internal Browser of Eclipse, there is obviously support for JavaScript! Except if you use contentProviders in your page, you have to use the content XML attribute in your introConent.xml instead of the url attribute, and there is currently a limitation for JavaScript support that is reported on bug 332416, that makes impossible to execute JS code that contains “<” or “&”, and possibly others.

However, only the content mode allows you to use contentProviders.

Links to actions in your application

This is well described in the Eclipse help, and is pretty easy to set up. For each action you want to call from your intro page, implement your action as a class that extends IIntroAction. Then, whenever the internal intro web browser reaches the URL http://org.eclipse.ui.intro/runAction?pluginId=org.bonitasoft.studio.intro&amp;class=org.bonitasoft.studio.intro.actions.NewProcessAction, the NewProcessAction will be executed.

Then simply add links from your HTML page to your actions:

Content depending on your application state (contentProvider)

This only works when you reference your page using the content attribute, in your introConfig.xml. The official documentation is here.

The key is to create a class that implements IIntroXHTMLContentProvider. With XHTML, it is generally more comfortable to implement the createContent(String id, Element parent) method. Here is the content provider we use for internationalization of messages in our intro page:

And then, we can include a message from our NLS messages class in the XHTML page using:

Examples

All this stuff, and much more, can be found in our SVN repo. You’ll hopefully find some clues and ideas if you’re stuck

Is this tip useful?