RFEM_Python_Client | Python client ( or high-level functions | SOAP library

You are not using the correct method signature to perform the call.

If you do a:

To work with the raw request you either need to create a request interceptor or just set the headers on the requested context on the service port. So in your case, it should be as simple as

Three problems:

1. There should be no trailing / in the XPath expression.
2. There should be only a single namespace prefix per element name, not two.
3. Namespace prefix z should be y given your Ansible declarations.

Based on your Ansible Code defined namespace prefixes,

Your requested WSDL URL contains https protocol and you are calling http request.

Please call this url : https://trx.*********ast.co.id/Webservice/b******ervice?wsdl

Based on that WSDL file, a code like this:

I think you may be overthinking this. That type might be a restriction, but fundamentally it's a string. It can't be any string, just the values in the enumeration, but nonetheless it's a string. So you can treat it as such.

Here is an example.

I have a mock web service running on http://localhost:8080/. It doesn't do much, it just acknowledges requests. The mock service has this interface:

My response on this one is late. I think the problem is ,

In Send object (Send) there is no field as SendID. If you need Job Id inorder to connect other tracking, you need to use "ID" attribute. You can further improve using BatchId

SendID is present in other event like clicks or open. You can use SendId in those event for filtering the data

Sample message for getting send info :

Omit the RPC tag in your WSDL definition and change it from

to

because you're using RPC as style it's adding app: to the output message and the parts, ignoring your outputName and replacing it with SoapQueryResponse as well. Removing the RPC tag will give you this output

Since you mention you are out of your depth here, I'll start with an introduction.

A SOAP web service is just an API exposed over the web that can be invoked with HTTP POST methods by sending (and then receiving) an XML message as payload. This XML message must have a specific form, specified by both the SOAP protocol as well as the documentation of the web service, commonly also in machine readable format as a WSDL.

You can build these messages yourself by whatever way available (even string concatenation can work), and then make HTTP requests with whatever HTTP library you prefer. But you then must also parse the XML response you receive from the web service to extract the useful values out of it. And that's a pain in the butt.

Because SOAP is a protocol with defined rules, and the WSDL describes the web service contract, you can use the WSDL to generate client code that handles these things for you. It will build the XML request messages and parse the XML response messages, and will invoke the operations of the service by making appropriate HTTP calls for you. What you will get from your client will be familiar Java objects and methods that you can work with without concern for what happens on the wire.

You did this with SoapUI, but I'm not sure what kind of client code you got back from that. You are showing an interface, but that's not enough to call the service. It just defined the contract with all of the operations of the service. Those annotations just add metadata about the operations. They don't invoke the methods. For that you need a proper client not just a contract.

The annotations shown in your question are part of the JAX-WS specification. You need a JAX-WS implementation of the client to handle the call to the service for you. Something like Apache CXF for example.

I would suggest you don't use SoapUI to generate code. Use your implementation of choice to generate the code from the WSDL. For example, Apache CXF has a command line tool (also a Maven plugin) called wsdl2java that can generate the client code for you. Then it's a matter of just instantiating the generated client and call methods on it like any Java object. The methods will receive Java objects and return java objects. Everything else related to SOAP or HTTP requests is handled by the client for you.

For example: