Preface
Welcome to Informatica Process Developer
- About Informatica Process Developer
- Working in the Eclipse Environment
- Migrating from Earlier Versions
- Saving From One Editing Style to Another (BPMN and Classic)
- Converting Legacy Deployments to Contributions
Using Guide Developer for the First Time
- Launching Process Developer
- Using the Workspace to Store Projects
- Creating an Orchestration Project
  - Changing the Default Location of a Workspace Project
  - Orchestration Project Templates
- Adding or Removing a Project Orchestration Nature
- About Project Orchestration and Validation Builders
- Using Project References
- Creating a New Process
  - Beginning a New Process
  - Selecting the BPMN-Centric or BPEL-Centric Palette
- Importing an Existing BPEL Process
- Importing a Visio XML Drawing File
- Begin Your First Project with Process Developer Assistance
- Setting Up the Embedded Process Server
- Process Developer Orchestration File Resources
Getting Started with Informatica Process Developer
- Using Source Control Systems
- Navigating Through Process Developer
- Windows Perspectives Views and Editors
- Process Developer Perspective
- Guide Developer Debug Perspective
- BPMN-Centric and BPEL-Centric Edit Styles
- Using the Process Developer Process Editor
- Customizing the Process Developer Perspective
- Process Developer Menus and Toolbars
- Process Developer Preferences
- Accessing Process Developer Help
About Interfaces Service References and Local WSDL
- Importing a Local WSDL
- Importing a Service Reference
- Creating a New Interface
- Creating a Java Interface
- Using the Interfaces View to Create Activities
- Creating a WSDL File with Extensions for BPEL
- Using Sample Data for WSDL Messages
- Finding Where a WSDL Component is Used
- Using Process Search
Planning Your BPEL Process
- Using Top-Down or Bottom-Up Process Design
- Using WSDL References for Efficient Design
  - Creating WSDL Extensions for BPEL
  - Starting a Process by Dropping an Operation onto the Process Editor
- Importing WSDL Schema and Other Resources
- Declaring Extensions
  - Using the Process Developer Create XPath Extension
  - Using the Process Developer Disable Selection Failure Fault Extension
- Declaring Extension Elements and Attributes
- Understanding BPEL Process Structure and Properties
- Understanding BPEL Process Lifecycle
- Creating an Executable vs. an Abstract Process
  - Creating an Abstract Process
  - Tips for Working with Abstract Processes
- Creating a BPEL Process as a Service for Another BPEL Process
- Message Exchange Declaration
Participants
- What are Participants
- What are Partner Link Types and Partner Links
- Partner Link Type
- Partner Link
- Using Scoped Partner Links
- Partner Links and Endpoint References
Implementing a BPMN Task or Event in BPEL
- BPMN-to-BPEL Implementation of Tasks and Events
- Overview of BPEL Activities
- Defining an Activity and Its Properties
  - Selecting Values for Activity Properties
  - Selecting Activity Labels
  - Standard Properties for Activities
  - Adding a Background Color to a Task Scope People Activity and Handlers
- Understanding and Using Activity Sequences and Flows
- Receive
- Reply
- Throw
- Rethrow
- Signal
- Exit
- Wait
- Compensate
- Compensate Scope
- Break
- Continue
- Start End None
- Invoke
  - From Part to Variable
  - From Variable to Part
  - Input Variable
  - Output Variable
- Assign
  - Tips for Copy Operations
  - Copy Operation Query and Expression Examples
  - Copy Operation Literal Contents Examples
  - Copy Operation Dynamic Endpoint Reference Example
  - Element to Element Copy Operation with Keep Source Element Name Attribute
  - Copy Operation with Ignore Missing From Data Attribute
- Empty
- Suspend
- Validate
- Opaque
- Creating a Custom Activity
- Creating an Activity by Starting with a WSDL Interface
Implementing a BPMN Gateway or Control Flow
- BPMN-to-BPEL Implementation of Gateways and Control Flow
- Different Ways of Structuring Activities
  - Overview of Control Flow Items
  - Ungrouping Selected Structured Activities
