view release on metacpan or  search on metacpan

lib/Business/PayPal/API.pm  view on Meta::CPAN

            ? ( proxy => [ [ 'http', 'https' ] => $args{proxy_url} ] )
            : ()
        )
    )->uri(C_xmlns_pp);

    $Header{$self} = SOAP::Header->name(
        RequesterCredentials => \SOAP::Header->value(
            SOAP::Data->name(
                Credentials => \SOAP::Data->value(
                    SOAP::Data->name( Username => $args{Username} )->type(''),
                    SOAP::Data->name( Password => $args{Password} )->type(''),
                    SOAP::Data->name( Signature => $args{Signature} )

 view release on metacpan or  search on metacpan

cpan-security-advisory.json  view on Meta::CPAN

{"meta":{"date":"Thu Jul  3 16:46:22 2025","generator":"util/generate","commit":"bf3bf39915e1ebde1c11224c270c5b6bff6ac398","repo":"https://github.com/briandfoy/cpan-security-advisory.git","epoch":1751561182},"module2dist":{"Mojo::Content":"Mojoliciou...

 view release on metacpan or  search on metacpan

lib/Checkout/CyberSource/SOAP.pm  view on Meta::CPAN

    my $usernameToken = SOAP::Data->name( 'UsernameToken' => {%tokenHash} )
        ->prefix( $self->wsse_prefix );

    my $header
        = SOAP::Header->name( Security =>
            { UsernameToken => SOAP::Data->type( '' => $usernameToken ) } )
        ->uri( $self->wsse_nsuri )->prefix( $self->wsse_prefix );

    return $header;
}

 view release on metacpan or  search on metacpan

Notes/cpan-namespaces/cpan-namespaces-L1-L2.txt  view on Meta::CPAN

SOAP::EnvelopeMaker
SOAP::Fault
SOAP::GenericHashSerializer
SOAP::GenericInputStream
SOAP::GenericScalarSerializer
SOAP::Header
SOAP::ISIWoK
SOAP::Lite
SOAP::MIME
SOAP::MIMEParser
SOAP::Message

 view release on metacpan or  search on metacpan

lib/Elive/Connection/SDK.pm  view on Meta::CPAN

    <Name>%s</Name>
    <Password>%s</Password>
    </h:BasicAuth>
EOD

    return (@preamble, SOAP::Header->type(xml => $auth));
};

=head2 login

Returns the login user as an object of type L<Elive::Entity::User>.

 view release on metacpan or  search on metacpan

lib/Email/ExactTarget.pm  view on Meta::CPAN

	#     <wsse:Username>username</wsse:Username>
	#     <wsse:Password>password</wsse:Password>
	#   </wsse:UsernameToken>
	# </wsse:Security>
	my @header = (
		SOAP::Header
			->name( Action => $args{'action'} )
			->uri( 'http://schemas.xmlsoap.org/ws/2004/08/addressing' )
			->prefix( 'wsa' ),
		SOAP::Header
			->name( To => $endpoint )
			->uri( 'http://schemas.xmlsoap.org/ws/2004/08/addressing' )
			->prefix( 'wsa' ),
		SOAP::Header
			->name(
				Security => \SOAP::Data->value(
					SOAP::Data->name(
						UsernameToken => \SOAP::Data->value(
							SOAP::Data->name( Username => $self->{'username'} )->prefix( 'wsse' ),

 view release on metacpan or  search on metacpan

lib/Experian/IDAuth.pm  view on Meta::CPAN

        $hash .= '=';
    }

    my $hmac_sig = $hash . '_' . $timestamp . '_' . $public_key;

    return SOAP::Header->name('head:Signature')->value($hmac_sig);
}

# Send the given SOAP request to 192.com
sub _send_request {
    my $self = shift;

 view release on metacpan or  search on metacpan

lib/MOBY/Async/WSRF.pm  view on Meta::CPAN

	
	
	my(@parameters, @header);
	for (@_) { 
		# Find all the SOAP Headers
		if (defined($_) && ref($_) && UNIVERSAL::isa($_ => 'SOAP::Header')) {
			push(@header, $_); 

		# Find all the SOAP Message Parts (attachments)
		} elsif (defined($_) && ref($_) && 
			$self->context && $self->context->packager->is_supported_part($_)

lib/MOBY/Async/WSRF.pm  view on Meta::CPAN

#===============================================================================
# WSRF::Header (WS-Address spec.)
# 
# header function creates a SOAP::Header that should be included
# in the response to the client. Handles the WS-Address stuff.
# Takes the original envelope and creates a Header from it - 
# the second paramter will be stuffed into the Header so must
# be XML
#

lib/MOBY/Async/WSRF.pm  view on Meta::CPAN

			$messageID = $envelope->headerof("//{$WSRF::Constants::WSA}MessageID")->value;
			$myHeader .= "<wsa:RelatesTo wsu:Id=\"RelatesTo\">".$messageID."</wsa:RelatesTo>";
		}
	}
	
	# Create the SOAP::Header object and return it
	return SOAP::Header->value($myHeader)->type('xml');
};

#===============================================================================
# WSRF::MobyFile
# 

 view release on metacpan or  search on metacpan

lib/Microsoft/AdCenter/Service.pm  view on Meta::CPAN

        my $header_ns = $header->{namespace};
        my $header_name = $header->{name};
        my $header_type = $header->{type};
        my $type_category = $self->_type_category($header_type);
        my $header_value = ($type_category eq 'COMPLEX') ? $self->_populate_complex_type($header_type) : $self->$header_name;
        push @soap_header, $self->_serialize_argument("SOAP::Header", $header_ns, $header_name, $header_value, $header_type, 0);
    }

    # Create request body
    my @soap_body;
    foreach my $request_parameter (@$request_parameters) {

 view release on metacpan or  search on metacpan

lib/Net/DSLProvider/Cerberus.pm  view on Meta::CPAN

    Wsgetexchangeevents => [qw/ cli clientid / ],
        );

sub _credentials {
    my $self = shift;
    return SOAP::Header->new(
      name =>'AuthenticatedUser',
      attr => { xmlns => "http://nc.cerberusnetworks.co.uk/NetCONNECT" },
      value => {username => $self->{user}, password => $self->{pass} },
    );
}

 view release on metacpan or  search on metacpan

lib/Net/Fritz/Service.pm  view on Meta::CPAN

}

sub _get_initial_auth {
    my $self = shift;

    my $userid = SOAP::Header->name('UserID')
	->value($self->fritz->username);

    return SOAP::Header
	->name('h:InitChallenge')
	->attr({'xmlns:h' => 'http://soap-authentication.org/digest/2001/10/',
		's:mustUnderstand' => '1'})
	->value(\$userid);
}

lib/Net/Fritz/Service.pm  view on Meta::CPAN

				$self->fritz->username,
				$parm->{Realm},
				$self->fritz->password,
			  ) );

    my $auth = SOAP::Header->name('Auth')
	->value(
	md5_hex( $secret . ':' . $parm->{Nonce} )
	);

    my $nonce = SOAP::Header->name('Nonce')
	->value($parm->{Nonce});

    my $realm = SOAP::Header->name('Realm')
	->value($parm->{Realm});

    my $userid = SOAP::Header->name('UserID')
	->value($self->fritz->username);

    return SOAP::Header
	->name('h:ClientAuth')
	->attr({'xmlns:h' => 'http://soap-authentication.org/digest/2001/10/',
		's:mustUnderstand' => '1'})
	->value(\SOAP::Header->value($nonce, $auth, $userid, $realm));
}

sub _hash_check {
    my ($hash_a, $hash_b, $msg_a, $msg_b) = (@_);

 view release on metacpan or  search on metacpan

lib/Net/LimeLight/Purge.pm  view on Meta::CPAN

    }
);

has '_header' => (
    is => 'rw',
    isa => 'SOAP::Header',
    lazy => 1,
    default => sub {
        my ($self) = @_;

        return SOAP::Header->new(
            name => 'AuthHeader',
            attr => { xmlns => 'http://www.llnw.com/Purge' },
            value => {
                Username => $self->username,
                Password => $self->password

 view release on metacpan or  search on metacpan

lib/POE/Component/Server/SOAP/Response.pm  view on Meta::CPAN

	$response->soaprequest()	# Returns the original HTTP::Request object from SimpleHTTP
	$response->soapservice()	# Returns the service that triggered this SOAP instance
	$response->soapmethod()		# Returns the method that triggered this SOAP instance
	$response->soapuri()		# Returns the original URI of the request without the method
	$response->soapheaders()	# Returns an arrayref of SOAP::Header objects ( undef if none )
	$response->soapbody()		# Returns the body as a hashref ( undef if no arguments )

=head2 EXPORT

Nothing.

 view release on metacpan or  search on metacpan

lib/SOAP/Data/Builder/Simple.pm  view on Meta::CPAN

                $parent->$1($value);
            }

        } else {

            my $element = $is_header ? SOAP::Header->new : SOAP::Data->new;

            $element->name($key);

            _add_value( $element, $value );

lib/SOAP/Data/Builder/Simple.pm  view on Meta::CPAN

=head1 FUNCTIONS

=head2 header

Identical to C<data> except the top level element(s) are of type SOAP::Header.

=head2 data

Returns a list of one or more SOAP::Data objects. Each object may have further
SOAP::Data objects as children. Arrayrefs are used to preserve order of child

 view release on metacpan or  search on metacpan

lib/SOAP/Data/Builder.pm  view on Meta::CPAN

  This Module provides a quick and easy way to build complex SOAP data
  and header structures for use with SOAP::Lite.

  It primarily provides a wrapper around SOAP::Serializer and SOAP::Data
  (or SOAP::Header) enabling you to generate complex XML within your SOAP
  request or response.

=head1 VERSION

1.0

lib/SOAP/Data/Builder.pm  view on Meta::CPAN

 return shift->{options}{readable} || 0;
}

=head2 to_soap_data()

  returns the contents of the object as a list of SOAP::Data and/or SOAP::Header objects

  NOTE: make sure you call this in array context!

=cut

lib/SOAP/Data/Builder.pm  view on Meta::CPAN

value should be a string,

attributes should be a hashref : { 'ns:foo'=> bar, .. }

header should be 1 or 0 specifying whether the element should be built using SOAP::Data or SOAP::Header

returns the added element

my $bar_elem = $builder->add_elem(name=>'bar', value=>$foo->{bar}, parent=>$foo);

lib/SOAP/Data/Builder.pm  view on Meta::CPAN

    $data[0] = \SOAP::Data->value( @values );
  } else {
    @data = @values;
  }
  if ($elem->{header}) {
    $data[0] = SOAP::Header->name($elem->{name} => $data[0])->attr($elem->attributes());
  } else {
      if ($elem->{isMethod}) {
	  @data = ( SOAP::Data->name($elem->{name} )->attr($elem->attributes()) => SOAP::Data->value( @values ) );
      } elsif ($elem->{type}) {
	  $data[0] = SOAP::Data->name($elem->{name} => $data[0])->attr($elem->attributes())->type($elem->{type});

 view release on metacpan or  search on metacpan

lib/SOAP/Data/ComplexType.pm  view on Meta::CPAN

	my %attributes = %{$self->attributes()};
	my $arrayTypeAttr = (grep(/(^|.+:)arrayType$/, keys %attributes))[0];
	$attributes{$arrayTypeAttr} = $attributes{$arrayTypeAttr}.'['.(scalar @values).']' if defined $arrayTypeAttr;
	if ($self->{header}) {
		$data[0] = SOAP::Header->name($self->{name} => $data[0])->attr(\%attributes)->type($self->{type})->uri($self->{uri});
	} else {
		if ($self->{isMethod}) {
			@data = ( SOAP::Data->name($self->{name})->attr(\%attributes)->type($self->{type})->uri($self->{uri}) 
				=> SOAP::Data->value(@values)->type($self->{type})->uri($self->{uri}) );
		} else {

 view release on metacpan or  search on metacpan

lib/SOAP/Lite.pm  view on Meta::CPAN

        : (return $self->{_signature});
}

# ======================================================================

package SOAP::Header;

use vars qw(@ISA);
@ISA = qw(SOAP::Data);

# ======================================================================

lib/SOAP/Lite.pm  view on Meta::CPAN

    my $self = shift->new;
    my $type = shift;
    my(@parameters, @header);
    for (@_) {
        # Find all the SOAP Headers
        if (defined($_) && ref($_) && UNIVERSAL::isa($_ => 'SOAP::Header')) {
            push(@header, $_);
        }
        # Find all the SOAP Message Parts (attachments)
        elsif (defined($_) && ref($_) && $self->context
            && $self->context->packager->is_supported_part($_)

lib/SOAP/Lite.pm  view on Meta::CPAN

    return wantarray
        ? map {o_value($_)} @{$self->{_current}}
        : @{$self->{_current}} ? o_value($self->{_current}->[0]) : undef;
}

sub headerof { # SOAP::Header is the same as SOAP::Data, so just rebless it
    wantarray
        ? map { bless $_ => 'SOAP::Header' } shift->dataof(@_)
        : do { # header returned by ->dataof can be undef in scalar context
            my $header = shift->dataof(@_);
            ref $header ? bless($header => 'SOAP::Header') : undef;
        };
}

sub dataof {
    my $self = shift;

lib/SOAP/Lite.pm  view on Meta::CPAN

                            : $object
                        )->$method_name(SOAP::Server::Object->objects(@parameters)),

                        # send object back as a header
                        # preserve name, specify URI
                        SOAP::Header
                            ->uri($SOAP::Constants::NS_SL_HEADER => $object)
                            ->name($request->dataof($som->method.'/[1]')->name)
                    } # end do block

                    # SOAP::Dispatcher will plug-in here as well

lib/SOAP/Lite.pm  view on Meta::CPAN

sub server { required; shift->new(@_) }

sub data   { SOAP::Data->new(@_) }

sub header { SOAP::Header->new(@_) }

sub hash   { +{@_} }

sub instanceof {
  my $class = shift;

lib/SOAP/Lite.pm  view on Meta::CPAN

L<SOAP::Transport> - Transport backend

L<SOAP::Data> - Data objects

L<SOAP::Header> - Header Data Objects

L<SOAP::Serializer> - Serializes data structures to SOAP messages

L<SOAP::Deserializer> - Deserializes SOAP messages into SOAP::SOM objects

 view release on metacpan or  search on metacpan

lib/SOAP/MIME.pm  view on Meta::CPAN

		  my $object = shift @parameters;
		  SOAP::Server::Object->object(ref $class ? $class : $object)
		      ->$method_name(SOAP::Server::Object->objects(@parameters)),
			# send object back as a header
			# preserve name, specify URI
			SOAP::Header
			    ->uri($SOAP::Constants::NS_SL_HEADER => $object)
			    ->name($request->dataof($som->method.'/[1]')->name)
		}
		: $class->$method_name(SOAP::Server::Object->objects(@parameters))
        );

lib/SOAP/MIME.pm  view on Meta::CPAN

  my $type = shift;

  # SOAP::MIME added the attachments bit here
  my(@parameters, @header, @attachments);
  for (@_) { 
    defined $_ && ref $_ && UNIVERSAL::isa($_ => 'SOAP::Header') ?
      push(@header, $_) :
	UNIVERSAL::isa($_ => 'MIME::Entity') ?
	    push(@attachments, $_) :
	      push(@parameters, $_);
  }

 view release on metacpan or  search on metacpan

lib/SOAP/WSDL/SOAP/Header.pm  view on Meta::CPAN

package SOAP::WSDL::SOAP::Header;
use strict;
use warnings;
use base qw(SOAP::WSDL::Base);
use Class::Std::Fast::Storable;

 view release on metacpan or  search on metacpan

lib/SOAP/XML/Client.pm  view on Meta::CPAN

     disable_base64 => 1,
   ...

=head2 header()

   my $header = SOAP::Header->name(
          SomeDomain => {
              Username => "a_user",
              Password => 'xxxxx',
          }
      )->uri('http://www.thedomain.com/')->prefix('');

 view release on metacpan or  search on metacpan

lib/SOAP/Envelope.pm  view on Meta::CPAN

    my $sp = $self->{soap_prefix};

    my $header_number = ++$self->{header_count};
    if (1 == $header_number) {
        #
        # this is the first header, so print the SOAP::Header tag to
        # delimit the headers
        #
        $self->_print(qq[<$sp$soap_header>]);
    }
    my $tag;

 view release on metacpan or  search on metacpan

lib/Salesforce.pm  view on Meta::CPAN

    }, $class;
}

sub get_session_header {
    my $self = shift;
    return SOAP::Header->name( 'SessionHeader' =>
          \SOAP::Header->name( 'sessionId' => $self->{'sessionId'} ) );
}

sub login {
    my $self = shift;
    my (%in) = @_;

lib/Salesforce.pm  view on Meta::CPAN

      ->proxy( $self->{address} );

    my $r = $client->query(
        $self->get_session_header(),
        SOAP::Data->name( 'query' => $in{'query'} ),
        SOAP::Header->name(
            'QueryOptions' => \SOAP::Header->name( 'batchSize' => $in{'limit'} )
        )
    );
    return $r;

}

lib/Salesforce.pm  view on Meta::CPAN

      ->proxy( $self->{address} );

    my $r = $client->queryMore(
        $self->get_session_header(),
        SOAP::Data->name( 'queryLocator' => $in{'queryLocator'} ),
        SOAP::Header->name(
            'QueryOptions' => \SOAP::Header->name( 'batchSize' => $in{'limit'} )
        )
    );
    return $r;

}

 view release on metacpan or  search on metacpan

lib/Shipment/SOAP/WSDL.pm  view on Meta::CPAN

  1;
SOAP_WSDL_SOAP_BODY

$fatpacked{"SOAP/WSDL/SOAP/Header.pm"} = <<'SOAP_WSDL_SOAP_HEADER';
  package
    SOAP::WSDL::SOAP::Header;
  use strict;
  use warnings;
  use base qw(SOAP::WSDL::Base);
  use Class::Std::Fast::Storable;
  

lib/Shipment/SOAP/WSDL.pm  view on Meta::CPAN

  1;
SOAP_WSDL_SOAP_HEADER

$fatpacked{"SOAP/WSDL/SOAP/HeaderFault.pm"} = <<'SOAP_WSDL_SOAP_HEADERFAULT';
  package
    SOAP::WSDL::SOAP::HeaderFault;
  use strict;
  use warnings;
  use base qw(SOAP::WSDL::Header);
  
  use version; our $VERSION = qv('2.00.99_3');

lib/Shipment/SOAP/WSDL.pm  view on Meta::CPAN

              type => 'CLASS',
              class => 'SOAP::WSDL::SOAP::Body',
          },
          header => {
              type => 'CLASS',
              class => 'SOAP::WSDL::SOAP::Header',
          },
          address => {
              type => 'CLASS',
              class => 'SOAP::WSDL::SOAP::Address',
          }

 view release on metacpan or  search on metacpan

