### WS-BPEL Flow Example with Links

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

An example demonstrating the use of <flow>, <link>, <source>, and <target> elements to define control flow dependencies between activities. This example shows links crossing boundaries of structured activities like <sequence>.

```xml
<flow>
<links>
<link name="XtoY" />
<link name="CtoD" />
</links>
<sequence name="X">
<sources>
<source linkName="XtoY" />
</sources>
<invoke name="A" ... />
<invoke name="B" ... />
</sequence>
<sequence name="Y">
<targets>
<target linkName="XtoY" />
</targets>
<receive name="C" ...>
<sources>
<source linkName="CtoD" />
</sources>
</receive>
<invoke name="E" ... />
</sequence>
<invoke name="D">
<targets>
<target linkName="CtoD" />
</targets>
</invoke>
</flow>
```

--------------------------------

### XPath 1.0 Examples in WS-BPEL Context

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Shows examples of how XPath 1.0 expressions are evaluated within the WS-BPEL context. These examples cover retrieving single XML infoset items, collections of items, sequences of CIIs for simple types, and variable references.

```xpath
$myFooVar/lines/line[2]
```

```xpath
$myFooVar/lines/*
```

```xpath
$myFooVar/lines/line[2]/text()
```

```xpath
$myFooVar
```

--------------------------------

### WS-BPEL 2.0: Example Flow with Links and Activities

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates a WS-BPEL 2.0 flow with 'toSkipped' and 'fromSkipped' links. This example demonstrates control dependencies between 'receive', 'empty' (within an 'if'), and 'reply' activities, showing how transitive dependencies are maintained even when an activity is skipped.

```xml
<flow>
<links>
<link name="toSkipped" />
<link name="fromSkipped" />
</links>
<receive ...>
<sources>
<source linkName="toSkipped" />
</sources>
...
</receive>
<if>
<condition>
... <!-- evaluates to false -->
</condition>
<empty name="skipped">
<targets>
<target linkName="toSkipped">
</targets>
<sources>
<source linkName="fromSkipped">
</sources>
</empty>
</if>
<reply ...>
<targets>
<target linkName="fromSkipped" />
</targets>
</reply>
</flow>
```

--------------------------------

### WS-BPEL Query/Expression Example

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Provides an example of a WS-BPEL fragment demonstrating the usage of a query or expression within a `<from>` element. This illustrates how a variable reference is used in an expression.

```xml
<from>$myVar/abc/def</from>
```

--------------------------------

### Illegal WS-BPEL Flow with Non-Start Activity

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This example illustrates an illegal WS-BPEL flow where an `<assign>` activity follows a `<receive>` activity marked with `createInstance="yes"`. In WS-BPEL, non-start activities must have a control dependency on a start activity.

```xml
<flow>
<!-- this example is illegal -->
<receive ... createInstance="yes" />
<assign ... />
</flow>
```

--------------------------------

### WS-BPEL 2.0: Catch Construct Examples

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates different configurations of the <catch> construct in WS-BPEL 2.0, demonstrating matching by faultName, faultVariable, and faultMessageType.

```xml
<faultHandlers>
<catch faultName="x:foo">
<empty />
</catch>
<catch faultVariable="bar" faultMessageType="tns:barType">
<empty />
</catch>
<catch faultName="x:foo" 
faultVariable="bar"
faultMessageType="tns:barType">
<empty />
</catch>
<catchAll>
<empty />
</catchAll>
</faultHandlers>
```

--------------------------------

### WS-BPEL 2.0 Variable Declaration Example with Namespace

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This example shows a concrete instance of a variable declaration, including a namespace prefix and a qualified name for the message type. This demonstrates how to use namespaces in BPEL variable definitions.

```xml
<variable xmlns:ORD="http://example.com/orders" 
name="orderDetails" messageType="ORD:orderDetails" />
```

--------------------------------

### EII-to-EII Comparison Copy in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Provides a comparative example of an EII-to-EII copy operation, distinct from EII-to-TII. This example copies the entire 'approvedLimit' element to 'approvalNotice4Var', including its attributes.

```xml
<assign>
  <copy>
    <from>$creditApprovalVar/tns:approvedLimit</from>
    <to>$approvalNotice4Var</to>
  </copy>
</assign>
```

--------------------------------

### WS-BPEL 2.0 Process with Extensions and Documentation

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

An example of a WS-BPEL 2.0 abstract process demonstrating the use of extension attributes and documentation tags. It shows how to declare extensions, define partner links with documentation, and use opaque activities with embedded documentation for process steps.