- Gateway
- Pick
- Fork Join
- If
- While
- Repeat Until
- Scope
- For Each
- Sequence
- Flow
Using Variables
- Overview of Variables
- Adding a Variable
- Adding Variable Properties and Property Aliases
- Initializing a Variable
- Viewing Variables
- Deleting a Variable
- Using Sample Data in Process Variables View
- Using the XML Data Wizard
- Finding Where Variables are Used
- Using Variables in a Copy Operation
- Using Variables Based on WSDL Fault Messages
- Mapping WSDL Message Parts in Web Service Interaction Activities
- Validating Variables
- Working with Variable Attachments
Attachments
- Adding an Attachment
- Adding an Attachment for Simulation
- Remote Debugging with Variable Attachments
- Custom Functions for Manipulating Attachments
- Attachment Custom Function Examples
Using Links
- What is a Link
- Process Developer Extension for Links
- Adding a Link Between Activities
- Execution Rules for Links
- Designing With Links vs. Structured Activities
- Links and the Join Condition
- Link Properties
Data Manipulation
- Overview of Data Manipulation in BPEL
- Selecting XPath or XQuery for Expression Building
  - Example XQuery Expressions
  - Example XPath Expressions
- Using the Expression Builder
- Expected Expressions for Conditions Counters and Other Values
- Using the Query Builder
- Creating a Join Condition for an Incoming Link
- Deadline and Duration Expressions
Compensation
- Compensation Handlers and Compensate Activities
  - Default-Order Compensation Example
  - Specified Compensation Example
- Adding a Compensation Handler to a Scope
- Compensating an Invoke Activity
Correlation
What is Correlation
What is a Correlation Set
- Properties
- Property Aliases
- WSDL Syntax and Example for Property Names and Aliases
- Global and Local Correlation Sets
Creating Message Properties and Property Aliases
- Creating a Property Definition
- Creating a Property Alias
Adding a Correlation Set
- XML Syntax
- Example
- Correlation Sets: Required and Optional Properties
Deleting a Correlation Set
Adding Correlations to an Activity
Rules for Declaring and Using Correlation Sets
Correlation Sets and Engine-Managed Correlation
Event Handling
- What is Event Handling
- Adding Event Handlers
  - Adding an onEvent Event Handler
  - Adding an onAlarm Event Handler
- Processing Rules for Events
- Adding Boundary Events
  - Catch and Catch All Boundary Events and Compensate Compensate Scope and Rethrow
  - Using a Variable from a Catch or Interrupting OnEvent Boundary Event
Fault Handling
- What is BPEL Fault Handling
- Defining Catch and CatchAll Fault Handlers
- Fault Handling for Service Invocations
- Adding a Fault Handler
- Fault Handling Processing Rules
- Rules for Catching Faults in a Catch Activity
- Tips on Fault Handling
- Catching Undeclared and SOAP Faults
Simulating and Debugging
- What is the Process Developer Debug Perspective
  - Opening the Process Developer Debug Perspective
  - Switching Between Process Developer Perspectives
- Process Developer Debug Perspective Views and Menus
- Simulating Execution of a BPEL Process
- Supplying and Inspecting Sample Variable Data During Simulation
  - Setting up Sample Data Values for Input Output and Fault Messages
  - Inspecting Process Variables during Simulation
- Selecting Simulation Paths and Properties
- Inspecting Standard Faults During Simulation
- Simulation Preferences
- Setting Debug Preferences
- Debugging Remote Processes Running on the Server
- Correcting Retrying or Completing Activities
- Monitoring Client Message Traffic with TCP IP Monitor
Deploying Your Processes
- Preparing for Deployment
  - Preparing BPEL Files for Deployment
  - Selecting a Server Platform for Deployed Processes
