Leveraging reference data for business rule authoring in IBM Operational Decision Manager using an XML dynamic domain

Business and other reference data often used in business rule authoring can reside in different sources and formats such as database tables, Excel files, CSV, XML and other text documents. Learn how you can create and deploy a dynamic domain plug-in to leverage existing business data represented as XML for rule authoring. You can associated a Business Object Model (BOM) class with the new XML dynamic domain. The XML dynamic domain allows any XML data stream that conforms to the XML dynamic domain schema to be used as a source of data for the dynamic domain. This content is part of the IBM Business Process Management Journal.

Neil Delima (ndelima@ca.ibm.com), Certified IT Specialist, IBM

Neil DelimaNeil Delima is a Level 2 Certified IT Specialist and member of the IBM Software Services for WebSphere team working at the IBM Toronto Lab. His current areas of focus and expertise include architecting, designing, and developing software solutions by leveraging IBM's business process and decision management products. Neil has several years of software engineering and application development experience in Java and XML parsing standards and technology. He has a MASc degree in Software Engineering from the University of Waterloo.



28 August 2013

Overview

IBM Operational Decision Manager (IBM ODM) is a business rules management system that comprises a rich set of tools to author, test, execute and manage business rules. Business entities that are referenced when creating business rules are modeled into a business object model (BOM). These business entities are represented as attributes, methods and constructor members of classes in the BOM. These verbalized BOM elements are used when authoring business rule artifacts such as business rules and decision tables.

In ODM, static and dynamic domains can be used to place restrictions on BOM members. They can also be used to provide reference data for rule authoring. Static domains typically consist of literals, static references, bounded types and collections hardcoded in the BOM. With static enumerated literal domains, when a new domain reference data value has to be added to the domain or an existing one updated, the BOM has to be updated, synchronized, and the changes have to be published to the business user authoring tool, Decision Center. Dynamic domains solve this problem by providing enumerated domain reference data values from an external data source without having to hardcode them in the BOM. This is done by executing Java® code external to the BOM that reads data from an external data source and dynamically populates the domain with the reference data values that were read. This data can originate from different sources such as enterprise information systems, database system, XML and text sources and others. WebSphere ODM V7.5 also added a new built-in Microsoft Excel dynamic domain provider that allowed users to create a dynamic domain from reference data defined in an external Excel worksheet. This external reference data provided by dynamic domains can be updated at any time using the business rule authoring tools in ODM, unlike in the case of static domains.

This article walks you, the IBM ODM developer, through the process of developing and deploying a dynamic domain plug-in that can leverage existing XML business data and use it for rule authoring. The description and examples provided in this article have been designed for ODM V8.0.1, but they can also be applied to earlier releases of ODM, specifically WebSphere ODM V7.5 and its predecessor ILOG JRules V7.1. The XML Schema for the data sources defines XML elements and attributes that capture the attributes of a BOM element like the name, the verbalization, the mapping and the description, which are parsed to construct the dynamic domain. Any XML data stream that conforms to the XML dynamic domain Schema can be used as a source of data for the dynamic domain. The XML data source is parsed using existing XML parser components and APIs available in the Java development and runtime environment. Once the dynamic domain is created, new business data added to the XML data source can be made available for rule authoring by using the BOM Update function available from Rule Designer and the Decision Center Enterprise Console. This action will update domain values in the BOM and make them available for rule authors, without having to republish the rule project with an updated BOM to Decision Center. While the method described to create an XML dynamic domain in this article applies to a specific XML data structure that resembles that of the Excel dynamic domain, it can be adapted to any XML data stream.


Developing and integrating the dynamic domain

This section describes the steps for creating the XML dynamic domain using ODM Rule Designer. The XML dynamic domain will parse an XML stream with reference data, defined by a structure that represents the attributes of a BOM member, such as the name and the verbalization. Rule authors can use the reference XML data made available by the dynamic domain in rule authoring after the dynamic domain has been created and deployed. The steps for creating the XML dynamic domain are as follows:

These steps are explained in detail in the following sections.


Step 1. Create an Eclipse plug-in project in Rule Designer for the dynamic domain implementation

