Network
Data Engineering
Data Engineering Integration
Enterprise Data Catalog
Enterprise Data Preparation
Cloud Integration
Cloud Application Integration
Cloud Data Integration
Cloud Customer 360
DiscoveryIQ
Cloud Data Wizard
Informatica for AWS
Informatica for Microsoft
Cloud Integration Hub
Complex Event Processing
Proactive Healthcare Decision Management
Proactive Monitoring
Real-Time Alert Manager
Rule Point
Data Integration
B2B Data Exchange
B2B Data Transformation
Data Integration Hub
Data Replication
Data Services
Data Validation Option
Fast Clone
Informatica Platform
Metadata Manager
PowerCenter
PowerCenter Express
PowerExchange
PowerExchange Adapters
Data Quality
Axon Data Governance
Data as a Service
Data Explorer
Data Quality
Data Security Group (Formerly ILM)
Data Archive
Data Centric Security
Secure@Source
Secure Testing
Master Data Management
Identity Resolution
MDM - Relate 360
Multidomain MDM
MDM Registry Edition
Process Automation
ActiveVOS
Process Automation
Product Information Management
Informatica Procurement
MDM - Product 360
Ultra Messaging
Ultra Messaging Options
Ultra Messaging Persistence Edition
Ultra Messaging Queuing Edition
Ultra Messaging Streaming Edition
Edge Data Streaming
Knowledge Base
Resources
PAM (Product Availability Matrices)
Support TV
Velocity (Best Practices)
Mapping Templates
Debugging Tools
User Groups
Documentation
English
English
English
Español
Spanish
Deutsch
German
Français
French
日本語
Japanese
한국어
Korean
Português
Portuguese
中文
Chinese
Log Out
Informatica ActiveVOS
Current Version
Current Version
2. Designer
Informatica ActiveVOS
All Products
Table of Contents
Search
No Results
Preface
Welcome to Informatica Process Developer
About Informatica Process Developer
Working in the Eclipse Environment
Migrating from Earlier Versions
Required Reset for Process Developer Perspectives
Migrating from Process Developer Versions Prior to 9.0
Migrating from Process Developer Versions Prior to 8.0.x
Opening and Using BPEL4WS 1.1 Processes
Migrating Processes from BPEL4WS 1.1 to WS-BPEL 2.0
Taking Advantage of SOAP 1.2 Port Binding Version 7.x
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
Project Explorer
Participants
Interfaces
Outline View
Problems View
Tasks View
Thumbnail View
Bookmarks View
Relationships View
Servers and Console Views
Status Bar
Guide Developer Debug Perspective
BPMN-Centric and BPEL-Centric Edit Styles
What is BPMN-Centric Style
What is BPEL-Centric Style
Comparing the BPMN-Centric and BPEL-Centric Tool Palettes
Which Edit Style to Choose BPMN-Centric or BPEL-Centric
Using Swimlanes
What is Guide Developer Classic Style
Using the Process Developer Process Editor
Process Editor Process Activities Tab
Process Editor Fault Handlers Tab
Process Editor Event Handlers Tab
Process Editor Compensation and Termination Handler Tabs
Process Editor Source Tab
Process Editor Source Tab
Setting Visual Properties and Using Your Own Library of Images
Adding Tasks and Bookmarks to the Process
Adding Comments to a Process
Adding Documentation to a Process
Tips for Designing on the Process Editor Canvas
Showing and Hiding Activities
Process Editor Keyboard Shortcuts
Process Developer Function Keys
Customizing the Process Developer Perspective
Process Developer Menus and Toolbars
Refactor
Go To Activity (Ctrl + l)
Open Operation (Ctrl + Shift + t o)
Open Port Type (Ctrl + Shift + t p)
Open Web Type (Ctrl + Shift + t w)
Optimize Parameters
Validate Process
Generate Process Report
Generate Process Image
Generate Deployment Image
Process Developer Preferences
B-Unit Preference
Cache and Timeout Preference
Colors and Fonts Preferences
Contribution Preference
Layout Preferences
Relationships View Preferences
Tasks and Problems Preferences
Identity Chooser Preference
Additional Preferences
Accessing Process Developer Help
About Interfaces Service References and Local WSDL
Importing a Local WSDL
Viewing Key Elements of a WSDL Tree
Editing a WSDL in the WSDL Editor
Deleting a WSDL from Your Project
Importing a Service Reference
Creating a New Interface
Creating a Java Interface
Setting up Your Java Project in Process Developer
Constraints for your Java Project
Generating WSDL and Schema from a Java Interface
Generating Argument Names for Schema Elements
Updating Your Java Project and Your BPEL Process Concurrently
Deployment Requirements for a Java (POJO) Endpoint
Deployment Requirements for Java (EJB) Endpoint
Running a BPEL Process with a POJO EJB Endpoint
Comparing the POJO EJB Interface to a Custom Java Invoke Handler
Using the Interfaces View to Create Activities
Interfaces Toolbar Options
Filtering the Interfaces View
System Services Interfaces
Creating a WSDL File with Extensions for BPEL
Using Sample Data for WSDL Messages
Adding or Editing a Sample Data Value for a Simple Type Message Part
Generating a Sample Data File
Adding a Sample Data File to a WSDL Message
Selecting a Default Sample Data File
Viewing the XML Structure of a Sample Data File
Removing a Sample Data File
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
Automatically Importing WSDL and Schema Locations
Manually Importing WSDL Schema and Other Resources
Refreshing Imports
Deleting an Import
Namespace Prefix and Declaration
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
Process Element and Properties
Partner Links
Variables
Activities
Fault Handlers
Compensation Handlers
BPEL XML Source and Implicitly Added Activities
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
Using the Participants View
Creating a New Process Service Consumer Interface
Creating a New Partner Service Interface
Creating a New Callback Interface
Clearing a Service Interface from a Participant
Creating New Activities from the Participants View
Creating a New Variable From an Activities Property View
What are Partner Link Types and Partner Links
Partner Link Type
Adding a new Partner Link Type from a WSDL in Project Explorer
Adding a new Partner Link Type to a new WSDL using a Service Reference WSDL
Add a new Partner Link Type from Interfaces View
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
About Gateway Types
Building a Gateway
Mutually Exclusive Transitions
Pick
Fork Join
If
While
Repeat Until
Scope
Setting Isolated to Yes in a Scope
Using a Termination Handler for a Scope
Lifecycle of a Scope
For Each
Sequence
Flow
Using Variables
Overview of Variables
Adding a Variable
WSDL Message Types
XML Schema Type
XML Schema Element
Adding Variable Properties and Property Aliases
Initializing a Variable
Viewing Variables
Quick View of Variables Used in Activities
Using the Process Variables View Options
Opening a Variable to View its Definition
Viewing Variable Properties
Understanding Icons Symbols and Descriptions of Variable Parts
Deleting a Variable
Using Sample Data in Process Variables View
Editing a Single Sample Data Value for a Simple Type Message Part
Loading a Sample Data File in Process Variables View
Saving and Viewing Sample Data in Process Variables View
Using the XML Data Wizard
Finding Variables Where Used
Using Variables in a Copy Operation
Creating a Copy Operation Using a Context Menu
Creating a Copy Operation Using Drag and Drop
Selecting a Copy Operation to Edit
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
Adding a Link with no Transition
Adding a Link with a Transition Condition
Link Examples
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
Using Content Assist
BPEL Functions
bpel doXslTransform(style-sheet-uri node-set)
bpel getVariableProperty(VariableName propertyName)
Process Developer Custom Functions General
abx base64Encode(stringValue charSet )
abx elementToXMLString(element)
abx getAllHTTPHeaders(partnerLinkName)
abx getHTTPHeader(partnerLinkName headerName)
abx getInboundSOAPHeader(partnerLinkName)
abx getProcessId()
abx getProcessInitiator() (1)
abx getProcessName()
abx isVariableInitialized(variable)
abx resolveURN(string)
abx setProcessTitle(titleString)
abx xmlStringToElement(string)
Attachment Functions
Boolean Functions
boolean(object)
not(boolean)
true()
false()
lang(string)
Catalog Functions
abx getCatalogResource(location)
abx putCatalogResource(location typeURI document)
Fault Functions
getFaultCode()
getFaultDetail()
getFaultString()
getSOAPFault()
I18N Functions
JSON Functions
jsonToXml(jsonString)
xmlToJson(element)
Node Set Functions
count(node-set)
id(object)
last()
local-name( node-set )
name( node-set )
namespace-uri( node-set )
position()
Number Functions
ceiling(number)
floor(number)
number(object)
round(number)
sum(node-set)
String Functions
concat(string1 string2 string3... )
normalize-space(string)
contains(string string)
starts-with(mainString lookForString)
string(object)
string-length(string)
substring(string number number )
substring-after(string string)
substring-before(string string)
translate(string string string)
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
Adding a Fault Handler for the Process
Adding a Fault Handler for a Scope
Adding a Fault Handler as a Boundary Event for an Invoke Activity
Selecting a Fault Name
Adding a Fault Variable Definition
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
Using the Process Developer Debug View
Using Breakpoints in BPEL Process Simulation
Using the Process Developer Debug Console
Simulating Execution of a BPEL Process
Prerequisites for Simulation
Starting and Ending Simulation of a BPEL Process
Running to a Breakpoint in a BPEL Process
Stepping to the Next Activity in a BPEL Simulation
Viewing the Execution State of an Activity or Link
Modifying a BPEL Process During Simulation
Terminating and Removing BPEL Process Simulations
Clearing the Process Execution State
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
Selecting an Invoke Subprocess for Simulation
Simulating Event Handlers
Simulating Fault Handlers
Inspecting Standard Faults During Simulation
Simulation Preferences
Disable bpel selectionFailure Fault Example
Auto Create Target Path for Copy To Example
Disable bpel selectionFailure Fault and Auto Create Target Path for Copy To Example
Setting Debug Preferences
Debugging Remote Processes Running on the Server
Configuring a Remote Process Connection
Selecting Processes for Remote Debugging
Setting Breakpoints on a Process for Remote Debugging
Using the Debug View Process Editor and Variable View for Remote Debugging
Remote Debugging Preferences
Selecting a Launch Configuration from the Toolbar
Checking for an Out of Sync Process
Server Interactions During a Remote Debugging Session
Setting Options for Console Output
Correcting Retrying or Completing Activities
Updating Variable Data in the Process Variables View
Updating Correlation Property Data
Updating Partner Link Address Information
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
Endpoint References and WS-Addressing Considerations
Endpoint References Requiring Credentials for Access
Specifying a Replaceable URN URL for an Endpoint Reference
Endpoint References and WS-Policy
Overview of Process Deployment Steps
Creating a Process Deployment Descriptor File
General Deployment Options
Partner Role Invoke Handlers
Partner Role Endpoint Types
My Role Binding Service Name and Allowed Roles Options
Selecting a Service for a Deployment Descriptor Partner Link
Using SOAP 1.1 or 1.2 Port Binding
Adding Policy Assertions
Authentication
Encryption
Engine-Managed Correlation
HTTP Transport
Invoke Recovery
JMS Delivery Options
Message Validation
REST Enabled
Retry
Run As User
SAML
Send WS-Addressing Headers
Signature
Suppress xsi type
Timestamp
Web Service Timeout
WS-Reliable Messaging
WSDL Binding Reference
Adding Indexed Properties
Eventing tab of the PDD
Viewing References
People tab of the PDD
Using the PDD Editor Source View
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
Prerequisite
Creating a B-unit Ant Script
Notes on Modifying a B-Unit Ant Script
Adding Multiple B-unit and B-suite to an Ant Script
Running a B-Unit Ant Script
Generating a Code Coverage Report
Editing a B-unit File
BPEL Unit (Root)
Extensions and Extension Activities
Invokes
Alarms
Commands
Debugging a B-unit Test
Creating and Running BPEL Unit Test Suites
Tips on Using Assertions
Tips on Using Parameterized XSL for Input and Assert Data
Tips on Providing Partner Link Data
Example B-unit File
Creating POJO and XQuery Custom Functions
Custom Functions Overview
Implementing the Function Context and Adding Annotations
Implementing: Step 1
Implementing: Step 2
Implementing: Step3
Sample Custom Function
Adding Global Custom Functions to the Process Server
Writing XQuery Functions
Using the XQuery Editor
Tips on Writing XQuery Functions
Testing XQuery Functions in the XQuery Editor
Custom Service Interactions
Using a REST-based Service
Creating a REST-based Receive or Invoke
BPEL REST Messages
Handling of Multipart HTTP Messages
Specifying Deployment Details for a REST-based Process
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
Making all Processes Eligible for Suspension on Uncaught Faults
Making Individual Processes Eligible for Suspension on Uncaught Faults
Suspending a Process Programmatically with a Suspend Activity
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
Understanding the Process Request Form Template
Editing HTML in Process Central Forms
Adding a New Service Operation for a Form or a Task
Customizing Task and Form Scripts An Introduction
Using the Process Developer SDK for Customizing Forms
Testing and Debugging Process Central Forms
Creating a Process Central Configuration File
Configuring Form Filters
Configuring Reports Filters
Including Your Own Styles Scripts and Meta Data for Process Central
Configuring Task Role Filters
Basic Task Roles Filter Configuration
Configuring Custom Columns for Task Roles Filtering
Configuring a GetMyTasks Filter with a WhereClause
Filtering a Task List using a Show Filter
Filtering a Task List by Parameter using a WS-HT whereClause
Presentation Parameters
Using a getMyTasks orderBy Element
Configuring an RSS or Atom Feed Filter
Deploying Forms Reports and Configuration Files
Adding Multilingual Support to Process Central
Displaying Process Central in a Web Browsers Preferred Language
Adding Multilingual Support for Forms and Tasks
Adding Multilingual Support for an .avcconfig File
Adding Multilingual Support for Reports
Naming Conventions for .properties File
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
Creating a BPEL Process that Executes Statements on a Data Source
Parameter-Based Request
Simulating the Data Access Invoke Output
Example-Response from an Insert Update or Delete Statement
Handling Binary Data
Fault Handling
Examples
Mapping Data Returned in the Data Access Response
Simulating the Data Access Service
Email Service
Identity Service
Migration Service
Input and Output for Create Map
Input and Output for Migrate
Creating a BPEL Process That Migrates Process Instances to a New Version
Testing Your Migration Process
Using the Process Server Migration Web Service
Monitoring Alert Service
Retry-Policy Service
Server Log Service
Shell Command Invoke Service
Human Tasks
Getting Started with Human Tasks
About the BPEL4People Specification
Introducing Human Workflow into a BPEL Process
Routing Tasks to People at Run Time
About Task Life Cycle
Creating the Artifacts Needed for the People Activity
Participants and Tasks
Creating a Human Task Participant
Using or Mapping Users or Groups From the Identity Service
Creating a Task for a Participant
Using BPEL4People Extension Elements and Activities
Human Interactions Extension Element
About Logical People Groups
Creating a Logical People From the Outline View
Logical People Group Parameters and Arguments
Using a Logical People Group in an Assign Activity
Selecting Users or Groups for Logical People Groups During Deployment
Using Logical People Groups for Role Assignments
Using Literal Values for Role Assignments
Using Expressions for Role Assignments
About Tasks
Adding a Task or Notification to the Outline View for Process or Scope Use
Required and Optional Properties for a Task
Task Name Interface and Priority
Adding a Task Interface
Role Assignments for a Task or Notification
Adding Task or Notification Presentation Properties
Configuring Presentation Parameters for a Task or Notification Subject or Description
Adding MultiLingual Support for Task Subject Description and Display Name
Adding a Content Type for a Task or Notification Description
Using the All Tab of a Task
Using Expressions for Outcome and Search By
About Task Deadlines and Escalations
Adding Start and Completion Deadlines and Alarms
Selecting an Escalation Action to Occur When a Task Deadline is Triggered
Defining a Condition for an Escalation Action
Using Task Data or Mapped Data for a Notification
Creating an Inline or Local Notification Action for a Task Deadline
Using a Reassignment Action for a Task Deadline
Invoking a Process When a Task Deadline Occurs
Sending Email When a Task Deadline Occurs
About Notifications
Required and Optional Properties for a Notification
Notification Name Priority and Interface
Using the All Tab of a Notification
Using the People Activity
What is a People Activity
Conceptual Overview of the People Activity
Adding a People Activity
Adding a People Activity from the BPMN Palette
Adding a People Activity Using the Participants View
Adding a People Activity Using the Create Activity Wizard
Adding a People Activity by Dragging a Guide
Required and Optional Properties of a People Activity
Creating an Inline Task or Notification
Selecting a Local Task or Notification
Selecting Overrides for Priority and People Assignments
Selecting Variables
Adding Scheduled Actions for Tasks
Sending and Receiving Attachments
Catching a Fault Thrown by the People Activity
Simulating Debugging Deploying
Simulating a Process with a People Activity
Simulating Comments Returned from a Task
Viewing Task Input Data While Simulating
Selecting a Logical People Group Handler During Deployment
Using or Mapping Users or Groups From the Identity Service
Adding a People Query
Using the Identity Chooser During Deployment
Running Your Process from the Process Server
Providing Renderings for Task Clients
About Task Presentation in Process Central
Rendering a Task Interface into a User Interface
Creating an Process Central Task Form
Creating a Task Form
Merging Input and Output Fields in a Task Form
Working in Development Mode or Production Mode
Understanding the Task Form Template
Examples of Task Forms for End Users
Adding a New Service Operation to a Task Form
Providing Multilingual Support for Task Forms
Deploying a Task Form and Properties Files
Creating an Process Central Configuration File for Tasks
Creating a Custom Rendering
Contributing a Custom Task Rendering Hint Editor
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
WS-HT Task Property List
Creating a Custom Task Property
Configuring Process Central Task Columns and Task Filters Using Properties
Creating Custom Escalation Actions
BPEL Faults and Reports
BPEL Standard Faults
User Reports Sample
2. Designer
2. Designer
Back
Next
Endpoint Reference Addressing Considerations
Endpoint Reference Addressing Considerations
Process Server supports a variety of addressing options to specify how, when, and where to reach the Web services invoked in a BPEL process. During the creation of the process deployment descriptor (PDD) file, you can add many address details.
Deploying Your Processes
Endpoint References and WS-Addressing Considerations
Endpoint References Requiring Credentials for Access
Specifying a Replaceable URN URL for an Endpoint Reference
Endpoint References and WS-Policy
Updated March 05, 2021
Download Guide
Send Feedback
Explore Informatica Network
Communities
Knowledge Base
Success Portal
Back to Top
Back
Next
