Here is an example that shows how to register and use custom workitems in the JBPM5 console using example described in http://community.jboss.org/people/bpmn2user/blog/2011/02/21/jbpm5-example-for-forms-with-variables.

Diduch Cordova has modified the bpmn file from the above example to include a custom notification workitem (http://community.jboss.org/people/bpmn2user/blog/2011/02/21/jbpm5-example-for-forms-with-variables#/?page=2) . A custom WorkItem for notification ('Notify Complete) is added at the end as shown below.

Following is the corresponding notification WorkItemHaldler class.

More details about creating  WorkItem can be found here http://community.jboss.org/people/bpmn2user/blog/2011/03/28/jbpm5--work-itemdomain-specific-process-hello-process-example.

Make sure the corresponding taskName (i.e, Email) for the WorkItem in the bpmn file is bound to Notification class in the workhandlers configuration file (CustomWorkItemHandlers.conf)

Deployment to an appsersever (e.g., JBoss or Tomcat)

1.) Copy the configuration file (CustomWorkItemHandlers.conf) to gwt-console-server's META-INF directory

e.g. jbpm-installer/boss-5.1.0.GA/server/default/deploy/jbpm-gwt-console-server.war/WEB-INF/classes/META-INF/CustomWorkItemHandlers.conf

2.) Copy the Notification class to the gwt-console-server's CLASSPATH.

e.g., Copy the Notification jar file into gwt-console-server war file  ( ..gwt-console-server\WEB-INF\lib)

or Copy the Notification jar and the dependant jar files into appserver's lib direcory (JBOSS_HOME\server\default\lib for JBOSS or TOMCAT_HOME\lib for TOMCAT)

3.) Copy the bpmn file to the directory where the other bpmn files are located  (specified using the parameter -Djbpm.console.directory).

After running the example successfully (i.e, after the second approval from 'john'), following log message can be seen.

This example shows the persistence feature of JBPM5 using Hello Proces example (http://community.jboss.org/people/bpmn2user/blog/2011/02/27/helloprocess-example-using-jbpm5-eclipse-plug-in).

JBPM5 database persistence involves following categories:

1.) Process persistence: This involves persisting runtime state that represents current execution state in a specific context. The runtime state contains the minimal runtime state that is required to continue execution at a later time. This allows restoring the state of execution of all the running processes in the event of a failure.

2.) Human task persistence: Task management component, which is treated as a separate component, can persist all the task information (e.g, user, assignment etc) into database.

3.) History or Auditlog persistence: All the audit log information(e.g., ProcessInstanceLog, NodeInstanceLog etc)can stored in database for reporting purposes.

How to install and run this example?

Start with the setup as shown in http://community.jboss.org/people/bpmn2user/blog/2011/02/27/helloprocess-example-using-jbpm5-eclipse-plug-in.

This example needs two jar files, one for database (e.g, h2.jar for H2, oracle-11.1.0.6.jar for Oracel etc) and another one Bitronix transaction manager (btm-1.3.3.jar). Add theste two jar files into Eclipse's project classpath.

This examples has a bpmn file (HelloProcess.bpmn), a process test program that starts the process(ProcessTest.java), a standalone task server (TaskServer.java), two persistence configuration files (orm.xml and persistence.xml ) and a Bitronix JNDI file ( jndi.properties) .

The persistence configuration files need to be included in META-INF folder as shown below. Please refer to JPA/Hibernate documents to know more about persistence configuration details.

After running the example successfully, tables for process, human task etc are created as shown below.

The task can be approved using the Eclipse  plugin. Select the plugin using Windows->ShowView->DRools Task->Human Task View.

The logging for Hibernate persistence is set to true to display the generated SQL queries as shown below.

Process logs from ProcessTest.java

Taskserver logs from TaskServer.java

Here are some important points to note:

Process persistence: It uses JPA/Hibernate as default to persist the runtime state. Create the knowledge session as shown below .