- Endpoint Reference Addressing Considerations
- Overview of Process Deployment Steps
- Creating a Process Deployment Descriptor File
- Creating and Deploying a Business Process Archive Contribution
  - Deploying Project Dependencies and Viewing Excluded Dependencies
  - Deploying Additional Resources
- Managing Deployment Contributions
- Using a BPRD Script to Regenerate and Deploy a BPR Contribution
  - Running a BPRD Ant Script from within Process Developer
  - Running a BPRD Ant Script from the Command Line
- Deployment Complete
- Starting the Server and Running a Process
- How a BPEL Process is Instantiated
- What is Process Versioning
BPEL Unit Testing
- What is BPEL Unit Testing
- Creating a BPEL Unit Test File
- Running a BPEL Unit Test in Process Developer
- Creating and Running a B-unit Ant Script
- Editing a B-unit File
- Debugging a B-unit Test
- Creating and Running BPEL Unit Test Suites
- Example B-unit File
Creating POJO and XQuery Custom Functions
- Custom Functions Overview
- Implementing the Function Context and Adding Annotations
- Sample Custom Function
- Adding Global Custom Functions to the Process Server
- Writing XQuery Functions
Custom Service Interactions
- Using a REST-based Service
- Using an OAuth REST-Based System Service
  - Creating an OAuth Service
  - Specifying Deployment Details for an OAuth Service Provider
- Using a Java Messaging Service Invoke Handler
Process Exception Management
- What is Process Exception Management
- Suspending a Process on Uncaught Faults
Creating Reports for Process Server and Central
- Creating the User Reports Orchestration Project
- Using the Process Developer Report Template
- Using the Process Developer Data Source
- Creating a Data Set from the Process Developer Data Source
- Understanding the Process Developer Data Model
- Deploying a Process Developer Report
- Updating or Deleting a Deployed Report
- Reporting Service
Business Event Processing
- Defining an Event in the Process Deployment Descriptor
- Using System-Defined Events
- Creating an Event-Action BPEL Process
- Activity States Event Properties Task States and Task Event Types
Process Central Forms and Configuration
- What is Process Central
- Creating a Process Central Process Form
- Testing and Debugging Process Central Forms
- Creating a Process Central Configuration File
- Configuring Task Role Filters
- Deploying Forms Reports and Configuration Files
- Adding Multilingual Support to Process Central
- Process Central Advanced Configuration
Building a Process with a System Service
- Using a BPEL Template for a System Service-Based Process
- Alert Service
- Data Access Service
- Email Service
- Identity Service
- Migration Service
- Monitoring Alert Service
- Retry-Policy Service
- Server Log Service
- Shell Command Invoke Service
Human Tasks
- Getting Started with Human Tasks
- Participants and Tasks
- Using the People Activity
- Simulating Debugging Deploying
- Providing Renderings for Task Clients
- Custom Functions
  - Human Tasks Custom Functions
  - WS-HT (Human Task) Custom Functions
- Using Customized Task Clients
  - What is the Informatica Business Process Manager WS-HumanTask API
  - Using the WS-HT and Identity Service SDK
- Creating Custom Task Properties
- Creating Custom Escalation Actions
BPEL Faults and Reports
- BPEL Standard Faults
- User Reports Sample

Designer

9.2.5
- 9.2.4.6

Back Next

bpel doXslTransform(style-sheet-uri node-set)

Returns the result of an XSL transformation of a single element node set using the specified style sheet.

Parameters:

style-sheet-uri

: URI for the XSL file.

node-set

: XPath node set providing the source document for the transformation.

Example syntax:

bpel:doXslTransform("project:/myStylesheets/A2B.xsl", $A)

Optional parameters (must appear in pairs if specified)

string

: XPath string parameter providing the qualified name of an XSLT parameter.

object

: XPath object parameter providing the value for the named XSLT parameter.

Examples

The following examples show complex document transformation and iterative document construction.

Example 1. Complex Document Transformation.

A common pattern in a WS-BPEL process involves receiving an XML document from one service, converting it to a different schema to form a new request message, and sending the new request to another service. Such document conversion can be accomplished using XSLT via the

