Skip to main content

Key Components

The Resource Library is essentially an indexed and searchable list of the key components that make up Enactor systems. The different types are briefly described below.

Actions

Actions have been discussed previously in the reference section. To find more information, click the button below.

More

Application Processes

These elements link Actions and States together and form the backbone of all Enactor Applications. Application Processes are implemented as XML files created by the Process Design Editor.

Business Processes

A Business Process is a high level flow of Actions and Tasks that operates across locations and Applications. They represent a business or customer-centric process operating within a business. They are implemented as XML files but are executed at runtime from a database.

Extension Points

The use of Extension Points in an Application requires two phases of Design implementation; one in the Original Code Base, to create the Extension Point as described in section Creating an Extension Point below and one in any (or each) variant context that will use it to enhance or override existing Processes of the Application, as described in the following section Using an Existing Extension Point.

Creating an Extension Point

Extension Points must be added on request into the Original Code Base by the responsible Designer.

Note: As an interim measure the Designer of the variant may use a Process Set to override the Process that will contain the Extension point and include the required Extension Point in the Override version. This version of the Process will also serve as a requirement specification for the Original Code Base.

Using an Existing Extension Point

A Variant application that will Extend or Override functionality based on an existing Extension Point in the Original Base Code will use a separate Eclipse Project in which to create all of the Design Elements associated with these extensions and a Packages.xml File in which to configure the Extensions. Package Extensions must be registered in the Packages.xml File. This Project will include, as a minimum, a deployments/Process/Extensions folder and a Packages.xml file under the META-INF folder. A convenient way to do this, after creating the new Eclipse Java Project, is to first select the Project in the Package Explored perspevctive and use the Right-mouse Menu to select Enactor>Add Deployment Folders. In the Add Deployment Folders Panel use the Select/Deselect All options and Checkboxes to specify requirements according to the Enactor Tools Design Elements that will be required.

After creating the required Processes and related Classes and other resources to be applied to the Extension Point the Designer can register the required Extension(s). In most cases only a single Process addition or Override is required, and execution order may not be important. However, if multiple Process Extensions are involved, or if there are other Projects using the same Extension Point the Designer may wish to influence the order of execution relative to other Extensions, which is controlled by reference to the Packages that contain them. The Designer therefore may need some insight to the relationshipa of Packages, Processes and Extensions.

Page Definitions

Page Definitions implement User Interface screens within Enactor Applications and are also implemented as XML files.

These describe the layout and format of dynamic documents. They are forms of Page Definitions and are also implemented as XML files.

Message Resources

Message Resources are XML files that contain the human-readable translations for texts and messages of User Interfaces.

Entities

Entities are serializable data objects, such as Address, Product and User. They are generally implemented as Java Classes with JAXB Annotations defining their properties. Entities may also be implemented as XML files, in which case they are referred to as Dynamic Entities.

Servers

A Server describes how an Entity is stored in a database. They consist of three parts. An Entity Mapping part describes how the properties of the Entity map to columns of a database table and is implemented as an XML file. A Server Definition part describes accessors such as listing methods, into the database table of an Entity. The final, optional part is a Java Class that contains custom handling that may be required such as specific SQL statements that may be used when accessing the database.

Activity types

Business Processes, as mentioned above, link activities together. These activities are of different types and these types are defined by the XML files that describe them. At runtime Activity Types operate from a database.

People Groups

When Business Processes execute, they allocate Tasks to individuals and groups of individuals. The definition of what constitutes a group of individuals valid for a particular task is defined in a People Group, which is implemented as an evaluator Java Class and XML files with a file extension of .htd.

Business Process Types

Business Processes themselves belong to certain types which are defined as XML files. The details and type of information define the context within which the Business Process runs.

BPEL

Business Process Execution Language (BPEL) elements are an industry standard for defining low level interactions and flows associated with Web Service calls. Enactor uses BPEL definitions in the form of diagrams as the low-level engine that executes Business Processes. BPEL definitions are implemented as XML files with .bpel file extensions.

Web Servers

These elements define the operations available on a given Web Service. They are standard XML format .wsdl files. The implementation of Web Servers is either Java classes or Application Processes.

Connected Processes

These are diagrams that show system level interactions between Applications and Web Services and Message Queues. They are implemented as XML files and are read by Applications when they initialise.

Schemas

These are the standard format XML files that are used by Enactor systems, which typically represent the Entities and Messages used in Web Service calls.