```xml
<process name="templateExample1-HomeAppraisal"
xmlns="http://docs.oasis-open.org/wsbpel/2.0/process/abstract"
targetNamespace="http://example.org/template-example-1"
xmlns:tns="http://example.org/template-example-1"
suppressJoinFailure="yes"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:ext="http://example.com/bpel/some/extension"
xmlns:template="http://docs.oasis-open.org/wsbpel/2.0/process/abstract/simple-template/2006/08"
abstractProcessProfile="http://docs.oasis-open.org/wsbpel/2.0/process/abstract/simple-template/2006/08">
<extensions>
<extension
namespace="http://example.com/bpel/some/extension"
mustUnderstand="yes" />
</extensions>
<partnerLinks>
<!-- example explanatory note: none of the 3
referenced partnerLinks have been declared -->
<partnerLink name="homeInfoVerifier" 
partnerLinkType="##opaque"
myRole="##opaque" 
partnerRole="##opaque">
<documentation>
We have not confirmed our home information verification
partner yet.
</documentation>
</partnerLink>
</partnerLinks>
<variables>
<variable name="commonRequestVar" element="##opaque" />
</variables>
<sequence>
<opaqueActivity template:createInstance="yes">
<documentation>
Pick an appraisal request from one of 3 customer referral
channels.
</documentation>
</opaqueActivity>
<assign>
<documentation>
Transform one of these 3 appraisal request into our own
format.
</documentation>
<copy>
<opaqueFrom/>
<to variable="commonRequestVar" />
</copy>
</assign>
<scope>
<faultHandlers>
<!-- example explanatory note: One can add a new <catch>
faultHandler for a fault from the "homeInfoVerifier" 
partnerLink of unspecified portType yet -->
<catchAll>
<exit />
</catchAll>
</faultHandlers>
<sequence>
<opaqueActivity>
<documentation>
Extract customer and housing info from our appraisal
request into a message understood by our home info
verification partner.
</documentation>
</opaqueActivity>
<invoke partnerLink="homeInfoVerifier"
operation="##opaque" inputVariable="##opaque"
ext:uniqueUserFriendlyName="request verification" />
<receive partnerLink="homeInfoVerifier"
operation="##opaque" variable="##opaque"
ext:uniqueUserFriendlyName="receive verification 
result" />
<reply partnerLink="homeInfoVerifier" operation="##opaque"
variable="##opaque"
ext:uniqueUserFriendlyName="confirm receipt of 
verification result">
<documentation>
This step confirms whether we have received the
verification result. It is intended to match the
"receive verification result" step.
</documentation>
</reply>
</sequence>
</scope>
<opaqueActivity>
<documentation>
Relay the appraisal request and home info verification to
an appraiser, who is responsible for on-site inspection.
The appraiser may request further verification info from
the partner through this business process. We will also
receive the results of the appraisal from this step.
</documentation>
<!-- example explanatory note: An unspecified
referral channel may trigger more than one unexpected 
fault in this process. -->
</opaqueActivity>
<opaqueActivity>
<documentation>
Send the appraisal result back to the corresponding
referral channel.
</documentation>
<!-- example explanatory note: An unspecified
referral channel may trigger more than one unexpected 
fault in this process. -->
</opaqueActivity>
</sequence>
</process>
```

--------------------------------

### WS-BPEL 2.0: Flow with Receive and Assign Activities

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

An example illustrating the allowed sequence of <receive> and <assign> activities within a <flow> in WS-BPEL 2.0. This demonstrates how the <assign> activity can follow a <receive> activity without violating execution order constraints.

```xml
<flow>
<links>
<link name="RecvToAssign" />
</links>
<receive ... createInstance="yes">
<sources>
<source linkName="RecvToAssign" />
</sources>
</receive>
<assign>
<targets>
<target linkName="RecvToAssign" />
</targets>
...
</assign>
</flow>
```

--------------------------------

### WS-BPEL 2.0 Partner Link Type Declaration Example

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates the basic syntax for declaring a `<partnerLinkType>` in WS-BPEL, defining roles and their corresponding WSDL `portType`s.

```xml
<plnk:partnerLinkType name="BuyerSellerLink">
<plnk:role name="Buyer" portType="buy:BuyerPortType" />
<plnk:role name="Seller" portType="sell:SellerPortType" />
</plnk:partnerLinkType>
```

--------------------------------

### WS-BPEL Example Variable Declaration (Message Type)

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

An example of a WS-BPEL variable declaration using a message type defined in a WSDL document. It demonstrates how to reference a WSDL message type using a qualified name (QName).

```xml
<variable xmlns:ORD="http://example.com/orders" 
name="orderDetails"
messageType="ORD:orderDetails" />
```

--------------------------------

### WS-BPEL 2.0: Invoke with Local Handlers

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Example of an <invoke> activity in WS-BPEL 2.0 that includes local catch and compensationHandler elements. This demonstrates the direct attachment of fault and compensation logic to an invoke operation.

```xml
<invoke name="purchase" 
suppressJoinFailure="yes" 
partnerLink="Seller"
portType="SP:Purchasing"
operation="Purchase"
inputVariable="sendPO"
outputVariable="getResponse">
<targets>
<target linkName="linkA" />
</targets>
<sources>
<source linkName="linkB" />
</sources>
<catch faultName="SP:rejectPO">...</catch>
<compensationHandler>
<invoke partnerLink="Seller" 
portType="SP:Purchasing"
operation="CancelPurchase"
inputVariable="getResponse"
outputVariable="getConfirmation" />
</compensationHandler>
</invoke>
```

--------------------------------

### WS-BPEL 2.0 Variable Declaration Syntax Example

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This snippet illustrates the informal syntax for declaring a variable within a BPEL process. It shows the structure of the <variable> element and its attributes, including optional fields and cardinality.

```xml
<variables>
<variable name="BPELVariableName" 
messageType="QName"? 
type="QName"? 
element="QName"?>+
from-spec?
</variable>
</variables>
```

--------------------------------

