Gantry::Plugins::SOAP::Doc(3)

NAME
Gantry::Plugins::SOAP::Doc - document style SOAP support

SYNOPSIS
In a controller:

    use Your::App::BaseModule qw(
         -PluginNamespace=YourApp
         SOAP::Doc
    );
    # This exports these into the site object:
    #    soap_out
    #    do_wsdl
    #    return_error

    do_a_soap_action {
        my $self        = shift;
        my $data        = $self->get_post_body();
        my $parsed_data = XMLin( $data );

        # Use data to process the request, until you have a
        # structure like:

        my $ret_struct = [
            {
                yourResponseType => [
                    { var  => value  },
                    { var2 => value2 },
                    { var3 => undef  }, # for required empty tags
                    { nesting_var => [
                        { subvar => value },
                    ] }
                ]
            }
        ] );

        return $self->soap_out( $ret_struct, 'prefix', 'pretty' );
    }

DESCRIPTION
This module supports document style SOAP. If you need rpc style, see Gantry::Plugins::SOAP::RPC.

This module must be used as a plugin, so it can register a pre_init callback to take the POSTed body from the HTTP request before the engine can mangle it, in a vain attempt to make form parameters from it.

The document style SOAP request must find its way to your do_ method via its soap_action URL and Gantry's normal dispatching mechanism. Once the do_ method is called, your SOAP request is available via the "get_post_body" accessor exported by each engine. That request is exactly as received. You probably want to use XML::Simple's XMLin function to extract your data. I would do that for you here, but you might need to set attributes of the parsing like ForceArray.

When you have finished processing the request, you have two choices. If it did not go well, call "return_error" to deliver a SOAP fault to client. Using die or croak is a bad idea as that will return a regular Gantry error message which is obviously not SOAP compliant.

If you succeeded in handling the request, return an array of hashes. Each hash is keyed by XML tag (not including namespace prefix). The value can be a scalar or an array of hashes like the top level one. If the value is "undef", an empty tag will be generated.

Generally, you need to take all of the exports from this module, unless you want to replace them with your own versions.

If you need to control the namespace of the returned parameters, call "soap_namespace_set" with the URL of the namespace before returning. If you don't do that the namespace will default to "http://example.com/ns".

METHODS

new For use by non-web scripts. Call this with a hash of attributes. Currently only the "target_namespace" key is used. It sets the namespace. Once you get your object, you can call "soap_out" on it as you would in a Gantry conroller.

get_callbacks
    Only for use by Gantry.pm.

    This is used to register "steal_post_body" as a pre init callback with Gantry.

steal_post_body
    Not for external use.

    Just a carefully timed call to "consume_post_body" exported by each engine. This is registered as a pre_init callback, so it gets the body before normal form parameter parsing would.

    You may retrieve with the post body with "get_post_body" (also exported by each engine). No processing of the request is done. You will receive whatever the SOAP client generated. That should be XML, but even that depends on the client.

soap_current_time
    Returns the UTC in SOAP format.

soap_serialize_xml
    This method is registered as a callback. Durning the post_init phase it will create a hash from the $self->get_post_body() and store the result in $self->params();

soap_namespace
    Called internally to retrieve the namespace for the XML tags in your SOAP response. Call "soap_namespace_set" if you need to set a particular namespace (some clients will care). Otherwise, the default namespace "http://example.com/ns" will be used.

soap_namespace_set
    Use this to set the namespace for your the tags in your XML response. The default namespace is "http://example.com/ns".

soap_out
    Parameters:

    structure
        actual data to send to the client. See SYNOPSIS and DESCRIPTION.

    namespace_style
        prefix or internal. Use prefix to define the namespace in the soap:Envelope declaration and use it as a prefix on all the return parameter tags. Use internal if you want the prefix to be defined in the outer tag of the response parameters.

        To set the value of the namespace, call "soap_namespace_set" before calling this method.

    pretty
        true if you want pretty printing, false if not

        By default returned XML will be whitespace compressed. If you want it to be pretty printed for debugging, pass any true value to this method as the second parameter, in a scenario like this:

            my $check_first = $self->soap_out(
                    $structure, 'prefix', 'pretty_please'
            );
            warn $check_first;
            return $check_first;

    Call this with the data to return to the client. If that client cares about the namespace of the tags in the response, call "soap_namespace_set" first. See the SYNOPSIS for an example of the structure you must pass to this method. See the DESCRIPTION for an explanation of what you can put in the structure.

    You should return the value returned from this method directly. It turns off all templating and sets the content type to text/xml.

build_args
    Mostly for internal use.

    "soap_out" uses this to turn your structure of return values into an XML snippet. If you need to re-implement "soap_out", you could call this directly. The initial call should pass the same structure "soap_out" expects and (optionally) a pretty print flag. The returned value is the snippet of return params only. You would then need to build the SOAP envelope, etc.

return_error
    This method returns a fault XML packet for you. Use it instead of die or croak.

do_wsdl
    This method uses the "wsdldoc.tt" in your template path to return a WSDL file to your client. The view.data passed to that template comes directly from a call to "get_soap_ops", which you must implement (even it it returns nothing).

send_xml
    For clients. Sends the xml to the SOAP server. You must have called new with "action_url" and "post_to_url" for this method to work. In particular, servers which use this as a plugin cannot normally call this method. First, they must call new to make an object of this class.

    Parameters: an object of this class, the xml to send (get it from calling "soap_out").

    Returns: response from remote server (actually whatever request on the LWP user agent retruns, try calling content on that object)

AUTHOR
Phil Crow, <crow.phil@gmail.com> Tim Keefer, <tim@timkeefer.com<gt>

COPYRIGHT and LICENSE
Copyright (c) 2007, Phil Crow

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.8.6 or, at your option, any later version of Perl 5 you may have available.