<!-- ${processName} BPEL Process [Generated by the Eclipse BPEL Designer]  -->
<!-- Date: ${date} -->

<bpel:process name="${processName}"
         targetNamespace="${namespace}"
         suppressJoinFailure="yes"
         xmlns:tns="${namespace}"
         xmlns:bpel="${bpelNamespace}"
         >
    <!-- Import the client WSDL -->
	<bpel:import location="${processName}Artifacts.wsdl" namespace="${namespace}" 
	        importType="http://schemas.xmlsoap.org/wsdl/" />
	        
    <!-- ================================================================= -->         
    <!-- PARTNERLINKS                                                      -->
    <!-- List of services participating in this BPEL process               -->
    <!-- ================================================================= -->         
    <bpel:partnerLinks>
        <!--
        The 'client' role represents the requester of this service. It is 
        used for callback. The location and correlation information associated
        with the client role are automatically set using WS-Addressing.
        -->
        <bpel:partnerLink name="client"
                     partnerLinkType="tns:${processName}"
                     myRole="${processName}Provider"
                     partnerRole="${processName}Requester"
                     />
    </bpel:partnerLinks>
  
    <!-- ================================================================= -->         
    <!-- VARIABLES                                                         -->
    <!-- List of messages and XML documents used within this BPEL process  -->
    <!-- ================================================================= -->         
    <bpel:variables>
        <!-- Reference to the message passed as input during initiation -->
        <bpel:variable name="input"
                  messageType="tns:${processName}RequestMessage"/>
                  
        <!-- Reference to the message that will be sent back to the 
             requester during callback
             -->
        <bpel:variable name="output"
                  messageType="tns:${processName}ResponseMessage"/>
    </bpel:variables>

    <!-- ================================================================= -->         
    <!-- ORCHESTRATION LOGIC                                               -->
    <!-- Set of activities coordinating the flow of messages across the    -->
    <!-- services integrated within this business process                  -->
    <!-- ================================================================= -->         
    <bpel:sequence name="main">
        
        <!-- Receive input from requestor. 
             Note: This maps to operation defined in ${processName}.wsdl 
             -->
        <bpel:receive name="receiveInput" partnerLink="client"
                 portType="tns:${processName}"
                 operation="initiate" variable="input"
                 createInstance="yes"/>
        <bpel:empty name="FIX_ME-Add_Business_Logic_Here"></bpel:empty>
        <!-- Asynchronous callback to the requester.
             Note: the callback location and correlation id is transparently handled 
             using WS-addressing.
             -->
        <bpel:invoke name="callbackClient" 
                partnerLink="client"
                portType="tns:${processName}Callback"
                operation="onResult" 
                inputVariable="output"
                />
    </bpel:sequence>
</bpel:process>