### WS-BPEL 2.0: Equivalent Scope with Handlers

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This XML snippet shows the WS-BPEL 2.0 equivalent of the previous <invoke> example. It uses a <scope> activity to encapsulate the <invoke> and includes faultHandlers and a compensationHandler, demonstrating semantic equivalence.

```xml
<scope name="purchase" suppressJoinFailure="yes">
<targets>
<target linkName="linkA" />
</targets>
<sources>
<source linkName="linkB" />
</sources>
<faultHandlers>
<catch faultName="SP:rejectPO">...</catch>
</faultHandlers>
<compensationHandler>
<invoke partnerLink="Seller" 
portType="SP:Purchasing"
operation="CancelPurchase"
inputVariable="getResponse"
outputVariable="getConfirmation" />
</compensationHandler>
<invoke name="purchase" 
partnerLink="Seller"
portType="SP:Purchasing"
operation="Purchase"
inputVariable="sendPO"
outputVariable="getResponse" />
</scope>
```

--------------------------------

### Example Service Reference Container in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Demonstrates the structure of a service reference container (`<sref:service-ref>`) used in WS-BPEL for wrapping endpoint references. It shows the use of the `reference-scheme` attribute and a child element representing the actual EPR.

```xml
<sref:service-ref reference-scheme="http://example.org">
<foo:barEPR xmlns:foo="http://example.org">...</foo:barEPR>
</sref:service-ref>
```

--------------------------------

### BPEL Flow with Dead Path Elimination Example

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This BPEL snippet demonstrates the use of a <flow> activity with the suppressJoinFailure attribute set to 'yes'. It defines links and join conditions to illustrate concurrent execution of activities and the impact of DPE when link conditions are not met.

```xml
<flow suppressJoinFailure="yes">
<links>
<link name="buyToSettle" />
<link name="sellToSettle" />
<link name="toBuyConfirm" />
<link name="toSellConfirm" />
</links>
<receive name="receiveBuyerInformation" ...>
<sources>
<source linkName="buyToSettle" />
</sources>
</receive>
<receive name="receiveSellerInformation" ...>
<sources>
<source linkName="sellToSettle" />
</sources>
</receive>
<invoke name="settleTrade" ...>
<targets>
<joinCondition>$buyToSettle and $sellToSettle</joinCondition>
<target linkName="buyToSettle" />
<target linkName="sellToSettle" />
</targets>
<sources>
<source linkName="toBuyConfirm" />
<source linkName="toSellConfirm" />
</sources>
</invoke>
<reply name="confirmBuyer" ...>
<targets>
<target linkName="toBuyConfirm" />
</targets>
</reply>
<reply name="confirmSeller" ...>
<targets>
<target linkName="toSellConfirm" />
</targets>
</reply>
</flow>
```

--------------------------------

### WS-BPEL 2.0: forEach Counter Values

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Details the WS-BPEL 2.0 elements for defining counter values within a `<forEach>` loop, including start, final, and branches.

```xml
<startCounterValue expressionLanguage="anyURI"? opaque="yes"/>
<finalCounterValue expressionLanguage="anyURI"? opaque="yes"/>
<branches ... expressionLanguage="anyURI"? opaque="yes"/>
```

--------------------------------

### WS-BPEL Assign Example with XPath Expressions

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

A WS-BPEL assignment snippet showcasing the use of XPath 1.0 expressions involving multiple variables and arithmetic operations to transform data between different parts of a BPEL process.

```xml
<assign>
  <copy>
    <from>$po/lineItem[@prodCode=$myProd]/amt * $exchangeRate</from>
    <to>$convertedPO/lineItem[@prodCode=$myProd]/amt</to>
  </copy>
</assign>
```

--------------------------------

### WS-BPEL 2.0 Flow Example with Parallel Invokes

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates the use of the <flow> activity in WS-BPEL 2.0 to execute two <invoke> activities concurrently. The 'transferMoney' <invoke> is executed only after both the seller and shipper responses are received, demonstrating synchronization.

```xml
<sequence>
<flow>
<invoke partnerLink="Seller" ... />
<invoke partnerLink="Shipper" ... />
</flow>
<invoke partnerLink="Bank" name="transferMoney" ... />
</sequence>
```

--------------------------------

### WS-BPEL Flow with Explicit Links and Default Transition Conditions

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This WS-BPEL 2.0 example rewrites a previous flow by using explicit links between activities A, B, and C, instead of a sequence. It includes default transition conditions (implicitly 'true') for links AtoB and BtoC. With a disjunction as the default join condition and a 'true' transition condition for AtoB, the join condition for B will always evaluate to true, ensuring B and C are executed.

```xml
<flow suppressJoinFailure="no">
<links>
<link name="XtoB" />
<link name="YtoB" />
<link name="AtoB" />
<link name="BtoC" />
</links>
<receive name="X">
<sources>
<source linkName="XtoB">
<transitionCondition>P:funcXB()</transitionCondition>
</source>
</sources>
</receive>
<receive name="Y">
<sources>
<source linkName="YtoB">
<transitionCondition>P:funcYB()</transitionCondition>
</source>
</sources>
</receive>
<receive name="A">
<sources>
<source linkName="AtoB" />
</sources>
</receive>
<receive name="B">
<targets>
<target linkName="AtoB" />
<target linkName="XtoB" />
<target linkName="YtoB" />
</targets>
<sources>
<source linkName="BtoC" />
</sources>
</receive>
<receive name="C">
<targets>
<target linkName="BtoC" />
</targets>
</receive>
</flow>
```

