Guide to Creating Corticon Extensions

Transcription

1 Guide to Creating Corticon Extensions

2

3 Notices Copyright agreement 2016 Progress Software Corporation and/or one of its subsidiaries or affiliates. All rights reserved. These materials and all Progress software products are copyrighted and all rights are reserved by Progress Software Corporation. The information in these materials is subject to change without notice, and Progress Software Corporation assumes no responsibility for any errors that may appear therein. The references in these materials to specific platforms supported are subject to change. Business Making Progress, Corticon, DataDirect (and design), DataDirect Cloud, DataDirect Connect, DataDirect Connect64, DataDirect XML Converters, DataDirect XQuery, Deliver More Than Expected, Icenium, Kendo UI, Making Software Work Together, NativeScript, OpenEdge, Powered by Progress, Progress, Progress Software Business Making Progress, Progress Software Developers Network, Rollbase, RulesCloud, RulesWorld, SequeLink, Sitefinity (and Design), SpeedScript, Stylus Studio, TeamPulse, Telerik, Telerik (and Design), Test Studio, and WebSpeed are registered trademarks of Progress Software Corporation or one of its affiliates or subsidiaries in the U.S. and/or other countries. AccelEvent, AppsAlive, AppServer, BravePoint, BusinessEdge, DataDirect Spy, DataDirect SupportLink, Future Proof, High Performance Integration, OpenAccess, ProDataSet, Progress Arcade, Progress Profiles, Progress Results, Progress RFID, Progress Software, ProVision, PSE Pro, SectorAlliance, Sitefinity, SmartBrowser, SmartComponent, SmartDataBrowser, SmartDataObjects, SmartDataView, SmartDialog, SmartFolder, SmartFrame, SmartObjects, SmartPanel, SmartQuery, SmartViewer, SmartWindow, WebClient, and Who Makes Progress are trademarks or service marks of Progress Software Corporation and/or its subsidiaries or affiliates in the U.S. and other countries. Java is a registered trademark of Oracle and/or its affiliates. Any other marks contained herein may be trademarks of their respective owners. Please refer to the Release Notes applicable to the particular Progress product release for any third-party acknowledgements required to be provided in the documentation associated with the Progress product. 3

4 Notices 4

5 Contents Table of Contents Chapter 1: Overview of Corticon extensions...7 Chapter 2: Using extensions when creating Decision Services...9 Chapter 3: Reviewing what is in the sample extensions...13 What's in the Extended Operators Sample Projects...14 What's in the Service Callout Sample Projects...15 Chapter 4: Code conventions...19 Using annotations...19 Imports and interfaces used in extensions...20 Chapter 5: Creating custom extended operators...23 Chapter 6: Creating custom service callouts...27 Chapter 7: Building the Java classes and JARs...31 Chapter 8: Deploying Decision Services with extensions...33 Appendix A: Access to Corticon knowledge resources

6 Contents 6

7 1 Overview of Corticon extensions When you are creating business rules, you sometimes need to perform operations that are not built natively into Corticon. For example you may need a complex mathematical formula or to retrieve data from an external web service. Corticon provides the ability to add custom extensions for just such purposes. This has been present in previous releases but has been made easier to use in Corticon 5.6. Extensions are written as custom Java code that you package into one or more JAR files. In earlier releases, you had to modify Corticon s Java classpath and perform other configuration steps to use an extension in your Decision Services. In Corticon 5.6, you simply add extension jar files to your rule project and Corticon bundles them into the EDS file for your Decision Service. This ease of adding extensions makes it easier to develop extensions yourself or to use open source extensions that you download from the Corticon community. By bundling extensions with EDS files, the EDS file becomes self-contained. You can deploy it to a Corticon Server without modifying the server s classpath. It also allows you to have different Decision Services, or versions of Decisions Services, running that use different versions of an extension. When developing an extension, it needs to implement one or more Java interfaces that Corticon has defined. These interfaces have not changed in Corticon 5.6. What is new is the addition of Java annotations to describe the extension. The use of annotations eliminates the need for additional configuration files. When developing a project in Corticon Studio you can add extensions to your project through the project's Properties dialog box, so that they are available for development and running rule tests. The Package and Deploy wizard in Corticon Studio will include any extensions used by the project into the EDS file it generates or deploys. If you want to script the building of your EDS files, you can also use the Corticon ANT scripts to package extensions into EDS files. For compatibility with previous releases you can still place extension JAR files on the Corticon classpath so that they are available to all Decision Services. Extensions can be created in the Java development environment included in Corticon Studio, or you can use another IDE. 7