UDDI/SOAP.pm  view on Meta::CPAN

    my @elem = @$self;
    shift(@elem); # attributes
    pop(@elem);   # body
    my @h;
    for (@elem) {
	die "Assert $_" unless ref($_) eq "UDDI::SOAP::Header";
	push(@h, $_->[1])
	    if $_->[1][0]{UDDI::SOAP::SOAP_ENV . "\0mustUnderstand"};
    }
    return @h;
}

 view release on metacpan or  search on metacpan

lib/VMWare/LabmanSoap.pm  view on Meta::CPAN

		-> on_action(sub { return "http://vmware.com/labmanager/" . $_[1]; } )
		-> default_ns('http://vmware.com/labmanager')
		-> proxy('https://' . $hostname . '/LabManager/SOAP/LabManagerInternal.asmx');

	$self->{'soap'}->readable(1);
	$self->{'auth_header'} = SOAP::Header->new(
		name => 'AuthenticationHeader',
		attr => { xmlns => "http://vmware.com/labmanager" },
		value => { username => $username, password => $password, organizationname => $orgname, workspacename => $workspace  },
		);

 view release on metacpan or  search on metacpan

lib/VMware/API/LabManager.pm  view on Meta::CPAN

    -> proxy('https://' . $self->{hostname} . '/LabManager/SOAP/LabManagerInternal.asmx', timeout => $self->{ssl_timeout} );

  $self->{soap}->readable(1);
  $self->{soap_priv}->readable(1);

  $self->{auth_header} = SOAP::Header->new(
		name => 'AuthenticationHeader',
		attr => { xmlns => "http://vmware.com/labmanager" },
		value => { username => $self->{username}, password => $self->{password}, organizationname => $self->{orgname}, workspacename => $self->{workspace}  },
  );
}

 view release on metacpan or  search on metacpan