--------------------------------

### WS-BPEL 2.0 Scope with Invokes and Fault Handlers

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

An example illustrating a WS-BPEL 2.0 <scope> containing a primary <flow> activity with two concurrent <invoke> activities. It also shows the declaration of <faultHandlers> that are shared by both invoke activities, demonstrating how to catch potential fault responses.

```xml
<scope>
<faultHandlers>...</faultHandlers>
<flow>
<invoke partnerLink="Seller" 
portType="Sell:Purchasing"
operation="Purchase" 
inputVariable="sendPO"
outputVariable="getResponse" />
<invoke partnerLink="Shipper" 
portType="Ship:TransportOrders"
operation="OrderShipment" 
inputVariable="sendShipOrder"
outputVariable="shipAck" />
</flow>
</scope>
```

--------------------------------

### WS-BPEL: Iterative Document Construction with bpel:doXslTransform and Global Parameters

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This example illustrates how to iteratively build an XML document in WS-BPEL using bpel:doXslTransform. It shows how to pass a WS-BPEL variable as an XSLT global parameter (named 'NewItem') to an XSLT stylesheet for appending data within a loop.

```xml
<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>
bpel:doXslTransform( "urn:stylesheets:AddToPO.xsl",
$PO, "NewItem", $OutVar)
</from>
<to variable="PO" />
</copy>
</assign>
</sequence>
</while>
```

--------------------------------

### WS-BPEL 2.0 Purchase Order Process Definition

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

The main WS-BPEL process definition for handling a purchase order. It includes documentation, partner link definitions, and placeholders for variables and fault handlers. This sets up the interaction with various services.

```xml
<process name="purchaseOrderProcess"
targetNamespace="http://example.com/ws-bp/purchase"
xmlns="http://docs.oasis-open.org/wsbpel/2.0/process/executable"
xmlns:lns="http://manufacturing.org/wsdl/purchase">
<documentation xml:lang="EN">
A simple example of a WS-BPEL process for handling a purchase
order.
</documentation>
<partnerLinks>
<partnerLink name="purchasing" 
partnerLinkType="lns:purchasingLT" myRole="purchaseService" />
<partnerLink name="invoicing" partnerLinkType="lns:invoicingLT" 
myRole="invoiceRequester" partnerRole="invoiceService" />
<partnerLink name="shipping" partnerLinkType="lns:shippingLT" 
myRole="shippingRequester" partnerRole="shippingService" />
<partnerLink name="scheduling"
```

--------------------------------

### WS-BPEL 2.0: Isolated Scope Definition

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Example of defining an isolated scope in WS-BPEL 2.0. The 'isolated="true"' attribute ensures that concurrent access to shared resources within this scope is controlled. This example includes a compensation handler for undoing operations.

```xml
<scope name="Q" isolated="true">
  <compensationHandler>
    <sequence name="undoQ_Seq">...</sequence>
  </compensationHandler>
  <sequence name="doQ_Seq">...</sequence>
</scope>
```

--------------------------------

### WS-BPEL Invoke Activity Syntax

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This snippet shows the general syntax for the WS-BPEL <invoke> activity. It includes attributes for specifying the partner, operation, and variables for input and output. Optional elements for correlations, fault handling, and parts are also outlined.

```xml
<invoke partnerLink="NCName"
portType="QName"?
operation="NCName"
inputVariable="BPELVariableName"?
outputVariable="BPELVariableName"
standard-attributes>
standard-elements
<correlations>?
<correlation set="NCName" initiate="yes|join|no"?
pattern="request|response|request-response"? />+
</correlations>
<catch faultName="QName"?
faultVariable="BPELVariableName"?
faultMessageType="QName"?
faultElement="QName"?>*
activity
</catch>
<catchAll>?
activity
</catchAll>
<compensationHandler>?
activity
</compensationHandler>
<toParts>?
<toPart part="NCName" fromVariable="BPELVariableName" />+
</toParts>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
</invoke>
```

--------------------------------

### WS-BPEL Flow with Synchronization Dependencies (suppressJoinFailure='yes')

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This WS-BPEL 2.0 example shows a flow where 'suppressJoinFailure' is set to 'yes'. Similar to the previous example, it involves synchronization dependencies on activity B from activities X and Y. However, when 'suppressJoinFailure' is 'yes', the bpel:joinFailure fault is suppressed, allowing activity C to execute even if the join condition for B is not met.

```xml
<flow suppressJoinFailure="yes">
<links>
<link name="XtoB" />
<link name="YtoB" />
</links>
<receive name="X" ...>
<sources>
<source linkName="XtoB">
<transitionCondition>P:funcXB()</transitionCondition>
</source>
</sources>
...
</receive>
<receive name="Y" ...>
<sources>
<source linkName="YtoB">
<transitionCondition>P:funcYB()</transitionCondition>
</source>
</sources>
...
</receive>
<sequence name="S">
<receive name="A" ...>...</receive>
<receive name="B" ...>
<targets>
<target linkName="XtoB" />
<target linkName="YtoB" />
</targets>
</receive>
<receive name="C" ... />
</sequence>
</flow>
```

--------------------------------