The steps to create the Eclipse plug-in project are:

  1. Launch ODM Rule Designer and switch to the Eclipse Plug-in Development perspective.
  2. In the Plug-in Development perspective, create a new Eclipse plug-in project by selecting File => New => Project.
  3. In the New Project wizard that appears, select Plug-in Project and click Next, as shown in Figure 1.
    Figure 1. Create a new Eclipse Plug-In project
    Create a new Eclipse Plug-In project
  4. In the Project Name field of the New Plug-in Project wizard, type a name for your project, and then click Next, as shown in Figure 2.
    Figure 2. New Eclipse Plug-In Project creation wizard
    New Eclipse Plug-In Project creation wizard
  5. Click Next (do not modify the default values) on the next dialog that appears.
  6. On the Templates dialog, uncheck Create a plug-in using one of the templates and then click Finish . This creates a new Eclipse Plug-in project in the Plug-in Development perspective. If you are not already working in the Plug-In Development perspective, click Yes in the Open Associated Perspective dialog. This action creates the plug-in project and opens the plug-in manifest in the plug-in editor.
  7. Check the properties for the newly created plug-in project and make sure that the compiler compliance level, in the JDK Compiler section of the Java Compiler properties is set to 1.5 or higher.
  8. Switch to the Dependencies tab of the plug-in editor. In the Required Plug-ins section, click Add to select and add the ODM plug-ins ilog.rules.studio.model, ilog.rules.brl.brldf, and ilog.rules.vocabulary.bom that appear in the Plug-in Selection dialog, as shown in Figure 3.
    Figure 3. Plug-in Dependencies
    Plug-in Dependencies

Step 2. Define the XML data stream Schema and add reference XML data for the dynamic domain

In order to create a dynamic domain, you must implement the domain value provider interface IlrBOMDomainValueProvider. This interface exposes properties of BOM domain members, such as the verbalization, the translation, the description, and the BOM-to-XOM mapping. Much like the Excel dynamic domain, the XML Schema of the XML dynamic domain is modeled to capture information associated with the IlrBOMDomainValueProvider interface, as illustrated in Listing 1.

The name attribute of the BOMClass class element corresponds to the BOM class that will be associated with this dynamic domain. The name attribute of the BOMElement corresponds to the BOM member name. The verbalization attribute corresponds to the BOM verbalization. The mapping attribute corresponds to the BOM-to-XOM mapping and the documentation attribute corresponds to the documentation for the BOM member of the encapsulating BOM class. Only the name attribute is required. All other attributes if absent will default to the value of the name attribute.

Listing 1. XML dynamic domain XML Schema definition
<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://developerWorks/WODM/Sample/DomainProvider"
    xmlns:ns="http://developerWorks/WODM/Sample/DomainProvider">

   <element name="ReferenceData">
        <complexType>
            <sequence>
                <element name="BOMClass" type="ns:BOMElementType"
                    minOccurs="1" maxOccurs="1"/>
            </sequence>
        </complexType>
    </element>

    <complexType name="BOMElementType">
        <sequence>
            <element name="BOMElement" minOccurs="1" maxOccurs="unbounded">
                <complexType>
                    <attribute name="name" type="string" use="required"/>
                    <attribute name="verbalization" type="string"use="optional"/>
                    <attribute name="mapping" type="string"use="optional"/>
                    <attribute name="documentation" type="string"use="optional"/>
                </complexType>
            </element>
        </sequence>
        <attribute name="name" type="string" use="required"/>
    </complexType>
</schema>

A snippet of the reference XML data stream that conforms to the XML dynamic domain schema is shown in Listing 2 below. The reference data in this example is a list of ISO country codes that get loaded as dynamic domain members of the associated virtual BOM class developerworks.wodm.sample.dynamicdomain.ISOCountry. The XML data stream for the dynamic domain could contain other more dynamic categories of reference data like discount codes. Further, the data stream could provide reference data and associate the data with more than one virtual BOM class using multiple BOMClass parent elements. The implementation of the IlrBOMDomainValueProvider interface in this article parses this XML reference data stream to create the dynamic domain. While this article is centered around creating a reusable XML dynamic domain from reference data in a specific structure that resembles that of the Excel dynamic domain, the code can be adapted to leverage reference XML data in any other structure.

