<?xml version="1.0" encoding="utf-8" ?>
<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements.  See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership.  The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License.  You may obtain a copy of the License at
  ~
  ~    http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied.  See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->

<!-- NoArgumentInvocationProcess BPEL Process [Generated by the Eclipse BPEL Designer] -->
<!-- Date: Wed Jan 30 11:02:23 IST 2013 -->
<bpel:process name="NoArgumentInvocationProcess"
         targetNamespace="http://example.ord/samples/"
         suppressJoinFailure="yes"
         xmlns:tns="http://example.ord/samples/"
         xmlns:bpel="http://docs.oasis-open.org/wsbpel/2.0/process/executable"
         xmlns:ns="http://axis2.ode.apache.org">

    <!-- Import the client WSDL -->
	<bpel:import location="NoArgumentInvocationProcessArtifacts.wsdl" namespace="http://example.ord/samples/"
	        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. -->
        <bpel:partnerLink name="client"
                     partnerLinkType="tns:NoArgumentInvocationProcess"
                     myRole="NoArgumentInvocationProcessProvider"
                     />
        <bpel:partnerLink name="axis2VersionPL" partnerLinkType="tns:axis2VersionPLT" partnerRole="myRole"></bpel:partnerLink>
    </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:NoArgumentInvocationProcessRequestMessage"/>

        <!--
          Reference to the message that will be returned to the requester
          -->
        <bpel:variable name="output"
                  messageType="tns:NoArgumentInvocationProcessResponseMessage">
        </bpel:variable>
        <bpel:variable name="noArgmentMethodResponse" messageType="ns:noArgmentMethodResponse"></bpel:variable>
    </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 requester.
             Note: This maps to operation defined in NoArgumentInvocationProcess.wsdl
             -->
        <bpel:receive name="receiveInput" partnerLink="client"
                 portType="tns:NoArgumentInvocationProcess"
                 operation="process" variable="input"
                 createInstance="yes"/>

        <!-- Generate reply to synchronous request -->
        <bpel:assign validate="no" name="Assign">
            <bpel:copy>
                <bpel:from>
                    <bpel:literal xml:space="preserve"><tns:NoArgumentInvocationProcessResponse xmlns:tns="http://example.ord/samples/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <tns:result>tns:result</tns:result>
</tns:NoArgumentInvocationProcessResponse>
</bpel:literal>
                </bpel:from>
                <bpel:to part="payload" variable="output"></bpel:to>
            </bpel:copy>
        </bpel:assign>
        <bpel:invoke name="Invoke" partnerLink="axis2VersionPL" operation="noArgmentMethod" portType="ns:DummyServicePortType" inputVariable="" outputVariable="noArgmentMethodResponse"></bpel:invoke>


        <bpel:assign validate="no" name="Assign1">
            <bpel:copy>
                <bpel:from part="parameters" variable="noArgmentMethodResponse">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[return]]></bpel:query>
                </bpel:from>
                <bpel:to part="payload" variable="output">
                    <bpel:query queryLanguage="urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"><![CDATA[tns:result]]></bpel:query>
                </bpel:to>
            </bpel:copy>
        </bpel:assign>
        <bpel:reply name="replyOutput"
               partnerLink="client"
               portType="tns:NoArgumentInvocationProcess"
               operation="process"
               variable="output"
               />
    </bpel:sequence>
</bpel:process>