### WS-BPEL 2.0 Auction Service Process Definition

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This snippet defines the main WS-BPEL 2.0 process for an auction service. It includes imports, partner links for seller, buyer, and registration services, variable declarations, correlation sets, and the core sequence of operations. It handles concurrent reception of seller and buyer information, invokes an auction registration service, and sends responses back to the seller and buyer.

```bpel
<process name="auctionService"
targetNamespace="http://example.com/auction"
xmlns="http://docs.oasis-open.org/wsbpel/2.0/process/executable"
xmlns:sref=" http://docs.oasis-open.org/wsbpel/2.0/serviceref"
xmlns:addr="http://example.com/addressing"
xmlns:as="http://example.com/auction/wsdl/auctionService/">
<import importType="http://schemas.xmlsoap.org/wsdl/"
location="auctionServiceInterface.wsdl"
namespace="http://example.com/auction/wsdl/auctionService/" />
<partnerLinks>
<partnerLink name="seller"
partnerLinkType="as:sellerAuctionHouseLT"
myRole="auctionHouse" 
partnerRole="seller" />
<partnerLink name="buyer"
partnerLinkType="as:buyerAuctionHouseLT"
myRole="auctionHouse" 
partnerRole="buyer" />
<partnerLink name="auctionRegistrationService"
partnerLinkType="as:auctionHouseAuctionRegistrationServiceLT"
myRole="auctionHouse"
partnerRole="auctionRegistrationService" />
</partnerLinks>
<variables>
<variable name="sellerData" 
messageType="as:sellerData" />
<variable name="sellerAnswerData"
messageType="as:sellerAnswerData" />
<variable name="buyerData" 
messageType="as:buyerData" />
<variable name="buyerAnswerData"
messageType="as:buyerAnswerData" />
<variable name="auctionData" 
messageType="as:auctionData" />
<variable name="auctionAnswerData"
messageType="as:auctionAnswerData" />
</variables>
<correlationSets>
<correlationSet name="auctionIdentification"
properties="as:auctionId" />
</correlationSets>
<sequence>
<!-- Process buyer and seller request concurrently
Either one can create a process instance -->
<flow>
<!-- Process seller request -->
<receive name="acceptSellerInformation" 
partnerLink="seller"
portType="as:sellerPT" 
operation="submit"
variable="sellerData" 
createInstance="yes">
<correlations>
<correlation set="auctionIdentification"
initiate="join" />
</correlations>
</receive>
<!-- Process buyer request -->
<receive name="acceptBuyerInformation" 
partnerLink="buyer"
portType="as:buyerPT" 
operation="submit"
variable="buyerData" 
createInstance="yes">
<correlations>
<correlation set="auctionIdentification"
initiate="join" />
</correlations>
</receive>
</flow>
<!-- Invoke auction registration service by setting the target 
endpoint reference and setting my own endpoint reference 
for call back and receiving the answer Correlation of 
request and answer is via auction Id -->
<assign>
<copy>
<from>
<literal>
<sref:service-ref>
<addr:EndpointReference>
<addr:Address>
http://example.com/auction/
RegistrationService/
</addr:Address>
<addr:ServiceName>
as:RegistrationService
</addr:ServiceName>
</addr:EndpointReference>
</sref:service-ref>
</literal>
</from>
<to partnerLink="auctionRegistrationService" />
</copy>
<copy>
<from partnerLink="auctionRegistrationService"
endpointReference="myRole" />
<to>$auctionData.auctionHouseEndpointReference</to>
</copy>
<copy>
<from>$sellerData.auctionId</from>
<to>$auctionData.auctionId</to>
</copy>
<copy>
<from>1</from>
<to>$auctionData.amount</to>
</copy>
</assign>
<invoke name="registerAuctionResults"
partnerLink="auctionRegistrationService"
portType="as:auctionRegistrationPT" 
operation="process"
inputVariable="auctionData" />
<receive name="receiveAuctionRegistrationInformation"
partnerLink="auctionRegistrationService"
portType="as:auctionRegistrationAnswerPT" 
operation="answer"
variable="auctionAnswerData">
<correlations>
<correlation set="auctionIdentification" />
</correlations>
</receive>
<!-- Send responses back to seller and buyer -->
<flow>
<!-- Process seller response by setting the seller to 
the endpoint reference provided by the seller
and invoking the response -->
<sequence>
<assign>
<copy>
<from>$sellerData.endpointReference</from>
<to partnerLink="seller" />
</copy>
<copy>
<from>
<literal>Thank you!</literal>
</from>
<to>$sellerAnswerData.thankYouText</to>
</copy>
</assign>
<invoke name="respondToSeller" 
partnerLink="seller"
portType="as:sellerAnswerPT" 
operation="answer"
inputVariable="sellerAnswerData" />
</sequence>
<!-- Process buyer response by setting the buyer to 
the endpoint reference provided by the buyer
and invoking the response -->
<sequence>
<assign>
<copy>
<from>$buyerData.endpointReference</from>
<to partnerLink="buyer" />
</copy>
<copy>
<from>
<literal>Thank you!</literal>
</from>
<to>$buyerAnswerData.thankYouText</to>
</copy>
</assign>
<invoke name="respondToBuyer" 
partnerLink="buyer"
portType="as:buyerAnswerPT" 
operation="answer"
inputVariable="buyerAnswerData" />
</sequence>
</flow>
</sequence>
</process>
```