Listing 2. Sample XML dynamic domain data stream
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ns2:ReferenceData
    xmlns:ns2="http://developerWorks/WODM/Sample/DomainProvider"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    si:schemaLocation="http://developerWorks/WODM/Sample/DomainProvider
    ODMDomainValues.xsd">

    <!-- Reference: http://www.iso.org/iso/country_codes.htm -->

	<BOMClass name="developerworks.wodm.sample.dynamicdomain.ISOCountry">
        ...
        <BOMElement name="CM" verbalization="CAMEROON"
            mapping="return "CM";"
            documentation="CAMEROON"/>
        <BOMElement name="CA" verbalization="CANADA"
            mapping="return "CA";"
            documentation="CANADA"/>
        <BOMElement name="CV" verbalization="CAPE VERDE"
            mapping="return "CV";"
            documentation="CAPE VERDE"/>
        <BOMElement name="KY" verbalization="CAYMAN ISLANDS"
            mapping="return "KY";"
            documentation="CAYMAN ISLANDS"/>
        ...
    </BOMClass>
</ns2:ReferenceData>

Step 3. Implement the dynamic domain IlrBOMDomainValueProvider interface.

The BOM domain value provider interface implementation is responsible for setting up the dynamic domain. In this example it parses the XML reference data stream and dynamically creates a BOM enumerated domain for the associated BOM class, as shown in Figure 4.

Figure 4. IlrBOMDomainValueProvider implementation class
IlrBOMDomainValueProvider implementation class

In this article, the class XMLDomainValueProvider implements the dynamic domain value provider interface IlrBOMDomainValueProvider. This class parses the XML data stream containing reference values used to populate a BOM class with dynamic domain data using the standard StAX XMLStreamReader APIs. Each BOMClass element in the XML data stream corresponds to a virtual class defined in the BOM and its child BOMMember elements in the data stream correspond to the dynamic domain member elements of the BOM class.

The data represented by BOM member elements in the XML data stream corresponds to those in the BOM. The implementation of the IlrBOMDomainValueProvider methods getValues, getBOM2XOMMapping, getDisplayText and getDocumentation return the corresponding parsed values of the BOM member name, the BOM-to-XOM mapping, the verbalization and documentation attributes for each BOM element from the XML data stream. The implementation of the methods getItemNames and getBOM2XOMMapping is illustrated in Listing 3. The getValues method returns a collection of BOM domain elements that correspond to the name element from the BOMMember class. The getBOM2XOMMapping method returns the BOM-to-XOM mapping for the corresponding domain value that corresponds to the mapping element from the BOMMember class. You can use the sample code in this article to create an XML dynamic domain with any XML data stream that conforms to the XML Schema defined.

Listing 3. IlrBOMDomainValueProvider implementation class
...
public String getDisplayText(String valueName, Locale locale) {
    List<BOMMember> domainItems = bomclasses.get(virtualBOMClassName);
    Iterator<BOMMember> it = domainItems.iterator();
    while (it.hasNext()) {
        BOMMember element = (BOMMember) it.next();
        if (valueName.equalsIgnoreCase(element.getName()))
            return element.getVerbalization();
        }
        // Should never happen
            return null;
        }
...
public Collection <String> getValues(IlrClass clazz) {
    this.virtualBOMClassName = clazz.getFullyQualifiedName();
    populateDomain();
    List<BOMMember> domainItems = bomclasses.get(virtualBOMClassName);
    ArrayList<String> names = new ArrayList<String>();
    Iterator<BOMMember> it = domainItems.iterator();
    while (it.hasNext()) {
        BOMMember element = (BOMMember) it.next();
        names.add(element.getName());
    }
    return names;
}
...

Step 4. Create a Rule Designer extension point that references the dynamic domain implementation