/*

     * Create EntityManagerFactory and register it in the environment

     * Create the knowledge session that uses JPA to persists runtime state

     */

    private static StatefulKnowledgeSession createKnowledgeSession(KnowledgeBase kbase) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory( "org.jbpm.persistence.jpa" );

        Environment env = KnowledgeBaseFactory.newEnvironment();

        env.set( EnvironmentName.ENTITY_MANAGER_FACTORY, emf );

        env.set( EnvironmentName.TRANSACTION_MANAGER, TransactionManagerServices.getTransactionManager() );

        env.set( EnvironmentName.GLOBALS, new MapGlobalResolver() );

        Properties properties = new Properties();

        properties.put("drools.processInstanceManagerFactory", "org.jbpm.persistence.processinstance.JPAProcessInstanceManagerFactory");

        properties.put("drools.processSignalManagerFactory", "org.jbpm.persistence.processinstance.JPASignalManagerFactory");

        KnowledgeSessionConfiguration config = KnowledgeBaseFactory.newKnowledgeSessionConfiguration(properties);

        return JPAKnowledgeService.newStatefulKnowledgeSession(kbase, config, env);

    }

Persistence configuration file (persistence.xml) includes the classes that are required for process persistence.

Human task persistence has another independent persistencecomponent which is responsible for persisting task related activities (e.g.,task assignments, comments, content, notification etc)

The human task management component is an independent service which has communication with the process engine. This is started using 'TaskServer.java' class.

            EntityManagerFactory emfTask = Persistence.createEntityManagerFactory( "org.jbpm.task" );

            TaskService taskService = new TaskService(emfTask, SystemEventListenerFactory.getSystemEventListener());

           /* Start Mina server for HT*/

            MinaTaskServer server = new MinaTaskServer(taskService);

            Thread thread = new Thread(server);

            thread.start();

It is also required to have the corresponding human task classes in the Hibernate persistence configuration file (persistence.xml) as shown below.

History or Auditlog persistence: The persistence configuration file should also include the classes that correspond to audit logs.

Excel decision tables are widely used to represent rule logic in a compact format.

This format is particularly popular as non-technical business users can read, edit and maintain the conditional logic in Excel spreadsheets.

This example shows how to use an Excel decision table rules inside a process.

The ‘Rule Task’ components can use the rules defined in a drl file, Excel decision table or the rules defined in BRMS (Guvnor).

An example to use the rules defined in drl file is shown in http://community.jboss.org/people/bpmn2user/blog/2011/03/07/jbpm5--ruletask-example.

This example shows how to run the same example using Excel decision table.

