Monday, January 26, 2015

Oracle Fusion Middleware Partner Community Forum 2015

Hi everyone,

This year Oracle is organizing its Oracle Fusion Middleware Partner Community Forum in Budapest. The event is going to be held on March 3rd and 4th 2015 with hands-on training on March 5th & 6th 2015.

The event is a great opportunity to learn about:
  • SOA Suite 12c & Integration Cloud Service
  • BPM Suite 12c & Process Cloud Service
  • Mobile & Development tools & Mobile Cloud Service
  • WebLogic 12c & Java Cloud & Developer Cloud Service
Oracle will be running the following hands-on bootcamps:
  • Java Cloud Service hands-on
  • Mobile Application Framework hands-on
  • Multichannel enablement of Oracle Applications
  • SOA 12c ICS, adapter & sdk, API management, Stream explorer & BAM
You can register here!

See you all in Budapest!

Monday, January 12, 2015

Using ADF BC Declarative Built-in Rules (Part 8 of 10): Regular Expression validator

The last validator in the entity attribute validator set is the "Regular Expression" validator. The "Regular Expression" validator allows you to validate whether an entity attribute either matches or does not matches a regular expression.

You can either use one of the predefined expressions such as the "Email" regular expression or the "Phone" regular expression to validate whether a specific attribute conforms to a specific pattern.

For example, ensure that an email consists of a specific number of predefined characters followed by the "at sign" (@) followed by a specific number of predefined characters followed by the "dot character" (.) followed by a specific number of predefined characters.

So let's see how we can use one of the predefined regular expressions, how you can create your own regular expression and how you can register your custom expressions for re-usability.

For the purpose of demoing the "Regular Expression" validator I have created an ADF Fusion Web Application and created the basic business components that I will be using in this demo; an entity object based on the Employees HR table, a default view object based on the Employees entity object and a default application module.

Next let’s define a "Regular Expression" validator on the Employees entity object to ensure that an employee's email conforms to a specific pattern (<character(s)>@<character(s)>.<characters(s)>). So on the  “Business Rules” tab of the Employees entity object, click on the green plus icon “Create new validator”.  This will open the “Add Validation Rule” editor for defining the validation specifics.

In the “Type” combo select “Regular Expression”, select the attribute that you want to define the validator, in my demo it's the "Email" attribute and then select an operator, either "Matches" or "Not Matches". In my demo I have selected the "Matches" operator.

Under the regular expression section you can either select one of the predefined expressions (currently two, "Email" and "Phone Number(US)") or type your own regular expression. I've selected the "Email" regular expression and clicked on the "Use Pattern" button to generate the pattern.

In the "Failure Handling" tab define a failure message and click "OK". In my example I have used a message token expression to construct a dynamic error message, passing to the failure message the  email value.
If you inspect the Employee’s entity source code you will see that JDeveloper added a RegExpValidationBean tag to the XML entity definition file.

Run the Application module to test your "Regular Expression" validator and try to update an employee's email, for example update Steven King's email from "SKING" to "SKING1". The "Regular Expression" validator should have fired displaying your error message.

Change the email to "SKING@demo.com". The validation should succeed.

You can of course create your own custom regular expressions. As with the example below, I have defined a regular expression to ensure that an employee's first name consists of only alpha characters and that the first name always starts with an upper case.

What if you wanted to re-use this custom regular expression in other attributes or in other ADF applications? It would be a really bad practice to just copy and paste the same expression in different attributes. What if you wanted to apply a change to your custom expression. It would require you to go through all occurrences and apply the change one by one.

A much better approach would be to register your custom regular expression into the PredefinedRegExp.properties file and your custom regular expression will appear into the list of "Predefined Expressions". This file is located in the o.BC4J subdirectory of the JDeveloper system directory (in my case it's system12.1.3.0.41.140521.1008), which is a subdirectory of JDeveloper’s user directory (the file in my case is located in "/home/oracle/apps/.jdeveloper/system12.1.3.0.41.140521.1008/o.BC4J").

Edit the file and add your own custom regular expression.

Restart JDeveloper and go to the Employees entity and create a new regular expression validation on the first name attribute. In the predefined expressions list you should see your own custom regular expression. Select it and click on the use expression button to populate your expression into the "Enter Regular Expression" text area.
Define a failure message and test your custom expression. If you followed my exact steps, try to update an employee's first name to start with a lower case alpha character. The validation should fail.

Download sample application: Regular Expression

Saturday, December 27, 2014

Oracle BPM 12c Gateways (Part 5 of 5): Event-based Gateway

My last article on gateways is on the event-based gateway, another type of gateway supported by Oracle BPM 12c to provide divergence in processes.

The event-based gateway is very similar, conceptual wise, to the exclusive gateway in the sense that we can have various outgoing sequence flows but only one branch is followed. The operational difference though is that, as its name suggests, the event-based gateway uses events for defining the branching conditions and decisions rather than data-specific conditions.

An event-based gateway can consist of multiple events; however the first event that occurs will determine the execution path that will be followed.

Using the order process as an example, once an order is received and validated it needs to be processed. Assuming that we have multiple warehouses, the order will be processed by the warehouse that can process all inventory items ordered and responds first. The process will wait until one of the warehouses responds to the request for processing the order. However, the process cannot wait indefinitely.

So let's see how we can implement the above scenario using the event-based gateway.

Let's start with creating the basic BPM application and BPM project (named both application and project "EventBasedGatewayDemo") and selecting "Composite with BPMN Process" in step 3.

This will bring up the "BPMN 2.0 Process Wizard" where you are prompted to specify a process name and the service type. Give your process a name, for example OrderProcess and select "Asynchronous Service" as the service type.

In step 3 of the BPMN 2.0 Process Wizard you are prompted to specify the input and output process arguments. A typical order definition would consist of an order id, a collection of order items, the order total, customer details and bill and ship address details. For simplicity reasons my demo process will only consist of the order id (of type int) and the order total (of type decimal) as input arguments and a status argument of type string as output.

The event-based gateway is composed of the event-based split gateway and two or more target events. These events can be either message catch events, timer catch events or receive tasks. Please note that you cannot mix message catch events and receive tasks within the same event-based gateway. 

Select and drop the "Event Based" gateway on the default sequence flow between the "Start" and "End" activities. You should notice that JDeveloper automatically has added three activities; an event based split gateway activity, a catch message activity and a timer catch activity.

There is an error on the Timer activity because it doesn't have an outgoing default sequence flow. Give the event based gateway split activity and the catch message activity some meaningful names and add a new catch message activity just below the default created catch message activity and define default sequence flows for all activities.

Next set the timer activity to wait for 30 seconds for a reply from the warehouses and define an implementation on the two catch message activities. Again for simplicity and demo reasons I have used the "Define Interface" message exchange type and created only a single argument, order id of type int. The implementation of both catch message activities are exactly the same, the only difference is the operation name.

So we have a process that expects some events to arrive from the two warehouses while its being executed. This means that the main process, which in our case its the order process needs to find a way to correlate these intermediate events with the itself. To do that we need to create a correlation property (an attribute to correlate the main process with the intermediate events) and a correlation key (which defines the properties to use in the correlation which consists of one or more correlation properties).

I will use the order id to correlate the events that will be flowing from the warehouses into the main order process, therefore I have created a correlation property named "orderId" and of type int and a correlation key named "ck_orderId" with the orderId correlation property selected.

We now need to instruct the process and intermediary events to use the orderId correlation property we created. The main process will be responsible for initiating the correlation and matching events that will be coming in from the warehouses with the main process. Therefore on the message start activity select under "Implementation" select "Correlations" and select the orderId correlation property and map it to the orderId process input argument. Ensure that you have selected the "Initiates" option to instruct the process to correlate an instance of the order process with the supplied order id.

The same correlation definitions need to be applied on the two catch message activities. Please ensure that the "Initiates" option is not selected since this will be done upon the instantiation of the process.

Deploy your process and run a test instance using the "start" operation. If you inspect the audit trail you should see that the instance is waiting at the event-based split gateway activity.

Run a new test instance of your order process but this time use one of the warehouse operations (for example, use the "warehouseB" operation). If you inspect the audit trail you should notice that the order is now completed and that the process followed the second branch.

Download sample application: Event-based Gateway



Tuesday, December 23, 2014

Oracle BPM 12c Gateways (Part 4 of 5): Complex Gateway

In this fourth article of a five-part series we will go through the complex gateway, a gateway that is similar to an inclusive gateway but at the same time allows you to define a voting pattern to determine whether your instance should continue execution even if not all outgoing sequence flows have been completed.

As with all the other gateways that we've seen till now, the complex gateway  involves a split activity which can be either an inclusive gateway (see "Inclusive and Complex" pattern) or an exclusive gateway and a complex merge gateway (see "Parallel and Complex" pattern).

Similar to an inclusive gateway, a process implementing the "Inclusive and Complex" pattern will follow all conditional paths whose expressions are evaluated to true. All conditional expressions that evaluate to true are executed; otherwise the default sequence flow is executed.

"Inclusive and Complex" pattern
A process implementing the "Parallel and Complex" pattern will follow all unconditional paths defined at design time.


"Parallel and Complex" pattern
What is really interesting with the complex gateway is that it allows you to define a condition on the complex gateway merge activity to control whether the instance should continue even if not all of the complex gateway paths have been completed.

When a process reaches a complex gateway activity it will create a token for each outgoing sequence flow that evaluates to true. You can configure the complex gateway merge activity to continue execution even if not all of the tokens have arrived at the complex gateway merge activity. For example, if you have three parallel sequence flows executed you can configure the complex gateway to continue after two or more tokens have arrived at the merge activity. This is really handy when you want to implement a voting based pattern on process activities.

Let's see how you can use the complex activity in a demo process. I will base my demo on the process I created in part three of my five-part series, Oracle BPM 12c Gateways (Part 3 of 5): Parallel Gateway. Let's assume that you are implementing an order process and that at some point in your process you want to request for quotations from three different suppliers. Your process shouldn't wait for a response from all three suppliers; it is sufficient that you receive quotations from just two suppliers. Once you have received quotations from any two out of the three suppliers your process should continue (ideally pick the lowest quotation but I will not be implementing this part).

So let's start with creating a BPM application with a default BPM project (named both application and project "ComplexGatewayDemo") having an empty composite.

I created next an asynchronous BPMN process and named it OrderProcess (without any arguments).

As already mentioned, in this demo I will be simulating an order process where I need to send three supplier quotations. The process shouldn't wait for all three quotations but just any two. So I will use the complex gateway and please notice how JDeveloper will automatically use the "Inclusive and Complex" pattern, adding an inclusive gateway split activity and a complex gateway merge activity.

Since I want to send a request to all three suppliers I will change the complex gateway pattern to "Parallel and Complex". You can do so by right-clicking on the inclusive split activity and choosing from the context menu "Change Gateway configuration to -> Parallel and Complex".

To simulate a supplier's request for quotation I used a human task component. I created a single human task for all three suppliers accepting all the defaults and just changing the human task title for each case. I created three user tasks on the process creating default sequence flows from the parallel split activity to all three user tasks and from each user task a default activity to the complex gateway merge activity.

You should notice that there is a warning on the complex gateway merge activity that the expression from node is empty. If you go to the implementation details of the complex gateway activity you will see that you can define either a simple or an xpath expression to control, by selecting the "Abort pending flows" check box when the process should continue even if not all tokens have reached the complex gateway.

There is a special predefined variable in a complex gateway called "activationCount" that will return you the number of tokens that have arrived to the merge gateway. You can use this with other custom data objects to form complex expressions.

In my demo, I only care for any two quotations so I will just use the activationCount variable to count the number of tokens that have reached the complex gateway. If two or more tokens have reached the complex gateway merge activity then my process shouldn't wait for the third token but instead continue with its execution.

 
For simplicity reasons I changed the human task assignment type from "Lane Participants" to "Names and expressions" and assigned the "weblogic" user as the new user participant.

Let's test our process. Since we didn't specify any arguments you can directly invoke your process. If you open the flow trace you will see that three human tasks have been created and are pending.

Go to the BPM workspace, login as weblogic (assuming that you have assigned the tasks to weblogic) and you should see three tasks. Submit one of them and go back to the flow trace. You should see that one human task has been completed and the other two are still pending.

Go back to the BPM workspace, submit one of the remaining two tasks and once the task is submitted click on the refresh icon. You should see that the third task get removed from your inbox. This is because of the expression we have defined on the complex gateway (to abort all pending flows if that expression was evaluated to true).

If you go back to the flow trace you should see that all three human tasks have been completed and the process ended.

Even though only two tokens reached the complex gateway, it was enough to signal the process to continue with its execution.

Download sample application: Complex Gateway

Wednesday, December 17, 2014

Oracle BPM 12c Gateways (Part 3 of 5): Parallel Gateway

The parallel gateway enables you to perform multiple tasks simultaneously, allowing your process to follow several unconditional paths in parallel. When your process token reaches a parallel gateway activity, the parallel gateway will create a token for each outgoing parallel sequence flow. Your process will wait until all tokens have arrived at the parallel gateway merge activity before resuming with the rest of the activities.

You should be very careful with the parallel gateway activity because if one of the tokens that have been created by the parallel gateway doesn't arrive at the parallel gateway merge activity, then your process will freeze.

So let's see how you can use the parallel gateway in a process. Let's assume that you are implementing an order process and that at some point in your process you want to request for quotations from two different suppliers. Once you have received both quotations your process should resume (ideally pick the lowest quotation but I will not be implementing this part).

I created a BPM application with a default BPM project (named both application and project "ParallelGatewayDemo") having an empty composite.

Next I created an asynchronous BPMN process and named it OrderProcess without any arguments.

As already stated above in this demo I will be simulating an order process where I need to send two supplier quotation. So I will use the parallel gateway. Please note how JDeveloper automatically adds a parallel gateway merge activity when you drop a parallel activity on your process.

To simulate a supplier's request for quotation I used a human task component. I created a single human task for both suppliers accepting all the defaults and just changing the human task title for each case.

For simplicity reasons I changed the human task assignment type from "Lane Participants" to "Names and expressions" and assigned the "weblogic" user as a new user participant.

So let's test our process. Since we didn't specify any arguments you can directly invoke your process. If you open the flow trace you will see that two human tasks have been created and are pending.


Go to the BPM workspace, login using the weblogic user and if you followed my exact steps and you should see two tasks. Approve one of them.
If you go back to the flow trace you should see that there process is waiting for the second human task.

Approve the second human task (from the BPM workspace) and go back to the flow trace; you process should be completed.

Both tokens from both outgoing parallel sequence flow have reached the parallel gateway merge activity which signaled to the process that all parallel activities have been completed.

Download sample application: Parallel Gateway

Monday, November 10, 2014

Using ADF BC Declarative Built-in Rules (Part 7 of 10): Range validator

The "Range Validator" is another entity attribute validator which can be be defined at either the entity or attribute level but pertains to an entity attribute just like the "Compare", "Key Exists", "Length" and "List" validators.

As it's name suggests you can use the "Range" validator to ensure that an attribute value falls either within or outside some specified minimum and maximum values. For example, ensure that an employee's salary is between $10,000 and $20,000.

For the purpose of demoing the "Range" validator I have created an ADF Fusion Web Application and created the basic business components that I will be using in this demo; an entity object based on the Employees HR table, a default view object based on the Employees entity object and a default application module.

Next let’s define a "Range" validator on the Employees entity object to ensure that an employee's salary is within a specified minimum and maximum values. So on the  “Business Rules” tab of the Employees entity object, click on the green plus icon “Create new validator”.  This will open the “Add Validation Rule” editor for defining the validation specifics.

In the “Type” combo select “Range”, select the attribute that you want to define the validator, in my demo it's the "Salary" attribute and then select an operator, either Between or NotBetween. In my demo I have selected the "Between" operator.

Under the range section define a minimum and a maximum value.

In the "Failure Handling" tab define a failure message and click "OK". In my example I have used a message token expression to construct a dynamic error message, passing to the failure message the new salary value using the newValue keyword.


If you inspect the Employee’s entity source code you will see that JDeveloper added a RangeValidationBean tag to the XML entity definition file.

Run the Application module to test your "Range" validator and try to update an employee's salary to a value greater than 20,000. The "Range" validator should have fired displaying your error message.

Download sample application: Range Validator

Monday, September 22, 2014

Oracle BPM 12c Gateways (Part 2 of 5): Inclusive Gateway


The inclusive gateway, just like the exclusive gateway, enables you to split your process into two or more paths. The intrinsic difference between an exclusive gateway and an inclusive gateway is that in an exclusive gateway, the process only continues down one of several paths (if multiple outgoing sequence flows are present) while in an inclusive gateway a process will follow all conditional paths whose expressions are evaluated to true.

Furthermore, in an inclusive gateway a process will only follow the default path only if no conditional expressions evaluate to true. Because of this particular characteristic the notation of an inclusive gateway consist of a split and a merge inclusive gateway.


An inclusive gateway can consist multiple outgoing conditional sequence flows for an inclusive gateway split. However, an inclusive gateway must define a default sequence flow. All conditional expressions that evaluate to true are executed; otherwise the default sequence flow is executed.

At run time, the BPM engine generates a token for each conditional sequence that evaluates to true. If none of the conditional sequence flows evaluate to true then a token gets generated for the default sequence flow. The process will pause and will resume only when all tokens have reached the merge

So let's see how you can use an inclusive gateway in a process. I have created a new BPM application using the "BPM Application" JDeveloper template and in the "Project SOA Settings" step i have selected "Composite with BPMN Process".

This will bring up the "BPMN 2.0 Process Wizard" where you are prompted to specify a process name and the service type. In this demo I have selected "Asynchronous Service".

In this demo I will be simulating a Banking Supervision process where a specific department of a Central Bank is responsible for over-sighting it's financial institutions and based on certain decision points various documents are required to be generated.

Therefore I will create two input arguments, NonComplianceLetter and LetterToCentralBank, both of type boolean to denote whether these two type of documents are required to be generated and an output string argument, DocumentsGenerated, to act as a confirmation of which documents where generated.

When you click finish it will open the process. Using the structure window I have created three process data objects to store the input arguments I have created above and hold the output argument value (nonComplianceLetter and letterToCentralBank both of type boolean and documentsGenerated of type string).

Next I assigned the two input arguments (NonComplianceLetter and LetterToCentralBank) to the process data objects (nonComplianceLetter, letterToCentralBank) by double-clicking on the "Start" activity, going to the "Implementation" tab and selecting "Data Associations".

Please note that i did the same thing for the "End" activity but this time i have mapped the documentsGenerated process data object to the DocumentsGenerated output argument.

As already mentioned I will be simulating a Banking Supervision process where based on the two boolean input arguments I will generate either both documents (Non-Compliance Letter and Letter to Central Bank), one of the documents (Non-Compliance Letter or Letter to Central Bank) or will not generated any documents at all. And to implement such a scenario I will use an inclusive gateway. Please pay attention how JDeveloper automatically adds an inclusive merge gateway with every inclusive split gateway.

Furthermore I dropped three script tasks, one between the inclusive split and merge gateway, one above the inclusive gateway and one below the inclusive gateway.

On each script task, using the "Data Associations" provided some static text to the documentsGenerated process data object to display whether a document is generated (please note that in the second script task I used the concat function to concatenate the string value from the first script task).

Because I want to have the third script task (Do not Generate Any Letters) marked as the default sequence flow I will delete the default sequence flow from the second script task (Generate Letter to Central Bank) and redefine the sequence flows.

For the first two conditional outbound sequence flows I have defined an XPath expression to check whether its marching document is selected. For the "Generate Non-Compliance Letter" conditional flow you should have an XPath condition similar to "xp20:matches(string(bpmn:getDataObject('nonComplianceLetter')), '\s*(?i:true|1)\s*')". For the "Generate Letter to Central Bank" conditional outbound sequence flow your XPath should be similar to "xp20:matches(string(bpmn:getDataObject('letterToCentralBank')), '\s*(?i:true|1)\s*')".

Deploy your process on the integrated Weblogic server and run a test with just one of the documents selected (let's say LetterToCentralBank set to true). The second conditional sequence flow is evaluated to true and if you inspect the "End" message DocumentsGenerated output element you should see that the Letter to Central Bank document has been generated.

Switch to graphical view to see the execution path highlighted.

 
Now test your process without selecting any of the two documents. The process should have followed the default sequence flow. You can confirm this by inspecting the "End" message DocumentsGenerated output element; it should read "No documents generated".

If you switch to graphical view you will see that the process followed the default outbound sequence flow.



Download sample application: Inclusive Gateway