To associate the XML dynamic domain plug-in with the domain editing component of the BOM editor, the extension point ilog.rules.studio.model.bomDomainValueProviders, which Rule Designer understands is created. To define the plug-in extension point:

  1. In the plug-in editor, select the Extensions tab.
  2. Click Add in the All Extensions section.
  3. In the New Extension, Extension Point Selection dialog that appears, select the extension point ilog.rules.studio.model.bomDomainValueProviders from the Extension Points, as illustrated in Figure 5.
    Figure 5. Select a new extension point
    Select a new extension point
  4. Click Finish and save any changes.
  5. Fill in the details that associate the extension point with the implementation of the IlrBOMDomainValueProvider interface by entering values for the id, name and class fields, as illustrated in Figure 6. The value you enter for the name will be later referenced in the BOM to associate the BOM class with the dynamic domain provider using the ODM property domainValueProviderName.
    Figure 6. Domain value provider extension point details
    Domain value provider extension point details
  6. In the Exported Packages section of the Runtime tab of the plug-in manifest editor, click Add to add the package name containing the implementation of the IlrBOMDomainValueProvider interface, as illustrated in Figure 7.
    Figure 7. Domain value provider extension point runtime packages
    Domain value provider extension point runtime packages

Step 5. Export and deploy the dynamic domain plug-in to Rule Designer

Now that you've created the plug-in, you can deploy it by following these steps:

  1. Select the plug-in project and click File => Export.
  2. In the Export wizard that appears, select Deployable plug-ins and fragments from the Plug-in Development folder and click Next, as illustrated in Figure 8.
    Figure 8. Export plug-in wizard
    Export plug-in wizard
  3. Select the plug-in you created from the Available Plug-ins and Fragments section of the Deployable plug-ins and fragments dialog, as illustrated in Figure 9.
  4. Select Directory on the Destination tab and click Browse to select the directory containing Rule Designer, which can be installed standalone or integrated with another Eclipse-based product, such as IBM Integration Designer.
  5. Select Options => Package plug-ins as an individual JAR archives, and click Finish to build and export the plug-in.
    Figure 9. Export plug-in wizard, Available Plug-ins and Fragments
    Export plug-in wizard, Available Plug-ins and Fragments
    Start Rule Studio and you should see that the dynamic domain value provider plug-in is now be available.

Step 6. Create a virtual BOM class associated with the dynamic domain and load the dynamic domain

To associate the dynamic domain with an element in the BOM, create a virtual BOM class and associate the domainValueProviderName property with the dynamic domain plug-in extension name. Dynamic domains can be associated with any BOM class, however having a virtual BOM class with domain reference values makes the BOM classes like an enumerated type, which can be assigned as the type of another BOM class member.

  1. In the BOM editor, create a virtual BOM class that will be used to store domain values. The class name should match the BOM class name specified in the XML data source (refer to the code snippet in Listing 2 ). In this article, the virtual BOM class created is named developerworks.wodm.sample.dynamicdomain.ISOCountry.
  2. The dynamic domain for the virtual BOM class consists of an enumerated list of string reference data values. In the Execution Name section of the BOM to XOM Mapping section of the BOM Editor, enter the virtual class type as java.lang.String, as illustrated in Figure 10.
    Figure 10. Virtual BOM class of type String
    Virtual BOM class of type String
  3. To associate the dynamic domain with the virtual BOM class, in the Custom Properties section of this class, define a custom property whose name is domainValueProviderName and value is the value of name assigned in the Plug-in Extensions tab of the dynamic domain plug-in editor, as illustrated in Figure 11.
    Figure 11. Associate a dynamic domain with a BOM class by plug-in extension name
    Associate a dynamic domain with a BOM class by plug-in extension name
  4. Once the domainValueProviderName has been successfully associated with the domain value provider plug-in, the Domain section of the virtual model class view gets updated with the Domain Type set to Dynamic. A link to synchronize the virtual BOM class's members with the dynamic domain data is also now created, as illustrated in Figure 11. If the value of the property domainValueProviderName is invalid, the following message appears in the Domain section: The value provider is invalid. Check the custom properties, as illustrated in Figure 12.
    Figure 12. Incorrect domainValueProviderName assignment
    Incorrect domainValueProviderName assignment

    Note that when creating a dynamic domain using ILOG JRules V7.1 Rule Studio, you need to click the Create a domain link in the Domain section. Select the Static references option of the Domain type field from the Domain dialog that appears, and click OK. (Note: You might have to select the Other domain type and switch back to the Static References domain type if the OK button is disabled.)

  5. Click the Synchronize link to populate the domain. This action loads enumerated reference data provided by the dynamic domain, as illustrated in Figure 13. If the enumerated domain reference data does not appear, the external data source providing the domain values is likely not accessible or loaded correctly.
    Figure 13. The BOM class loaded with reference data from the dynamic domain
    The BOM class loaded with reference data from the dynamic domain
  6. Click a member of the ISOCountry virtual domain class loaded from the dynamic domain. The verbalization should appear as illustrated in Figure 14. Note that the name, verbalization, documentation, and BOM to XOM mapping is the same as that specified in the XML data stream or should be defaulted based on the BOM member name that was specified in the XML data stream.
    Figure 14. BOM member attributes of the virtual BOM class
    BOM member attributes of the virtual BOM class