8 Chapter 1: Overview of Corticon extensions There are two types of Corticon extensions: Extended operators - Operators are used when defining conditions and actions in a Rulesheet. While Corticon has a large built-in set of operators, you can expand this set by adding custom operators. Operators can operate on individual attributes, collections or sequences. Examples include: Financial functions, such as net present value, and loan amortization Statistical functions, such as standard deviation, and permutations Engineering functions, such as pi, sine, and cosine Service callouts - Callouts can be used in a ruleflow to retrieve, modify, or store data that is being processed by the rules. The most common use is to access data in a database or external web service. For example, if your Ruleflow needs to look up an applicant's credit rating, the service callout can have a step in the Ruleflow processing that calls out to a trusted realtime ratings provider, and then adds the response back into the decision processing. 8

9 2 Using extensions when creating Decision Services You might want your project to include extensions that are already packaged and ready to use. The sample extensions bundled with Corticon Studio provide sample Rule projects with their samples already packaged into JARs. For now, assume that you just want to use the functionality in these extensions. To use the packaged extension samples in my project 1. In Corticon Studio, choose Help > Samples. Locate the Advanced samples: 2. Select Extended Operators, click Open, and then click OK. 3. Then do the same to open the Service Callouts sample. 4. Your Studio's Project Explorer lists the two samples, each with its Java project and its Rules project: 9

10 Chapter 2: Using extensions when creating Decision Services 5. Expanding the two Rule Projects, you can see that each has a related samples JAR. 6. Create a new Rule Project named myproject and create a very simple Vocabulary that includes a date type: 7. In thew Project Explorer, click on myproject, and then select Properties. Select Corticon Extensions. Click Add then navigate to each of the sample Rule Projects to select its extensions JAR, as shown: 10

11 While it is good to copy extension JARs you want to use into your project, you can navigate to other locations to add them to your project 8. Because the JARs were referenced in their original locations, they are not listed in myproject folder. If your extensions requires other JARs, you can add them here. 9. Create a Rulesheet in myproject. Note that the Rule Operators tab adds in the extended operators that are in the JAR, so that you can readily use one as a valid operator in the Rulesheet, as shown: 10. Create a Ruleflow in myproject. Click Service Call-out on the palette, click on the canvas, and then name it. On the Properties tab, click the Service Name dropdown to see the service callouts that are packaged in the sample JAR you added to the project, as shown when getpatientinfo was selected: 11

12 Chapter 2: Using extensions when creating Decision Services Because the two extension JARs are properties of the project, they are embedded in Decision Services that you package and deploy from Studio. The next section looks at the source code in each of their Java projects to gain insight into how extensions are created and prepared for use. 12

13 Reviewing what is in the sample extensions 3 Both the Extended Operator and Service Callout samples contain Java projects that show how you can create the sample extension JAR yourself, and a Corticon Rules project that demonstrates those extensions. There are two sets of extension samples: Extended Operator Sample Projects - The Extended Operators sample contains the source code for several extended operators and a rule project that uses them. The rule project uses extended operators for determining the future value or an investment, if a collection contains duplicate strings, and if a given date is a leap year. Service Callout Sample Projects - The Service Callout sample contains the source code for several service callouts and a rule project that uses them. The rule project uses service callouts to retrieve and update patient medical data in a pseudo external service. Accessing web services or other external datasources is a common use case for service callouts. For details, see the following topics: What's in the Extended Operators Sample Projects What's in the Service Callout Sample Projects 13