Please refer to Drools documentation (http://downloads.jboss.com/drools/docs/5.1.1.34858.FINAL/drools-expert/html/ch05.html#d0e5683) to know about authoring Drools decision tables.

Here are rules represented in Excel decision table.

There are three rules in the following decision table. For example, Rule1 (Row 11) means that if the 'userlocation' is set to ‘NewYorkUser’ and the initial count is less 4, then the ‘loopcondition’ is set to 6.

Following is the main process flow diagram. This example has a loop condition which is determined using the rules shown in the above decision table in the RuleTask 'LoopConditionRules'.

'LoopConditionRules' is a 'Rule Task' component and it needs to have a valid RuleFlowGroup name (e.g.,  EvalLoopcondistion as shown below) and it should match with the 'RULEFLOW-GROUP' name (Column C) of the decision table.

Excel decision table needs to be added to the Knowledgebase as shown below.

private static KnowledgeBase readKnowledgeBase() throws Exception {

        ProcessBuilderFactory

                .setProcessBuilderFactoryService(new ProcessBuilderFactoryServiceImpl());

        ProcessMarshallerFactory

                .setProcessMarshallerFactoryService(new ProcessMarshallerFactoryServiceImpl());

        ProcessRuntimeFactory

                .setProcessRuntimeFactoryService(new ProcessRuntimeFactoryServiceImpl());

        BPMN2ProcessFactory

                .setBPMN2ProcessProvider(new BPMN2ProcessProviderImpl());

        KnowledgeBuilder kbuilder = KnowledgeBuilderFactory

                .newKnowledgeBuilder();

        kbuilder.add(ResourceFactory.newClassPathResource("processRuleslooptest777.bpmn"),

                ResourceType.BPMN2);

        /*

         * Add Excel decision table file

         */

        DecisionTableConfiguration config = KnowledgeBuilderFactory.newDecisionTableConfiguration();

        config.setInputType(DecisionTableInputType.XLS);

        kbuilder.add(ResourceFactory.newClassPathResource("LoopConditionRules.xls"), ResourceType.DTABLE, config);

        return kbuilder.newKnowledgeBase();

    }

How to deploy?

This example has a bpmn file (processRuleslooptest777.bpmn), model file (HelloProcessModel.java), rules file (LoopConditionRules.xls) and a test file (HelloProcessTest.java). It might be easy to start with a HelloProcess project (http://community.jboss.org/people/bpmn2user/blog/2011/02/27/helloprocess-example-using-jbpm5-eclipse-plug-in) and import these files.

Following results can be seen after successfully running the example.

JBPM5 provides 'Multiple Instances' node that can be used to create multiple instances of reusable sub-processes.

Here is a simple example that shows how to send a colection of elements to sub-process nodes and invoke mutiple processes.

The example from the discussion http://community.jboss.org/thread/163105?tstart=0 is considered here to illustrate the usage.

It has a main process (sampleMultiLoopSubprocessTest.bpmn) that invokes multiple sub-processes (multilooptest777.bpmn).

The main process sends a list of parameters (initial count ) to the sub-process.

The sub-process goes through a loop incrementing the value of 'count'. Once the 'count' reaches the 'do until' loop condition value, it will exit the loop.

A list to contain the parameters that need to be sent to sub-processes are populated as shown below (MultiLoopProcessTest.java).

            Map<String, Object> params = new HashMap<String, Object>();

            List<Integer> myList = new ArrayList<Integer>();

            myList.add(process1Count);

            myList.add(process2Count);

            params.put("list", myList);

            ksession.startProcess("com.sample.bpmn.multilooptest",params);

The 'CollectionExpression' is set to 'list' as shown below,

The ProcessID is set to 'multilooptest777' as shown below to bind the sub-process.

How to run this example?

This example has two bpmn files (sampleMultiLoopSubprocessTest.bpmn for main process that invokes multiple processes and multilooptest777.bpmn for sub-process loop) and a test file (LoopSubProcessTest.java). It might be easy to start with a HelloProcess project (http://community.jboss.org/people/bpmn2user/blog/2011/02/27/helloprocess-example-using-jbpm5-eclipse-plug-in) and import these files.

Following results can be seen after successfully running this example.

Here is an example that shows how to invoke a sub-process from a main process.

A simple example shown in the discussion http://community.jboss.org/thread/163105?tstart=0 is considered here.

This example has a main process as shown below. It sends a couple of parameters (count and loopcondition) to the subprocess.

The sub-process goes through a loop incrementing the value of 'count'. Once the 'count' reaches the 'do until' loop condition value, it will exit the loop and return the 'count' value to the main process. The 'loopcondition' can either be set inside this sub-process or can be retrieved from the parent process. In this example, it is set as a paramter in the main process.

How to run this example?

This example has two bpmn files (sampleLoopTest.bpmn for main process and looptest777.bpmn for sub-process loop) and a test file (LoopSubProcessTest.java). It might be easy to start with a HelloProcess project (http://community.jboss.org/people/bpmn2user/blog/2011/02/27/helloprocess-example-using-jbpm5-eclipse-plug-in) and import these files.

Here is the sample test code. The main process 'com.sample.bpmn.looptest'  is started as shown below which inturn invokes the sub-process.

public class LoopSubProcessTest {

   public static final void main(String[] args) {

        try {

            // load up the knowledge base

            KnowledgeBase kbase = readKnowledgeBase();

            StatefulKnowledgeSession ksession = createSession(kbase);

            KnowledgeRuntimeLogger logger = KnowledgeRuntimeLoggerFactory

                    .newFileLogger(ksession, "test");

            // Set the initial count and loopcondition

            Map<String, Object> params = new HashMap<String, Object>();

            params.put("count", 1);

            params.put("loopcondition", 4);

            //start the main process

            ksession.startProcess("com.sample.bpmn.looptest", params);

            logger.close();

        } catch (Throwable t) {

            t.printStackTrace();

        }

    }

It is important to note that both the bpmn files need to be added to the KnowledgeBuilder as shown below.

I

Here are the results you would see after running the test program LoopSubProcessTest.