Step 7. Add the dynamic domain to a BOM member by setting its type to the virtual BOM class

Now that you've created the virtual BOM class, you can assign it as a BOM member type. This action makes the enumerated domain reference values available to the BOM member that it is assigned to. To do this, open the BOM members properties and in the Member view under the General Information section, click Browse beside the Type property to browse and select the BOM virtual class that contains dynamic domain values. As illustrated in Figure 15, the ISOCountry virtual BOM class is assigned to the type of the ISOCountryCode attribute of the Address BOM class.

Figure 15. BOM member type assignment to the dynamic domain virtual BOM class
BOM member type assignment to the dynamic domain virtual BOM class

The reference data from the dynamic domain is now available when authoring rules that operate on the BOM member to which it is associated. Figure 16, Figure 17 and Figure 18 illustrate how the ISOCountry member of the Address BOM object can be used to reference the ISO country code data from the dynamic domain in Rule Designer and Decision Center Enterprise and Business consoles.

Figure 16. Using the new dynamic domain reference data when authoring rules
Using the new dynamic domain reference data when authoring rules

This action rule checks whether the Country Code BOM member has the value CA and if so, sets the value of another BOM member defined in the rule. The string that is selected in the rule editor CANADA, is extracted from the verbalization attribute of the BOMElement that was defined in the XML reference data stream, as illustrated in Listing 2. The verbalized value CANADA of the dynamic domain, has an ILOG Rule Language BOM to XOM mapping that returns the String CA. This is defined by the mapping attribute in the XML reference data stream and gets propagated to the BOM to XOM mapping of the CA BOM member in the BOM editor.

Figure 17. Using the new dynamic domain reference data when authoring rules in Decision Center Enterprise console
Using the new dynamic domain reference data when authoring rules in Decision Center Enterprise console
Figure 18. Using the new dynamic domain reference data when authoring rules in Decision Center Business console
Using the new dynamic domain reference data when authoring rules in Decision Center Business consol

Integrating the dynamic domain with the Decision Center Enterprise console