14 Chapter 3: Reviewing what is in the sample extensions What's in the Extended Operators Sample Projects The Extended Operator Java project contains a src folder with the source code for the extended operators and has on its build path the standard Java system library and CcExtensionApi.jar with the Corticon extension API: The src folder contains the source code for three Java classes that implement extended operators: The Extended Operator Rule Project is a set of rule assets that demonstrate the extended operator Java samples: The Extended Operator Rule project uses the extended operators and the supporting vocabulary, Ruleflows, and Ruletests for the project. It also contains the JAR file of the extensions built from the Java project, sample-extensions.jar. The sample project contains a Vocabulary, and three Rulesheets that demonstrate each of the new extended operators: 14

15 What's in the Service Callout Sample Projects 1. FutureValue - Determines years to retirement and the future value of the current investment with a constant interest rate. 2. RetireInLeapYear - Checks whether the retirement year is a leap year 3. DuplicateVendors - Checks to determine that there are not multiple accounts with the same vendor The Ruleflow chains the three Rulesheets together for the Ruletest to see that the extended operators behave as expected. What's in the Service Callout Sample Projects The Service Callout Java project contains a src folder with the source code for the service callouts and has on its build path the standard Java system library and CcExtensionApi.jar with the Corticon extension API: 15

16 Chapter 3: Reviewing what is in the sample extensions The src folder contains the source code for four Java classes that implement service callouts: The Service Callout Rule Project is a set of rule assets that demonstrate the Service Callout Java samples: The project uses the service callouts and the supporting vocabulary, Rulesheet, Ruleflow, and Ruletest for the project. It also contains the JAR file of the extensions built from the Java project, sample-callouts.jar. The Ruleflow uses three service callouts and a Rulesheet to perform its functions: The Ruletest shows that the service callouts behave as expected. 16

17 What's in the Service Callout Sample Projects 17

18 Chapter 3: Reviewing what is in the sample extensions 18

19 4 Code conventions For details, see the following topics: Using annotations Imports and interfaces used in extensions Using annotations Corticon extensions use Java annotations to get information about extensions. Corticon supports four types of annotations: Class - The name of the top level folder that will contain the extended operator. The operator tree supports two levels of folders; a top level folder and an operator folder. All operators defined in the class will be under a subfolder of the top level folder defined for the class.. Method - The text that describes the operator in the Rule operator tooltip or the description of the service callout in the Ruleflow properties. Note that this is typically the only annotation type used withh service - The name of the subfolder, under top level folder, for the operator defined by the method. Parameter annotations 19