--------------------------------

### WS-BPEL 2.0 Ordering Service Process Definition

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

The main WS-BPEL 2.0 process definition for the Ordering Service. It includes imports, partner links, variables, correlation sets, and the core sequence of activities.

```xml
<process name="OrderingServiceProcess"
targetNamespace="http://example.com/ordering/"
xmlns="http://docs.oasis-open.org/wsbpel/2.0/process/abstract"
xmlns:ext="http://example.com/bpel/some/extension"
xmlns:oif="http://example.com/ordering/interfaces/"
xmlns:order="http://example.com/ordering/order.xsd"
xmlns:plt="http://example.com/ordering/partnerLinkTypes/"
xmlns:props="http://example.com/ordering/properties/"
xmlns:tns="http://example.com/ordering/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
abstractProcessProfile="http://docs.oasis-open.org/wsbpel/2.0/process/abstract/simple-template/2006/08"
suppressJoinFailure="yes">
<import importType="http://schemas.xmlsoap.org/wsdl/"
location="orderingLT.wsdl"
namespace="http://example.com/ordering/partnerLinkTypes/" />
<import importType="http://schemas.xmlsoap.org/wsdl/"
location="orderingPT.wsdl"
namespace=" http://example.com/ordering/interfaces/" />
<import importType="http://schemas.xmlsoap.org/wsdl/"
location="orderingProperties.wsdl"
namespace="http://example.com/ordering/properties/" />
<extensions>
<extension namespace="http://example.com/bpel/some/extension"
mustUnderstand="no" />
</extensions>
<partnerLinks>
<partnerLink name="ordering"
partnerLinkType="plt:orderingServiceLT"
myRole="orderingService" 
partnerRole="orderingServiceResponse" />
<partnerLink name="shipper" 
partnerLinkType="plt:shipperLT"
myRole="shippingServiceResponse" 
partnerRole="shippingService" />
<partnerLink name="shippingRequester" 
partnerLinkType="##opaque"
myRole="##opaque" />
<partnerLink name="invoiceProcessor" 
partnerLinkType="##opaque"
myRole="##opaque" 
partnerRole="##opaque" />
<partnerLink name="orderingConfirmation"
partnerLinkType="plt:completionConfirmationLT"
partnerRole="orderingServiceConfirmation" />
</partnerLinks>
<variables>
<!-- Reference to the message passed as input during
initiation -->
<variable name="order" messageType="oif:OrderMessageType" />
<variable name="orderAckMsg"
messageType="oif:OrderAckMessageType" />
<variable name="orderShippedMsg"
element="order:OrderAckMessage" />
<variable name="shippingRequestMsg"
element="order:ShipRequestMessage" />
<variable name="shippingNoticeMsg"
element="order:ShipNoticeMessage" />
<variable name="shipHistoryMsg"
messageType="oif:ShippingHistoryMessageType" />
<variable name="invoiceAckMsg"
messageType="oif:InvoiceAckMessageType" />
</variables>
<correlationSets>
<correlationSet name="orderCS" properties="props:orderID" />
</correlationSets>
<sequence>
<receive partnerLink="ordering" operation="placeOrder"
variable="order" createInstance="yes">
<correlations>
<correlation set="orderCS" initiate="yes" />
</correlations>
</receive>
<assign>
<copy>
<from>
$order.OrderMessagePart/order:OrderMessageHeader/
order:orderID
</from>
<to>
$shippingRequestMsg/order:ShipRequestMessageHeader/
order:orderID
</to>
</copy>
<copy>
<from>$order.OrderMessagePart/order:ShippingInfo</from>
<to>$shippingRequestMsg/order:ShippingInfo</to>
</copy>
</assign>
<invoke partnerLink="shipper" operation="shippingRequest"
inputVariable="shippingRequestMsg"
ext:uniqueUserFriendlyName="send shipping request to 
shipper"/>
<receive partnerLink="shipper"
portType="oif:shippingServiceCustomerPT"
operation="shippingNotice" 
variable="shippingNoticeMsg"
ext:uniqueUserFriendlyName="receive response from shipper">
<correlations>
<correlation set="orderCS" />
</correlations>
</receive>
<assign>
<copy>
<from>
$order.OrderMessagePart/order:OrderMessageHeader/
order:orderID
</from>
<to>
$orderAckMsg.OrderAckMessagePart/
order:OrderAckMessageHeader/order:orderID
</to>
</copy>
</assign>
<if>
<condition opaque="yes" />
<!--
the first case would package the order
acknowledgement for a completed shipment 
-->
<assign>
<copy>
<opaqueFrom/>
<to>$orderAckMsg.OrderAckMessagePart/order:Ack</to>
</copy>
</assign>
<else>
<!--
the second case would package the order
acknowledgement for an uncompleted shipment 
-->
<assign>
<copy>
<opaqueFrom/>
<to>$orderAckMsg.OrderAckMessagePart/order:Ack</to>
</copy>
</assign>
</else>
</if>
<invoke partnerLink="ordering" 
operation="getOrderAck"
inputVariable="orderAckMsg" />
<receive partnerLink="shippingRequester" 
operation="##opaque"
variable="##opaque"
ext:uniqueUserFriendlyName="receive the pickup notification">
<correlations>
<correlation set="orderCS" />
</correlations>
</receive>
<assign>
<copy>
<opaqueFrom/>
<to>
$shipHistoryMsg.ShipHistoryMessagePart/order:Event
</to>
</copy>
</assign>
<opaqueActivity>
<documentation>
If we receive notice that the ship has completed, update
our ship history accordingly

```