To integrate the dynamic domain into ODM Decision Center, the dynamic domain provider plug-in project that was just created needs to be exported to a JAR file and the exported JAR integrated with the Decision Center Enterprise console. To do this, complete the following steps:

  1. Select the Eclipse Plug-In domain provider project from the Eclipse Plug-in Development perspective and select File => Export.
  2. In the Export wizard, select JAR file from the Java folder and click Next, as illustrated in Figure 19.
    Figure 19. Export plug-in wizard
    Export plug-in wizard
  3. Select the dynamic domain value provider Java plug-in project. In the JAR file text box, specify the destination file name and path for the JAR file, as illustrated in Figure 20, and click Next.
    Figure 20. JAR file options from the Export plug-in wizard
    JAR file options from the Export plug-in wizard
  4. Accept the default options in the Jar Packaging Options step of the Export plug-in wizard.
  5. Select Use Existing Manifest From Workspace from the Jar Manifest Specification step of the Export plug-in wizard and select the manifest file from the plug-in project, as illustrated in Figure 21, then click Finish to create the exported JAR file.
    Figure 21. JAR file manifest pptions from the Export plug-in wizard
    JAR file manifest pptions from the Export plug-in wizard
  6. To integrate the dynamic domain JAR file with ODM Decision Center, you need to set a configuration preference property for the dynamic domain. You can do this in one of the following two ways:
    1. Run the ant task:
      ant set-config-param
       -Dkey=teamserver.<plug-in extension point name>
       -Dvalue=<plug-in extension point class name>.

      The ant command used in this article would be:
      ant set-config-param
       -Dkey=teamserver.XMLDynamicDomainValueProvider
       -Dvalue=developerworks.wodm.sample.dynamicdomain.XMLDomainValueProvider
    2. Create a properties file called preferences.properties that is placed in the root of the dynamic domain plug-in project. Add the property teamserver.<plug-in extension point name>=<plug-in extension point class name>, as illustrated in Figure 22 and export the plug-in JAR.
    Figure 22. Set up the dynamic domain Decision Center configuration property
    Set up the dynamic domain Decision Center configuration property
  7. To integrate the dynamic domain provider exported JAR with the Decision Center enterprise application, repackage the exported JAR into the Decision Center enterprise archive and then redeploy the Decision Center application. To do this, run the ant task: ant repackage-ear -DadditionalJars=<path to dynamic domain jar>. Alternatively, depending on the application server that hosts the Decision Center application, you can also place the exported JAR file in the web application archive classpath directory of Decision Center, and then restart Decision Center. For application servers such as WebSphere Application Server or Apache Tomcat, this directory is <directory path on the Application Server to the Rule Team Server EAR>/teamserver.war/WEB-INF/lib.

Update the dynamic domain

This section describes how to update external reference data in the dynamic domain from Rule Designer and the Decision Center Enterprise console.

Update dynamic domains in Rule Designer

  1. To update the dynamic domain in Rule Designer, open the BOM in the BOM editor and click Update the dynamic domains of this BOM entry in the Task section of the editor, as illustrated in Figure 23.
    Figure 23. Updating the dynamic domain in Rule Designer
    Updating the dynamic domain in Rule Designer
  2. This opens the Dynamic Domains dialog, which contains all BOM classes with associated dynamic domains. This is determined by the presence of the property domainValueProviderName set on the BOM class. Select the BOM classes to be updated and click Finish to update the dynamic domains, as shown in Figure 24.
    Figure 24. Updating the dynamic domain in Rule Designer
    Updating the Dynamic Domain in Rule Designer
  3. To update the dynamic domain from the Decision Center Enterprise console, navigate to the Project tab in the Decision Center Enterprise console, as illustrated in Figure 25. Click Update Dynamic Domains under the Business Object Model section on this tab.
    Figure 25. Updating the dynamic domain in Decision Center
    Updating the dynamic domain in Decision Center
    In the next Dynamic Domains update selection page that appears, select the dynamic domains to update and click Update at the top of the page, as illustrated in Figure 26. If the dynamic domain was successfully updated, a message will appear indicating that "The dynamic domains were successfully reloaded." Otherwise, an error message will display.
    Figure 26. Updating the dynamic domain in Decision Center
    Updating the dynamic domain in Decision Center

Conclusion

This article explained how to use IBM Operational Decision Manager to create a reusable dynamic domain from an XML data stream that conformed to an XML Schema, whose model resembled that of the Excel dynamic domain. It covered the details on how to develop and configure the dynamic domain Eclipse plug-in, how to define and set-up the domain with reference data, how to deploy it to Rule Designer and Decision Center, how to use it in to access reference data when authoring business rules, and how to update the domain. While the examples in the article were developed with IBM ODM V8.0.1 and the article was based on creating a dynamic domain from an XML stream of a specific format, the process could be adapted to earlier versions of WebSphere ODM and ILOG, and to any other XML stream with reference business data.


Acknowledgements

The author would like to especially thank Jerome Boyer for reviewing this article.


Download

DescriptionNameSize
Sample plug-in and rule projects for this article.XMLDynamicDomainSample.zip10KB

Resources

Comments

developerWorks: Sign in

Required fields are indicated with an asterisk (*).


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name



The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


All information submitted is secure.

Dig deeper into Business process management on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Business process management, WebSphere
ArticleID=942157
ArticleTitle=Leveraging reference data for business rule authoring in IBM Operational Decision Manager using an XML dynamic domain
publish-date=08282013