bpel:doXslTransform

function, as shown in the following example.

<variables>
    <variable name="A" element="foo:AElement" />
    <variable name="B" element="bar:BElement" />
</variables>
...
<sequence>
    <invoke ... inputVariable="..." outputVariable="A" />
    <assign>
      <from>
           bpel:doXslTransform("urn:stylesheets:A2B.xsl", $A)
      </from>
      <to variable="B" />
    </assign>
    <invoke ... inputVariable="B" ... />
</sequence>

In the sequence, a service is invoked, and the result (

foo:AElement)

copied to variable A. The assign activity transforms the contents of variable A to

bar:BElement

, and copies the result to variable B. Variable B is used to invoke another service. The style sheet,

A2B.xsl

, contains the XSL rules for converting documents of schema

foo:AElement

to schema bar:BElement
.

Example 2. Iterative Document Construction.

Suppose that a document is constructed by repeatedly calling a service and accumulating the result in a variable, as shown in the following example:

<variables>
   <variable name="PO" element="foo:POElement" />
   <variable name="OutVar" element="foo:ItemElement" />
</variables>
<!-- ... PO is initialized ... -->
<!-- Iteratively add more items to PO until complete -->
<while>
   <condition>...</condition>
    <sequence>
       <!-- Fetch next chunk into OutVar -->
     <invoke ... inputVariable="..." outputVariable="OutVar"/>
      <assign>
         <copy>
          <from>
            <expression>
               bpel:doXslTransform
                 ( "urn:stylesheets:AddToPO.xsl",
                   $PO, "NewItem", $OutVar)
            </expression>
          </from>
          <to variable="PO" />
         </copy>
     </assign>
    </sequence>
</while>

The optional parameters given in the

doXslTransform

call specify that the XSLT parameter named

NewItem

is set with the value of the process variable

OutVar

. To allow the XSLT style sheet access to this value, it contains a global (top-level) parameter with a name matching that given in the third parameter of the function call shown above.

<xsl:transform version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" ...>
     <!-- NewItem variable set by WS-BPEL process; 
        defaults to empty item -->
    <xsl:param name="NewItem">
        <foo:itemElement />
    </xsl:param>
        ...
</xsl:transform>

The style sheet contains a template that appends the value of global parameter NewItem (the value of

OutVar

from the process instance) to the existing list of items in the PO variable.

<!-- line 1 -->  <xsl:template match="foo:itemElement">
<!-- line 2 -->  <xsl:copy-of select="." />
<!-- line 3 -->    <xsl:if test="position()=last()">
<!-- line 4 -->      <xsl:copy-of select="$NewItem" />
<!-- line 5 -->    </xsl:if>
<!-- line 6 -->  </xsl:template>

This template copies all existing items in the source document (lines 1 & 2) and appends the contents of the XSLT parameter

NewItem

to the list of items (lines 3 & 4). It tests to see if the current node is at the end of the item list (line 3) and copies the

result-tree

fragment from the XSLT parameter

NewItem

to follow the last item (line 4).

If PO has a value of:

<foo:poElement>
     <foo:itemElement>item 1</foo:itemElement>
</foo:poElement>

at the beginning of an iteration of the while loop and the invoke activity returns a value of

<foo:itemElement>item 2</foo:itemElement>

, evaluation of the from expression will result in a value of:

<foo:poElement>
     <foo:itemElement>item 1</foo:itemElement>
     <foo:itemElement>item 2</foo:itemElement>
</foo:poElement>

When the copy operation completes, it becomes the new value of the PO variable.

Adding an XSL Style Sheet to Process Server

A style sheet that you reference in a

doXslTransform

function is automatically recognized by Process Developer and is added to a BPR archive for deployment.

Rename Saved Search

Table of Contents

Designer

Designer

bpel doXslTransform(style-sheet-uri node-set)

bpel doXslTransform(style-sheet-uri node-set)