20 Chapter 4: Code - The name of the argument shown in the function signature part of the tool tip. Localizing Annotations Annotations offer a format that allows localization. In its basic format, you can just You can choose to add a list of one or more locales with corresponding strings for each locale. For values={"text","texte") Creating multi-line annnotations Some annotations provide the help that the user sees when they hover over an operator in the Rule Operator tab. Often the description can be improved by adding line returns You can embed line returns in your description by using the "\n text" + convention, as = { "en", values = { " "\n Replace all occurrences of a substring" + "\n within a string" + "\n with another string." ) The following excerpt from AttributeOperators.java highlights usage of Corticon extension Extended Operators") public class AttributeOperators implements ICcDecimalExtension, ICcStringExtension, ICcDateTimeExtension = { "en", values = { "String" = { "en", values = { "Replace all occurences of a substring with a string with another string." ) public static String replaceall(string = { "en", values = { "searchstring" ) String = { "en", values = { "replacement" ) String replacement) {... Imports and interfaces used in extensions Imports The com.corticon.services.extension interfaces for an extended operator loads the four annotation types: import com.corticon.services.extensions.argumentname; import com.corticon.services.extensions.description; import com.corticon.services.extensions.operatorfolder; import com.corticon.services.extensions.toplevelfolder; While the com.corticon.services.extension interfaces for a service callout loads only one annotation type: import com.corticon.services.extensions.description; 20

21 Imports and interfaces used in extensions And then add the interfaces that are required for the data types used in the extended operator class from the following: import com.corticon.services.extensions.icccollectionextension; import com.corticon.services.extensions.iccdatetimeextension; import com.corticon.services.extensions.iccdecimalextension; import com.corticon.services.extensions.iccintegerextension; import com.corticon.services.extensions.iccsequenceextension; import com.corticon.services.extensions.iccstandaloneextension; import com.corticon.services.extensions.iccstringextension; While the service callout adds the following: import com.corticon.services.extensions.iccservicecalloutextension; import com.corticon.services.dataobject.iccdataobject; import com.corticon.services.dataobject.iccdataobjectmanager; Extended operator data type mappings The mapping of parameter and return types for Extended Operators are as follows: Java Type java.math.biginteger java.math.bigdecimal java.lang.boolean java.util.date java.lang.string Corticon Type Integer Decimal Boolean Date, Time or DateTime String 21

22 Chapter 4: Code conventions 22

23 5 Creating custom extended operators Note: Corticon Studio is built on Eclipse which provides a Java development environment you can use for creating Corticon extensions that you can use in current and future versions of Corticon. If you want to create extensions in a separate IDE, you must use Java 1.7.0_05 or higher. Note: You might want to simply copy the sample project Extended Operator Java Project, and then tweak a sample such as AttributeOperators.java by renaming the TopLevelFolder to mysampleextendedoperators for your first run. You can then go ahead to Building the Java classes and JARs on page 31. For many developers, the quickest way to learn is by example. You might want to compare the three Java source files in the Extended Operator Java Project to see what is common and what changes. In this example, the AttributeOperators.java is presented. 1. Specify the imports and interfaces you will need. package com.corticon.samples.extensions; import java.util.calendar; import java.util.date; import com.corticon.services.extensions.argumentname; import com.corticon.services.extensions.description; import com.corticon.services.extensions.iccdatetimeextension; import com.corticon.services.extensions.iccstringextension; import com.corticon.services.extensions.operatorfolder; import com.corticon.services.extensions.toplevelfolder; 23

24 Chapter 5: Creating custom extended operators This class imports the Corticon ICcStringExtension and ICcDateTimeExtension interfaces because it will implement extended operators for String and DateTime attributes. The other Corticon imports are for the annotations which will be used to describe the extensions. 2. Enter your comments that describe the class. /** * This class provides sample Corticon stand-alone extended operators. * Extended operators are a means to add custom features to Corticon for * use in Corticon rules. * * The samples in this class provide simple operators for calculating the * present and future value of an investment for a number of years at a given * interest rate. */ A general description of this source file is always good coding practice. It has no use outside of the source file. 3. Specify the TopLevelFolder Extended Operators") The TopLevelFolder annotation identifies the folder that will group the extended operators on the Rule Operators tab in Corticon Studio. You can name the folder to fit your needs, such as "My Operators", or "Financial Operators". 4. Specify the class and its implementations. public class AttributeOperators implements ICcStringExtension, ICcDateTimeExtension { 5. Name your operator folder, and use the locale parameters if = { "en", values = { "Date" ) The OperatorFolder defines the subfolder that will list an individual operator within the TopLevelFolder on the Rule Operators tab in Corticon Studio. You can organize and name folders to fit your needs. 6. Add your description of the operator, and use the locale parameters if = { "en", values = { "Returns true if the date is in a leap year." ) The Description annotation describes the specific operator. The hover help reveals what is passed, what is returned, and description text for the locale. 7. Write your actual implementation of the extended operator. It is always public static. public static Boolean isleapyear(date d) { if (d == null) return null; Calendar c = Calendar.getInstance(); c.settime(d); int year = c.get(calendar.year); if ((year % 400 == 0) ((year % 4 == 0) && (year % 100!= 0))) return true; else return false; The example takes a date and returns a boolean. It is up to you to determine that this produces the result you want, and that you can verify it across a range of values and error conditions. 24

25 8. The sample includes another operator definition using the same structure, this one for the String OperatorFolder. You can similarly change this section, or just cut the whole section out. /** * Replaces all occurrences of a substring in a string with another string. * s A string. searchstring The substring to look for in s. replacement The string to replace it with. The original string with all instances of searchstring replace by * replacement. = { "en", values = { "String" = { "en", values = { "Replace all occurrences of a substring within a string with another string." ) public static String replaceall(string = { "en", values = { "searchstring" ) String = { "en", values = { "replacement" ) String replacement) { if (s == null) return null; if (searchstring == null) return s; String r = s.replaceall(searchstring, replacement); return r; 9. Save your work, and then go ahead to Building the Java classes and JARs on page 31. Note: Compatibility of extensions created in an earlier release, any extension operators and service callouts that are in extended.core.jar are shared across all Rule Projects. As a result, such extensions are always in the Rule Operator tab in every editor. Then, you can add your extended operators and service callouts to specific Rule Projects using the new mechanism. 25

26 Chapter 5: Creating custom extended operators 26

27 6 Creating custom service callouts Service Call-out extensions are user-written functions that can be invoked in a Ruleflow. In a Ruleflow, the flow of control moves from Rulesheet to Rulesheet, with all Rulesheets operating on a common pool of facts. This common pool of facts is retained in the rule execution engine's working memory for the duration of the transaction. Connection arrows on the diagram specify the flow of control. Each Rulesheet in the flow may update the fact pool. When you add a Service Call-out to a Ruleflow diagram, you effectively instruct the system to transfer control to your extension class a specific point in the flow. Your extension can directly update the fact pool, and your updated facts are available to subsequent Rulesheets. Consider the sample: 27

28 Chapter 6: Creating custom service callouts The rule flow uses two service callouts (Get Patient Info and then Get Procedure History), then uses the data in the Determine Approval Rulesheet, and finally passes control to Service Callout extension class Save Approvals. Your Service Call-outs use the Progress Corticon Extension API to retrieve and update facts. The package com.corticon.services.dataobject contains two Java interfaces: Interface com.corticon.services.dataobject.iccdataobjectmanager com.corticon.services.dataobject.iccdataobject Purpose Provides access to the entire fact pool. Allows you to create, retrieve and remove entity instances. Provides access to a single entity instance. Allows you to update the entity instance, including setting attributes and creating and removing associations. Your Service Call-out class must implement marker interface ICcServiceCalloutExtension. Here is the source code for the service callout MedicalRecords.java: : /* * Copyright (c) 2016 by Progress Software Corporation. All rights reserved. */ package com.corticon.samples.extensions; import java.util.arraylist; import java.util.set; import com.corticon.services.dataobject.iccdataobject; import com.corticon.services.dataobject.iccdataobjectmanager; import com.corticon.services.extensions.description; import com.corticon.services.extensions.iccservicecalloutextension; import com.corticon.samples.simulation.*; /** * This class provides sample Corticon service callouts. Callouts provide * a means to add custom features to Corticon for use in Corticon ruleflows. * Callouts are for integrating with external systems such as webservices. * In a callout you can create and delete instances of Corticon entities, * set their properties and define associations. * * The samples in this class provide a simulation of retrieving patient * medical data given a patient id. The class MedicalDataSimulator provides * a static set of patient and procedure data. In a real implementation * this could be a class which gets data from a webservice, database, or * other source. * */ public class MedicalRecords implements ICcServiceCalloutExtension { private static MedicalDataSimulator md = new MedicalDataSimulator(); /** * Service callout to retrieve patient descriptive information for * the set of Corticon "Patient" entities. * * This callout demonstrates how to iterate over a set of Corticon * entities and set attributes on them. = { "en", values = { "Service callout to retrieve patient descriptive 28

29 information for the set of Corticon 'Patient' entities." ) Service Call-out methods must be declared public static. The system will recognize your Service Call-out method if the method signature takes one parameter and that parameter is an instance of ICcDataObjectManager. public static void getpatientinfo(iccdataobjectmanager dataobjmgr) { // Get the set of "Patient" entities. Set<ICcDataObject> patients = dataobjmgr.getentitiesbyname("patient"); if (patients!= null) { // Process each patient in the set. for (ICcDataObject patient : patients) { // Get the "id" attribute of the current patient. Long id = (Long) patient.getattributevalue("id"); if (id!= null) { // Get the simulated information for this patient. PatientData pd = md.getpatientdata(id.intvalue()); if (pd!= null) { // Set patient information as entity attributes. patient.setattributevalue("firstname",pd.getfirstname()); patient.setattributevalue("lastname", pd.getlastname()); /** * Service callout to retrieve history of medical procedures for the * set of Corticon "Patient" entities. * * This callout demonstrates how to create new Corticon entities and * associate them with existing Corticon entities. = { "en", values = { "Service callout to retrieve history of medical procedures for the set of Corticon 'Patient' entities." ) public static void getprocedurehistory(iccdataobjectmanager dataobjmgr) { // Get the set of "Patient" entities. Set<ICcDataObject> patients = dataobjmgr.getentitiesbyname("patient"); if (patients!= null) { // Process each patient in the set. for (ICcDataObject patient : patients) { // Get the "id" attribute of the current patient. Long id = (Long) patient.getattributevalue("id"); if (id!= null) { // Get the simulated information for this patient. PatientData pd = md.getpatientdata(id.intvalue()); // Get the medical procedure history for this patient. ArrayList<ProcedureData> td = pd.getprocedurerecords(); // Add procedures to the patient entity for (ProcedureData r : td) { // Create a new "Procedure" entity. ICcDataObject p = dataobjmgr.createentity("procedure"); // Set attributes on this entity. p.setattributevalue("code", r.getcode()); p.setattributevalue("description", r.getdescription()); p.setattributevalue("date", r.getdate()); // Associate it with the current patient. patient.addassociation("procedure", p); 29

30 Chapter 6: Creating custom service callouts /** * Service callout to save the approval state for each medical procedure * for a set of Corticon "Patient" entities. * * This callout demonstrates how to iterate over a set of entities and * associations to get the value of attributes. = { "en", values = { "Service callout to save the approval state for each medical procedure for a set of Corticon 'Patient' entities." ) public static void saveprocedureapproval(iccdataobjectmanager dataobjmgr) { // Get the set of "Patient" entities. Set<ICcDataObject> patients = dataobjmgr.getentitiesbyname("patient"); if (patients!= null) { // Process each patient in the set. for (ICcDataObject patient : patients) { // Get the "id" attribute of the current patient. Long id = (Long) patient.getattributevalue("id"); // Process each "Procedure" association on the patient. Set<ICcDataObject> procedures = patient.getassociations("procedure"); for (ICcDataObject procedure: procedures) { // Get the value of the "approved" and "code" attributes on the procedure. Boolean approved = (Boolean) procedure.getattributevalue("approved"); String code = (String) procedure.getattributevalue("code"); // Update the procedure record. md.setprocedureapproval(id.intvalue(), code, approved); Recognized classes and methods are displayed in the Ruleflow Properties View/Service Name drop-down list when a Service Call-out object is on a Ruleflow canvas: The Service Call-out API provides your extension class complete access to the fact pool, allowing you to: Find entities in several ways Read and update entity attributes Create and remove entity instances Create and remove associations Refer to Service Callout Java sample project and the API Javadocs for more information. 30

31 7 Building the Java classes and JARs Both the Extended Operator and Service Callout samples contain Java projects demonstrating how to create a Java extension. These are standard Java projects. Each has the CorticonCorticon JAR file that defines the API for Corticon extensions, CcExtensionApi.jar on its build path. When developing extensions in Corticon Studio, add this JAR to the Java Build Path using the predefined Eclipse variable CORTICON_HOME. For example: 31

32 Chapter 7: Building the Java classes and JARs 32

33 Deploying Decision Services with extensions 8 Once you have added extension jars to your project, several deployment tools provide mechanisms to package the extension JARs into deployment. When you compile a project Ruleflow into an EDS file, the extension JARs are encapsulated within the encrypted.eds. That insures that regardless how you relocate or update a Decision Service, the extension JARs that are associated with it are consistent. Deployment from Studio The three standard techniques in Studio that package and deploy Decision Services all incorporate the extension JARs that were associated with the project: Deploying directly to a server Deploying to a server through a Web Console application Packaging the EDS file locally for access by other tools or the Web Console to complete the deployment. Deployment using the Server's command line interface When you use the tool CorticonManagement at a server's [CORTICON_HOME]\Server\bin location, the compile command provides parameters that will declare dependent JARs and then include them. Both parameters take comma-separated values and both parameters are required to achieve the packaging into EDS file. -dj,--dependentjars dependentjar -ij,--includedjars includedjar add jar files required for this decision service add jar files to include in the generated eds file 33

34 Chapter 8: Deploying Decision Services with extensions A complete command might look like this: corticonmanagement --compile --input C:\myProject\myRuleflow.erf --output C:\myProject\Output --service MyDS --dependentjars C:\myProject\myExtensions.jar,C:\myProject\myCallouts.jar --includedjars C:\myProject\myExtensions.jar,C:\myProject\myCallouts.jar With only required options specified, the result is C:\myProject\Output\MyDS.eds Additions to Ant macro compile arguments If you want to use Ant macros for the corticonmanagement command line utilities that are in the file [CORTICON_HOME]\Server\lib\corticonAntMacros.xml, you can set the required extension JARs in the arguments for the compile macro so that you can use them in the call: <attribute name="input" default=""/> <attribute name="output" default="" /> <attribute name="service" default="" /> <attribute name="version" default="false" /> <attribute name="edc" default="false" /> <attribute name="failonerror" default="false" /> <attribute name="dependentjars" default="" /> <attribute name="includedjars" default="" /> Example of a call to the compile macro: <corticon-compile input="${project.home/order.erf" output="${project.home" service="orderprocessing" dependentjars="${project.home/myextensions.jar,${project.home/mycallouts.jar" includedjars="${project.home/myextensions.jar,${project.home/mycallouts.jar" /> Note: Deploymemt to a Corticon.NET Server - Once a project that includes extension JARs is packaged into a Decision Service, it deploys and performs as expected on Corticon.NET Server. 34

35 A Access to Corticon knowledge resources Complete online documentation for the current release Corticon online tutorials available in the Corticon Learning Center: Tutorial: Basic Rule Modeling in Corticon Studio Tutorial: Advanced Rule Modeling in Corticon Studio Modeling Progress Corticon Rules to Access a Database using EDC Connecting a Progress Corticon Decision Service to a Database using EDC Deploying a Progress Corticon Decision Service as a Web Service for Java Deploying a Progress Corticon Decision Service in process for Java Using Corticon Business Rules in a Progress OpenEdge Application Corticon guides (PDF): What's New in Corticon Corticon Installation Guide Corticon Studio: Rule Modeling Guide Corticon Studio: Quick Reference Guide Corticon Studio: Rule Language Guide Corticon Studio: Extensions Guide Corticon Server: Integration and Deployment Guide 35

36 Appendix A: Access to Corticon knowledge resources Corticon Server: Web Console Guide Corticon Server: Deploying Web Services with Java Corticon Server: Deploying Web Services with.net Corticon JavaDoc API reference (HTML): Corticon Server API CorticonExtensions API See also: Introducing the Progress Application Server Corticon documentation for this release on the Progress download site: What's New Guide (PDF), Installation Guide (PDF), PDF download package, and the online Eclipse help installed with Corticon Studio. 36