lib/VMware/LabManager.pm  view on Meta::CPAN

=cut

sub get_auth_header
{
 my $self = shift;
 my $auth_header = SOAP::Header->new(
                            name => 'AuthenticationHeader',
                            attr => { xmlns => "http://vmware.com/labmanager" },
                            value => {
                                       username         => $self->{Username},
                                       password         => $self->{Password},

 view release on metacpan or  search on metacpan

lib/W3C/SOAP/Client.pm  view on Meta::CPAN

use English qw/ -no_match_vars /;
use LWP::UserAgent;
use Try::Tiny;
use XML::LibXML;
use W3C::SOAP::Exception;
use W3C::SOAP::Header;
use Moose::Util::TypeConstraints qw/duck_type/;

extends 'W3C::SOAP::Base';

our $VERSION = 0.14;

 view release on metacpan or  search on metacpan

lib/WSRF/Lite.pm  view on Meta::CPAN

	my $type = shift;
	my ( @parameters, @header );
	for (@_) {

		# Find all the SOAP Headers
		if ( defined($_) && ref($_) && UNIVERSAL::isa( $_ => 'SOAP::Header' ) )
		{
			push( @header, $_ );

			# Find all the SOAP Message Parts (attachments)
		} elsif (    defined($_)

lib/WSRF/Lite.pm  view on Meta::CPAN

	my ( @parameters, @header );
	for (@_) {

		# Find all the SOAP Headers
		if ( defined($_) && ref($_) && UNIVERSAL::isa( $_ => 'SOAP::Header' ) )
		{
			push( @header, $_ );

			# Find all the SOAP Message Parts (attachments)
		} elsif (    defined($_)

lib/WSRF/Lite.pm  view on Meta::CPAN

		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $xml = $request->content;

		print STDERR "$$ Attempt to PUT\n";

		$xml =~ s/^<\?xml[\s\w\.\-].*\?>\n?//o;

lib/WSRF/Lite.pm  view on Meta::CPAN

		  ->attr( { 'xmlns:wsrp' => $WSRF::Constants::WSRP } );
		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $envelope = WSRF::WSRFSerializer->new()->freeform( $header, $data );
		$request = HTTP::Request->new();
		$request->method('POST');
		$request->header( "SOAPAction" =>
						 "$WSRF::Constants::WSRP/GetResourcePropertyDocument" );

lib/WSRF/Lite.pm  view on Meta::CPAN

		  ->attr( { 'xmlns:wsrl' => $WSRF::Constants::WSRL } );
		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $envelope = WSRF::WSRFSerializer->new()->freeform( $header, $data );
		$request = HTTP::Request->new();
		$request->method('POST');
		$request->header( "SOAPAction" => "$WSRF::Constants::WSRL/Destroy" );
		$request->header( "Content-Length" => length $envelope );

lib/WSRF/Lite.pm  view on Meta::CPAN

		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $xml = $request->content;

		print STDERR "$$ Attempt to PUT\n";

		$xml =~ s/^<\?xml[\s\w\.\-].*\?>\n?//o;

lib/WSRF/Lite.pm  view on Meta::CPAN

		  ->attr( { 'xmlns:wsrp' => $WSRF::Constants::WSRP } );
		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $envelope = WSRF::WSRFSerializer->new()->freeform( $header, $data );
		$request = HTTP::Request->new();
		$request->method('POST');
		$request->header( "SOAPAction" =>
						 "$WSRF::Constants::WSRP/GetResourcePropertyDocument" );

lib/WSRF/Lite.pm  view on Meta::CPAN

		  ->attr( { 'xmlns:wsrl' => $WSRF::Constants::WSRL } );
		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $envelope = WSRF::WSRFSerializer->new()->freeform( $header, $data );
		$request = HTTP::Request->new();
		$request->method('POST');
		$request->header( "SOAPAction" => "$WSRF::Constants::WSRL/Destroy" );
		$request->header( "Content-Length" => length $envelope );

lib/WSRF/Lite.pm  view on Meta::CPAN

		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $xml = $request->content;

		print STDERR "$$ Attempt to PUT\n";

		$xml =~ s/^<\?xml[\s\w\.\-].*\?>\n?//o;

lib/WSRF/Lite.pm  view on Meta::CPAN

		  ->attr( { 'xmlns:wsrp' => $WSRF::Constants::WSRP } );
		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $envelope = WSRF::WSRFSerializer->new()->freeform( $header, $data );
		$request = HTTP::Request->new();
		$request->method('POST');
		$request->header( "SOAPAction" =>
						 "$WSRF::Constants::WSRP/GetResourcePropertyDocument" );

lib/WSRF/Lite.pm  view on Meta::CPAN

		  ->attr( { 'xmlns:wsrl' => $WSRF::Constants::WSRL } );
		my $To = $ENV{URL};
		chop $To;
		$To .= $request->uri;
		my $header =
		  SOAP::Header->value( "<wsa:To>" . $To . "</wsa:To>" )->type('xml');
		my $envelope = WSRF::WSRFSerializer->new()->freeform( $header, $data );
		$request = HTTP::Request->new();
		$request->method('POST');
		$request->header( "SOAPAction" => "$WSRF::Constants::WSRL/Destroy" );
		$request->header( "Content-Length" => length $envelope );

lib/WSRF/Lite.pm  view on Meta::CPAN

	my $Lock = $self->{_lock};
	$Lock->DESTROY();
}

#===============================================================================
# header function creates a SOAP::Header that should be included
# in the response to the client. Handles the WS-Address stuff.
# Takes the original envelope and creates a Header from it -
# the second paramter will be stuffed into the Header so must
# be XML
#

lib/WSRF/Lite.pm  view on Meta::CPAN

	}

	#append anything else the user has given us
	$myHeader .= $anythingelse;

	#create the SOAP::Header object and return to client
	return SOAP::Header->value($myHeader)->type('xml');
}

#===============================================================================
# Base class for the process based WSRF services - a Service can inherit from
# this class to pick up GetResourceProperty, GetMultiResourceProperties and

lib/WSRF/Lite.pm  view on Meta::CPAN

		  : '';

		#bug fix - John Newman
		$header .=
"<wsa:ReplyTo wsu:Id=\"ReplyTo\"><wsa:Address>$WSRF::Constants::WSA_ANON</wsa:Address></wsa:ReplyTo>";
		@_ = ( @_, SOAP::Header->value($header)->type('xml') );
	}

	my $response = $self->transport->send_receive(
		context  => $self,             # this is provided for context
		endpoint => $self->endpoint,

 view release on metacpan or  search on metacpan

lib/WWW/PIDS.pm  view on Meta::CPAN

	}

	defined $self->{ 'ClientGuid' } or $self->{ 'ClientGuid' } = $self->GetNewClientGuid();
	$ATTR{ 'ClientGuid' } = $self->{ 'ClientGuid' };

	$self->{pids_header} = SOAP::Header->name( 'PidsClientHeader' )
					   ->attr( { 'xmlns' => $NS } )
					   ->value( \SOAP::Header->value( 
							SOAP::Header->name( 'ClientGuid'		=> $ATTR{ 'ClientGuid' } ),
							SOAP::Header->name( 'ClientType'		=> $ATTR{ 'ClientType' } ),
							SOAP::Header->name( 'ClientVersion'		=> $ATTR{ 'ClientVersion' } ),
							SOAP::Header->name( 'ClientWebServiceVersion'	=> $ATTR{ 'ClientWebServiceVersion' } )
						) );
	
	return $self
}