--------------------------------

### WS-BPEL XPath Restriction in <to> Element

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This rule specifies that when using an XPath expression within the '<to>' element of an 'assign' activity, the expression must start with an XPath VariableReference.

```xpath
$myVariable/somePath
```

--------------------------------

### WS-BPEL: Standard Elements for Activity Synchronization

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Describes the optional 'targets' and 'sources' elements used for defining synchronization relationships between activities via links. Includes 'joinCondition' and 'transitionCondition' for controlling flow.

```xml
<targets>?
<joinCondition expressionLanguage="anyURI"?>?
bool-expr
</joinCondition>
<target linkName="NCName" />+
</targets>
<sources>?
<source linkName="NCName">+
<transitionCondition expressionLanguage="anyURI"?>?
bool-expr
</transitionCondition>
</source>
</sources>
```

--------------------------------

### AII-to-AII Copy in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Demonstrates an Attribute-to-Attribute (AII-to-AII) copy operation in WS-BPEL, where the value of one attribute is copied to another. This example copies the 'amt' attribute from order details to billing details.

```xml
<assign>
  <copy>
    <from>$orderDetailVar/@amt</from>
    <to>$billingDetailVar/@amt</to>
  </copy>
</assign>
```

--------------------------------

### WS-BPEL Abstract Process Structure

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates the structure of a WS-BPEL Abstract Process, highlighting the permitted attributes. Key attributes include 'name', 'targetNamespace', 'abstractProcessProfile', and optional attributes like 'queryLanguage' and 'expressionLanguage'.

```xml
<process name="NCName" 
targetNamespace="anyURI"
abstractProcessProfile="anyURI" 
queryLanguage="anyURI"?
expressionLanguage="anyURI"?
suppressJoinFailure="yes|no"?
exitOnStandardFault="yes|no"?
xmlns="http://docs.oasis-open.org/wsbpel/2.0/process/abstract">
...
</process>
```

--------------------------------

### Example: Cyclic Peer-Scope Dependency in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates a WS-BPEL process definition with a cyclic peer-scope dependency between SC1 and SC2, which would be rejected by a WS-BPEL processor due to violations of Rule 2.

```xml
<process name="P1">
...
<flow name="F1">
...
<scope name="SC1">
<flow name="F2">
...
<invoke name="InvA" ...>
<targets>
<target linkName="LinkA"/>
</targets>
</invoke>
...
</flow>
</scope>
<scope name="SC2">
...
<receive name="RcvA" ...>
<targets>
<target linkName="LinkB"/>
</targets>
</receive>
...
</scope>
...
</flow>
...
</process>
```

--------------------------------

### Applying Extension Element to Invoke Activities

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Example demonstrating an extension element 'foo:invokeProperty' applied to a scope. This extension element can affect all invoke activities within that scope, unlike attribute extensions.

```xml
<process>
...
<scope>
<foo:invokeProperty>SomeNature</foo:invokeProperty>
<sequence>
<invoke operation="operation1" ... />
<invoke operation="operation2" ... />
<invoke operation="operation3" ... />
</sequence>
</scope>
...
</process>
```

--------------------------------

### WS-BPEL: Sequential Activity Execution with <sequence>

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

The <sequence> activity executes one or more contained activities in the order they are defined. The sequence completes only after the last activity within it has finished execution.

```xml
<sequence standard-attributes>
  standard-elements
  activity+
</sequence>
```

```xml
<sequence>
  <flow>...</flow>
  <scope>...</scope>
  <pick>...</pick>
</sequence>
```

--------------------------------

### WS-BPEL While Activity for Conditional Looping

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

The <while> activity repeatedly executes a contained activity as long as a Boolean condition remains true. The condition is evaluated at the start of each iteration. It requires a <condition> element and an <activity> to be performed.

```xml
<while standard-attributes>
standard-elements
<condition expressionLanguage="anyURI"?>bool-expr</condition>
activity
</while>

Example:
<while>
<condition>$orderDetails > 100</condition>
<scope>...</scope>
</while>
```

--------------------------------

### WS-BPEL 2.0 Pick Activity

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

The <pick> activity waits for one of several triggers (message arrival or alarm) to occur. It executes associated activities and supports correlation and message parts.

```xml
<pick createInstance="yes|no"? standard-attributes>
standard-elements
<onMessage partnerLink="NCName" 
portType="QName"?
operation="NCName"
variable="BPELVariableName"?
messageExchange="NCName"?>+
<correlations>?
<correlation set="NCName" initiate="yes|join|no" />+
</correlations>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
activity
</onMessage>
<onAlarm>* 
(
<for expressionLanguage="anyURI"?>duration-expr</for>
|
<until expressionLanguage="anyURI"?>deadline-expr</until>
) 
activity
</onAlarm>
</pick>
```

--------------------------------

### EII-to-TII Copy in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Demonstrates an Entity-to-Text (EII-to-TII) copy operation, transferring data from an XML element to the text content of another element. This example copies the approved limit to the text content of an approval notice.

```xml
<assign>
  <copy>
    <from>$creditApprovalVar/tns:approvedLimit</from>
    <to>$approvalNotice3Var/text()</to>
  </copy>
</assign>
```

--------------------------------

### Applying Extension Attribute to Invoke Activity

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Example showing an extension attribute 'foo:invokeProperty' applied to an invoke activity. This attribute is qualified by a namespace declared elsewhere and affects specific activities within its scope.

```xml
<process>
...
<scope>
<sequence>
<invoke operation="operation1"
foo:invokeProperty="someNature" ... />
<invoke operation="operation2" ... />
<invoke operation="operation3"
foo:invokeProperty="someNature2" ... />
</sequence>
</scope>
...
</process>
```

--------------------------------

### WS-BPEL Pick Activity for Event-Driven Selection

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

The <pick> activity waits for and processes exactly one event from a set of possibilities (<onMessage> or <onAlarm>). Once an event is selected, others are discarded. It requires at least one <onMessage> and can optionally include <onAlarm> for timed events.

```xml
<pick createInstance="yes|no"? standard-attributes>
standard-elements
<onMessage partnerLink="NCName" 
portType="QName"?
operation="NCName"
variable="BPELVariableName"?
messageExchange="NCName"?>+
<correlations>?
<correlation set="NCName" initiate="yes|join|no" />+
</correlations>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
activity
</onMessage>
<onAlarm>* 
(
<for expressionLanguage="anyURI"?>duration-expr</for>
|
<until expressionLanguage="anyURI"?>deadline-expr</until>
)
activity
</onAlarm>
</pick>

Example:
<pick>
<onMessage partnerLink="buyer" 
portType="orderEntry"
operation="inputLineItem" 
variable="lineItem">
<!-- activity to add line item to order -->
</onMessage>
<onMessage partnerLink="buyer" 
portType="orderEntry"
operation="orderComplete" 
variable="completionDetail">
<!-- activity to perform order completion -->
</onMessage>
<!-- set an alarm to go off 
3 days and 10 hours after the last order line -->
<onAlarm>
<for>'P3DT10H'</for>
<!-- handle timeout for order completion -->
</onAlarm>
</pick>
```

--------------------------------

### EII-to-AII Copy in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Shows an Entity-to-Attribute (EII-to-AII) copy operation, where data from an XML element is copied to an attribute of another element. This example copies the approved limit from a credit application to the 'amt' attribute of an approval notice.

```xml
<assign>
  <copy>
    <from>$creditApprovalVar/tns:approvedLimit</from>
    <to>$approvalNotice2Var/@amt</to>
  </copy>
</assign>
```

--------------------------------

### WS-BPEL 2.0: <pick> createInstance Attribute Rule

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

When a <pick> activity has a 'createInstance' attribute set to 'yes', all its enclosed events must be <onMessage> events. This ensures that a new process instance is initiated only through message reception. It applies to the 'createInstance' attribute of <pick> and the types of events within it.

```xml
<pick createInstance="yes">
  <onMessage .../>
  <onMessage .../>
  <!-- <onAlarm> is not allowed here -->
</pick>
```

--------------------------------

### EII-to-TII Copy with Potential Fault in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates an EII-to-TII copy operation that may result in a `selectionFailure` fault if the target text node does not exist. This example attempts to copy an approved limit to a potentially empty text node.

```xml
<assign>
  <copy>
    <from>$creditApprovalVar/tns:approvedLimit</from>
    <to>$approvalNotice4Var/text()</to>
  </copy>
</assign>
```

--------------------------------

### WS-BPEL 2.0 Sequence Activity

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

The <sequence> activity executes a collection of child activities in their defined lexical order.

```xml
<sequence standard-attributes>
standard-elements 
activity+
</sequence>
```

--------------------------------

### EII-to-EII Copy in WS-BPEL

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Demonstrates an Entity-to-Entity (EII) copy operation in WS-BPEL, where the content of one XML element is copied to another. This example shows copying shipping address data from one poHeader to the billing address of another.

```xml
<assign>
  <copy>
    <from>$poHeaderVar1/tns:shippingAddr</from>
    <to>$poHeaderVar2/tns:billingAddr</to>
  </copy>
</assign>
```

--------------------------------

### WS-BPEL Receive Activity Syntax

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

This defines the syntax for the `<receive>` activity in WS-BPEL. It specifies attributes like `partnerLink`, `portType`, `operation`, `variable`, `createInstance`, and `messageExchange`, along with optional child elements for correlations and fromParts.

```xml
<receive partnerLink="NCName" 
portType="QName"?
operation="NCName"
variable="BPELVariableName"?
createInstance="yes|no"?
messageExchange="NCName"? 
standard-attributes>
standard-elements
<correlations>?
<correlation set="NCName" initiate="yes|join|no"? />+
</correlations>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
</receive>
```

--------------------------------

### XPath 1.0 Example: Unqualified Element Access Failure

Source: https://docs.oasis-open.org/wsbpel/2.0/wsbpel-v2.0.html/index

Illustrates a scenario where an XPath 1.0 expression fails to select an element because it uses an unqualified name, and the element in the variable has a namespace. This highlights the importance of namespace handling in XPath.

```xml
<from xmlns="http://example.com">$FooVar/bar/text()</from>
```