Payment_PayPal_SOAP
[ class tree: Payment_PayPal_SOAP ] [ index: Payment_PayPal_SOAP ] [ all elements ]

Source for file SOAP.php

Documentation is available at SOAP.php

  1. <?php
  2.  
  3. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  4.  
  5. /**
  6.  * Payment_PayPal_SOAP is a package to easily use PayPal's SOAP API from PHP
  7.  *
  8.  * By itself, this package isn't very useful. It should be used in combination
  9.  * with the documentation provided by PayPal at
  10.  * {@link https://www.paypal.com/en_US/pdf/PP_APIReference.pdf}. This package
  11.  * makes it easier to get up and running, and allows you to begin integration
  12.  * by making requests rather than by figuring out how to set SOAP
  13.  * authentication headers.
  14.  *
  15.  * PHP version 5
  16.  *
  17.  * LICENSE:
  18.  *
  19.  * Copyright (c) 2008-2011 silverorange
  20.  *
  21.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  22.  * of this software and associated documentation files (the "Software"), to deal
  23.  * in the Software without restriction, including without limitation the rights
  24.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  25.  * copies of the Software, and to permit persons to whom the Software is
  26.  * furnished to do so, subject to the following conditions:
  27.  *
  28.  * The above copyright notice and this permission notice shall be included in
  29.  * all copies or substantial portions of the Software.
  30.  *
  31.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  32.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  33.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  34.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  35.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  36.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  37.  * THE SOFTWARE.
  38.  *
  39.  * @category  Payment
  40.  * @package   Payment_PayPal_SOAP
  41.  * @author    Michael Gauthier <mike@silverorange.com>
  42.  * @copyright 2008-2009 silverorange
  43.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  44.  * @version   CVS: $Id$
  45.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  46.  * @link      https://www.paypal.com/en_US/pdf/PP_APIReference.pdf
  47.  */
  48.  
  49. /**
  50.  * Package-specific exceptions classes.
  51.  */
  52. require_once 'Payment/PayPal/SOAP/Exceptions.php';
  53.  
  54. /**
  55.  * An easy to use SOAP client for the PayPal SOAP API
  56.  *
  57.  * By itself, this class isn't very useful. It should be used in combination
  58.  * with the documentation provided by PayPal at
  59.  * {@link https://www.paypal.com/en_US/pdf/PP_APIReference.pdf}. This class
  60.  * makes it easier to get up and running, and allows you to begin integration by
  61.  * making requests rather than by figuring out how to set SOAP authentication
  62.  * headers.
  63.  *
  64.  * @category  Payment
  65.  * @package   Payment_PayPal_SOAP
  66.  * @author    Michael Gauthier <mike@silverorange.com>
  67.  * @copyright 2008-2011 silverorange
  68.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  69.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  70.  */
  71. {
  72.     // {{{ class constants
  73.  
  74.     /**
  75.      * Warning or informational error.
  76.      */
  77.     const ERROR_WARNING = 1;
  78.  
  79.     /**
  80.      * Application-level error.
  81.      */
  82.     const ERROR_ERROR = 2;
  83.  
  84.     /**
  85.      * Unknown error type reserved for future internal use by PayPal
  86.      */
  87.     const ERROR_UNKNOWN = 3;
  88.  
  89.     // }}}
  90.     // {{{ protected properties
  91.  
  92.     /**
  93.      * SOAP client used to make PayPal SOAP requests
  94.      *
  95.      * @var SoapClient 
  96.      *
  97.      * @see Payment_PayPal_SOAP::getSoapClient()
  98.      */
  99.     protected $soapClient = null;
  100.  
  101.     /**
  102.      * SOAP header values specific to PayPal SOAP API
  103.      *
  104.      * This contains PayPal authentication values.
  105.      *
  106.      * @var SoapHeader 
  107.      *
  108.      * @see Payment_PayPal_SOAP::getSoapHeaders()
  109.      */
  110.     protected $soapHeader = null;
  111.  
  112.     /**
  113.      * Options passed to the SOAP client when it is created
  114.      *
  115.      * PayPal's SOAP implementation uses SOAP 1.1 so the SOAP version option
  116.      * is specified by default. If using local certificates for authentication,
  117.      * the local certificate file is also included in these options.
  118.      *
  119.      * The API endpoint location is also specified in these options as the
  120.      * endpoint in the WSDL file is not always correct depending on the
  121.      * authentication mechanism used.
  122.      *
  123.      * @var array 
  124.      *
  125.      * @see Payment_PayPal_SOAP::setCertificateFile()
  126.      * @see Payment_PayPal_SOAP::__construct()
  127.      */
  128.     protected $soapOptions = array(
  129.         'trace'        => true,
  130.         'soap_version' => SOAP_1_1
  131.     );
  132.  
  133.     /**
  134.      * Whether or not to use a local copy of the PayPal WSDL
  135.      *
  136.      * If true, a local copy of the PayPal WSDL is used instead of the copy
  137.      * hosted on PayPal's servers. This can be used if PayPal breaks the hosted
  138.      * WSDL files, as has happened in the past.
  139.      *
  140.      * @var boolean 
  141.      *
  142.      * @see Payment_PayPal_SOAP::__construct()
  143.      * @see Payment_PayPal_SOAP::getWsdlFile()
  144.      */
  145.     protected $useLocalWsdl = false;
  146.  
  147.     // }}}
  148.     // {{{ private properties
  149.  
  150.     /**
  151.      * Mode to use for PayPal API
  152.      *
  153.      * Valid modes are:
  154.      * - <kbd>sandbox</kbd> - for development and testing.
  155.      * - <kbd>live</kbd>    - for processing live payments.
  156.      *
  157.      * Defaults to 'sandbox'.
  158.      *
  159.      * @var string 
  160.      *
  161.      * @see Payment_PayPal_SOAP::__construct()
  162.      * @see Payment_PayPal_SOAP::setMode()
  163.      */
  164.     private $_mode 'sandbox';
  165.  
  166.     /**
  167.      * PayPal API username
  168.      *
  169.      * @var string 
  170.      *
  171.      * @see Payment_PayPal_SOAP::__construct()
  172.      * @see Payment_PayPal_SOAP::setUsername()
  173.      */
  174.     private $_username '';
  175.  
  176.     /**
  177.      * PayPal API password
  178.      *
  179.      * @var string 
  180.      *
  181.      * @see Payment_PayPal_SOAP::__construct()
  182.      * @see Payment_PayPal_SOAP::setPassword()
  183.      */
  184.     private $_password '';
  185.  
  186.     /**
  187.      * PayPal signature
  188.      *
  189.      * Only set if using signature-based authentication instead of
  190.      * local-certificate-based authentication.
  191.      *
  192.      * @var string 
  193.      *
  194.      * @see Payment_PayPal_SOAP::__construct()
  195.      * @see Payment_PayPal_SOAP::setSignature()
  196.      */
  197.     private $_signature '';
  198.  
  199.     /**
  200.      * PayPal subject used for making requests on behalf of a third-party
  201.      *
  202.      * This is the email address of the third-party the request should be made
  203.      * on behalf of. Your API username may require explicit access from the
  204.      * third-party before certain API actions will work.
  205.      *
  206.      * @var string 
  207.      *
  208.      * @see Payment_PayPal_SOAP::__construct()
  209.      * @see Payment_PayPal_SOAP::setSubject()
  210.      */
  211.     private $_subject '';
  212.  
  213.     /**
  214.      * API endpoints indexed by mode and security mode
  215.      *
  216.      * Certificate-based authentication uses a different API endpoint than
  217.      * signature (3 token)-based authentication.
  218.      *
  219.      * @var array 
  220.      *
  221.      * @see https://ppmts.custhelp.com/cgi-bin/ppdts.cfg/php/enduser/popup_adp.php?p_sid=undefined&p_lva=undefined&p_faqid=391&p_created=1169502818
  222.      */
  223.     static private $_apiEndpoints = array(
  224.         'sandbox' => array(
  225.             'certificate' => 'https://api.sandbox.paypal.com/2.0/',
  226.             'signature'   => 'https://api-3t.sandbox.paypal.com/2.0/'
  227.         ),
  228.         'live'    => array(
  229.             'certificate' => 'https://api.paypal.com/2.0/',
  230.             'signature'   => 'https://api-3t.paypal.com/2.0/'
  231.         )
  232.     );
  233.  
  234.     // }}}
  235.     // {{{ __construct()
  236.  
  237.     /**
  238.      * Creates a new PayPal SOAP client
  239.      *
  240.      * Either signature-based or certificate-based authentication options
  241.      * are required. The username, password and optional signature fields may
  242.      * be retrieved from your PayPal account in the 'API Credentials' section.
  243.      *
  244.      * Sandbox and live modes require different PayPal accounts so all option
  245.      * values will require changing if you select a different mode.
  246.      *
  247.      * The available options are:
  248.      *
  249.      * - <kbd>mode</kbd>         - optional. The mode to use for PayPal API
  250.      *                             calls. Valid modes are <kbd>sandbox</kbd>
  251.      *                             for development and testing, and
  252.      *                             <kbd>live</kbd> for live payments. If not
  253.      *                             specified, <em><kbd>sandbox</kbd></em> is
  254.      *                             used.
  255.      * - <kbd>username</kbd>     - the username used for authentication.
  256.      * - <kbd>password</kbd>     - the password used for authentication.
  257.      * - <kbd>subject</kbd>      - optional. The third-party on whose behalf
  258.      *                             requests are to be made.
  259.      * - <kbd>signature</kbd>    - optional. The signature used for signature-
  260.      *                             based authentication. Not required if
  261.      *                             certificate-based authentication is used.
  262.      * - <kbd>certificate</kbd>  - optional. The local certificate filename used
  263.      *                             for certificate-based authentication. Not
  264.      *                             required if signature-based authentication is
  265.      *                             used.
  266.      * - <kbd>useLocalWsdl</kbd> - optional. When sepecified as true, a local
  267.      *                             copy of the PayPal WSDL is used instead of
  268.      *                             the copy hosted on PayPal's servers. This
  269.      *                             can be used if PayPal breaks the hosted
  270.      *                             WSDL files, as has happened in the past.
  271.      *
  272.      * @param array $options array of options.
  273.      *
  274.      * @throws InvalidArgumentException if neither a signature nor a
  275.      *          certificate file is specified in the options array, or if the
  276.      *          username or password options are not specified in the options
  277.      *          array.
  278.      */
  279.     public function __construct(array $options)
  280.     {
  281.         $hasSignature   = false;
  282.         $hasCertificate = false;
  283.  
  284.         foreach ($options as $key => $value{
  285.             switch ($key{
  286.             case 'mode':
  287.                 $this->setMode($value);
  288.                 break;
  289.  
  290.             case 'username':
  291.                 $this->setUsername($value);
  292.                 break;
  293.  
  294.             case 'password':
  295.                 $this->setPassword($value);
  296.                 break;
  297.  
  298.             case 'subject':
  299.                 $this->setSubject($value);
  300.                 break;
  301.  
  302.             case 'signature':
  303.                 $hasSignature = true;
  304.                 $this->setSignature($value);
  305.                 break;
  306.  
  307.             case 'certificate':
  308.                 $hasCertificate = true;
  309.                 $this->setCertificateFile($value);
  310.                 break;
  311.  
  312.             case 'useLocalWsdl':
  313.                 $this->useLocalWsdl = ($value? true : false;
  314.                 break;
  315.             }
  316.         }
  317.  
  318.         if (!$this->_username{
  319.             throw new InvalidArgumentException('A username is required.');
  320.         }
  321.  
  322.         if (!$this->_password{
  323.             throw new InvalidArgumentException('A password is required.');
  324.         }
  325.  
  326.         if (!$hasSignature && !$hasCertificate{
  327.             throw new InvalidArgumentException(
  328.                 'Either a signature or a local certificate file is required.');
  329.         }
  330.  
  331.         // set appropriate API endpoint
  332.         if ($this->_signature{
  333.             $this->soapOptions['location'=
  334.                 self::$_apiEndpoints[$this->_mode]['signature'];
  335.         else {
  336.             $this->soapOptions['location'=
  337.                 self::$_apiEndpoints[$this->_mode]['certificate'];
  338.         }
  339.     }
  340.  
  341.     // }}}
  342.     // {{{ call()
  343.  
  344.     /**
  345.      * Makes a PayPal SOAP request
  346.      *
  347.      * If a structured array is used as the arguments, WSDL types with
  348.      * attributes may be specified as:
  349.      *
  350.      * <code>
  351.      * $arguments = array(
  352.      *     'OrderTotal' => array(    // 'OrderTotal' is a type with attributes
  353.      *         '_' => '1000.00',     // this is the element value
  354.      *         'currencyID' => 'USD' // this is an attribute value
  355.      *     )
  356.      * );
  357.      * </code>
  358.      *
  359.      * @param string $requestName the name of the request. This should be a
  360.      *                             request documented in the PayPal SOAP API
  361.      *                             reference manual. Sending a request of an
  362.      *                             invalid type will cause a SoapFault to be
  363.      *                             thrown.
  364.      * @param mixed  $arguments   optional. Either a structured array or an
  365.      *                             object representing the SOAP request
  366.      *                             arguments. If the request requires no
  367.      *                             arguments, this parameter may be ommitted.
  368.      *
  369.      * @return mixed the PayPal SOAP response. If only one value is returned
  370.      *                for the request, a simple value (e.g. an integer, a
  371.      *                string, etc) is returned. For requests that return multiple
  372.      *                values or complex types, a data structure composed of
  373.      *                stdClass objects is returned.
  374.      *
  375.      * @throws Payment_PayPal_SOAP_InvalidRequestNameException if the specified
  376.      *          request name is not a valid PayPal SOAP API request name.
  377.      *
  378.      * @throws Payment_PayPal_SOAP_MissingPropertyException if a required
  379.      *          property for a request type is not specified in the request
  380.      *          arguments. Refer to the PayPal SOAP API documentation at
  381.      *          {@link https://www.paypal.com/en_US/pdf/PP_APIReference.pdf} for
  382.      *          information about required fields.
  383.      *
  384.      * @throws Payment_PayPal_SOAP_ErrorException if a SOAP response contains
  385.      *          one or more Error elements. A detailed error message will be
  386.      *          present in the exception message and the PayPal error code will
  387.      *          be in the exception code.
  388.      *
  389.      * @throws Payment_PayPal_SOAP_FaultException if a SOAP initialization
  390.      *          error occurs or an unknown SOAP error occurs.
  391.      */
  392.     public function call($requestName$arguments = array())
  393.     {
  394.         $client $this->getSoapClient();
  395.  
  396.         // Use a unique client. If an exception is thrown, state will be
  397.         // preserved if subsequent requests are made.
  398.         $client = clone $client;
  399.  
  400.         $headers $this->getSoapHeaders();
  401.  
  402.         try {
  403.             $response $client->__soapCall(
  404.                 $requestName,
  405.                 array($arguments),
  406.                 null,
  407.                 $headers
  408.             );
  409.  
  410.             if (isset($response->Errors)) {
  411.                 if (is_array($response->Errors)) {
  412.                     $errors $response->Errors;
  413.                 else {
  414.                     $errors = array($response->Errors);
  415.                 }
  416.  
  417.                 $errorObjects = array();
  418.                 $messages     = array();
  419.                 $codes        = array();
  420.  
  421.                 foreach ($errors as $error{
  422.  
  423.                     $message (isset($error->LongMessage))
  424.                         ? $error->LongMessage
  425.                         : $error->ShortMessage;
  426.  
  427.                     $messages[$message;
  428.  
  429.                     $code intval($error->ErrorCode);
  430.                     $codes[$code;
  431.  
  432.                     switch ($error->SeverityCode{
  433.                     case 'Warning':
  434.                         $severity Payment_PayPal_SOAP::ERROR_WARNING;
  435.                         break;
  436.                     case 'Error':
  437.                         $severity Payment_PayPal_SOAP::ERROR_ERROR;
  438.                         break;
  439.                     default:
  440.                         $severity Payment_PayPal_SOAP::ERROR_UNKNOWN;
  441.                         break;
  442.                     }
  443.  
  444.                     $expiredTokenExp '/Token value is no longer valid\.$/';
  445.                     if (preg_match($expiredTokenExp$message=== 1{
  446.                         $type Payment_PayPal_SOAP_Error::TYPE_EXPIRED_TOKEN;
  447.                     else {
  448.                         $type Payment_PayPal_SOAP_Error::TYPE_DEFAULT;
  449.                     }
  450.  
  451.                     $errorObjects[= new Payment_PayPal_SOAP_Error(
  452.                         $message,
  453.                         $code,
  454.                         $severity,
  455.                         $type
  456.                     );
  457.  
  458.                 }
  459.  
  460.                 $exceptionMessage sprintf(
  461.                     "Error(s) present in PayPal SOAP response: %s\n" .
  462.                     "Code(s): %s\n" .
  463.                     "Username: %s\n",
  464.                     implode(', '$messages),
  465.                     implode(', '$codes),
  466.                     $this->_username
  467.                 );
  468.  
  469.                 if ($this->_subject{
  470.                     $exceptionMessage .= sprintf(
  471.                         "Subject: %s\n",
  472.                         $this->_subject
  473.                     );
  474.                 }
  475.  
  476.                 $errorException = new Payment_PayPal_SOAP_ErrorException(
  477.                     $exceptionMessage,
  478.                     0,
  479.                     $response
  480.                 );
  481.  
  482.                 foreach ($errorObjects as $error{
  483.                     $errorException->addError($error);
  484.                 }
  485.  
  486.                 throw $errorException;
  487.             }
  488.         catch (SoapFault $e{
  489.             $message $e->getMessage();
  490.  
  491.             $badFunctionExp '/^Function \(".*?"\) is not a valid method ' .
  492.                 'for this service$/';
  493.  
  494.             if (preg_match($badFunctionExp$message=== 1{
  495.                 throw new Payment_PayPal_SOAP_InvalidRequestNameException(
  496.                     'Request name "' $requestName '" is not a valid ' .
  497.                     'request name for the PayPal API.',
  498.                     $e->getCode()$requestName);
  499.             }
  500.  
  501.             $badArgumentExp '/^SOAP-ERROR: Encoding: object hasn\'t ' .
  502.                 '\'(.*?)\' property$/';
  503.  
  504.             $matches = array();
  505.             if (preg_match($badArgumentExp$message$matches=== 1{
  506.                 $propertyName $matches[1];
  507.                 throw new Payment_PayPal_SOAP_MissingPropertyException(
  508.                     'Arguments for "' $requestName '" request is missing ' .
  509.                     'a "' $propertyName '" property. See the PayPal SOAP ' .
  510.                     'API reference for details on required request properties.',
  511.                     $e->getCode()$propertyName);
  512.             }
  513.  
  514.             // Unknown SOAP exception, pass it along.
  515.             throw new Payment_PayPal_SOAP_FaultException('PayPal SOAP Error: ' .
  516.                 $e->getMessage()$e->getCode()$e$client);
  517.         }
  518.  
  519.         return $response;
  520.     }
  521.  
  522.     // }}}
  523.     // {{{ getLastRequest()
  524.  
  525.     /**
  526.      * Gets the XML sent in the last SOAP request
  527.      *
  528.      * @return boolean|stringthe XML sent in the last SOAP request. If no
  529.      *                         request has been performed, false is returned.
  530.      */
  531.     public function getLastRequest()
  532.     {
  533.         if ($this->soapClient === null{
  534.             $request = false;
  535.         else {
  536.             $request $this->soapClient->__getLastRequest();
  537.         }
  538.  
  539.         return $request;
  540.     }
  541.  
  542.     // }}}
  543.     // {{{ getLastResponse()
  544.  
  545.     /**
  546.      * Gets the XML returned in the last SOAP response
  547.      *
  548.      * @return boolean|stringthe XML used in the last SOAP response. If no
  549.      *                         response has been retrieved, false is returned.
  550.      */
  551.     public function getLastResponse()
  552.     {
  553.         if ($this->soapClient === null{
  554.             $response = false;
  555.         else {
  556.             $response $this->soapClient->__getLastResponse();
  557.         }
  558.  
  559.         return $response;
  560.     }
  561.  
  562.     // }}}
  563.     // {{{ getSoapHeaders()
  564.  
  565.     /**
  566.      * Gets the SOAP headers required for PayPal authentication
  567.      *
  568.      * If the header doesn't exist, it is created and stored in the protected
  569.      * property {@link PaymentPayPal_SOAP::$soapHeader}.
  570.      *
  571.      * This header is passed to all PayPal SOAP calls.
  572.      *
  573.      * @return SoapHeader the SOAP header required for PayPal authentication.
  574.      *
  575.      * @see Payment_PayPal_SOAP::call()
  576.      * @see Payment_PayPal_SOAP::setUsername()
  577.      * @see Payment_PayPal_SOAP::setPassword()
  578.      * @see Payment_PayPal_SOAP::setSubject()
  579.      * @see Payment_PayPal_SOAP::setSignature()
  580.      */
  581.     protected function getSoapHeaders()
  582.     {
  583.         if ($this->soapHeader === null{
  584.             $credentials = array(
  585.                 'Credentials' => array(
  586.                     'Username'  => $this->_username,
  587.                     'Password'  => $this->_password
  588.                 )
  589.             );
  590.  
  591.             if ($this->_subject{
  592.                 $credentials['Credentials']['Subject'$this->_subject;
  593.             }
  594.  
  595.             if ($this->_signature{
  596.                 $credentials['Credentials']['Signature'$this->_signature;
  597.             }
  598.  
  599.             $this->soapHeader = new SoapHeader('urn:ebay:api:PayPalAPI',
  600.                 'RequesterCredentials'$credentials);
  601.         }
  602.  
  603.         return $this->soapHeader;
  604.     }
  605.  
  606.     // }}}
  607.     // {{{ getSoapClient()
  608.  
  609.     /**
  610.      * Gets the SOAP client used to make PayPal SOAP calls
  611.      *
  612.      * If the client doesn't exist, it is created and stored in the protected
  613.      * property {@link PaymentPayPal_SOAP::$soapClient}.
  614.      *
  615.      * @return SoapClient the SOAP client used to make PayPal SOAP calls.
  616.      *
  617.      * @see Payment_PayPal_SOAP::call()
  618.      * @see Payment_PayPal_SOAP::setSoapClient()
  619.      */
  620.     protected function getSoapClient()
  621.     {
  622.         if (!($this->soapClient instanceof SoapClient)) {
  623.             $this->soapClient = new SoapClient(
  624.                 $this->getWsdlFile(),
  625.                 $this->soapOptions
  626.             );
  627.         }
  628.  
  629.         return $this->soapClient;
  630.     }
  631.  
  632.     // }}}
  633.     // {{{ setSoapClient()
  634.  
  635.     /**
  636.      * Sets a SOAP client to use for SOAP requests
  637.      *
  638.      * This is useful for testing.
  639.      *
  640.      * @param SoapClient $client the SOAP client to use.
  641.      *
  642.      * @return Payment_PayPal_SOAP the current object, for fluent interface.
  643.      */
  644.     public function setSoapClient(SoapClient $client)
  645.     {
  646.         $this->soapClient = $client;
  647.         return $this;
  648.     }
  649.  
  650.     // }}}
  651.     // {{{ setUsername()
  652.  
  653.     /**
  654.      * Sets the API username used for authentication
  655.      *
  656.      * @param string $username the API username used for authentication.
  657.      *
  658.      * @return Payment_PayPal_SOAP the current object, for fluent interface.
  659.      *
  660.      * @see Payment_PayPal_SOAP::__construct()
  661.      * @see Payment_PayPal_SOAP::$_username
  662.      */
  663.     protected function setUsername($username)
  664.     {
  665.         $this->_username = strval($username);
  666.         return $this;
  667.     }
  668.  
  669.     // }}}
  670.     // {{{ setPassword()
  671.  
  672.     /**
  673.      * Sets the API password used for authentication
  674.      *
  675.      * @param string $password the API password used for authentication.
  676.      *
  677.      * @return Payment_PayPal_SOAP the current object, for fluent interface.
  678.      *
  679.      * @see Payment_PayPal_SOAP::__construct()
  680.      * @see Payment_PayPal_SOAP::$_password
  681.      */
  682.     protected function setPassword($password)
  683.     {
  684.         $this->_password = strval($password);
  685.         return $this;
  686.     }
  687.  
  688.     // }}}
  689.     // {{{ setSignature()
  690.  
  691.     /**
  692.      * Sets the API signature used for signature-based authentication
  693.      *
  694.      * @param string $signature the API signature used for signature-based
  695.      *                           authentication.
  696.      *
  697.      * @return Payment_PayPal_SOAP the current object, for fluent interface.
  698.      *
  699.      * @see Payment_PayPal_SOAP::__construct()
  700.      * @see Payment_PayPal_SOAP::$_signature
  701.      */
  702.     protected function setSignature($signature)
  703.     {
  704.         $this->_signature = strval($signature);
  705.         return $this;
  706.     }
  707.  
  708.     // }}}
  709.     // {{{ setSubject()
  710.  
  711.     /**
  712.      * Sets the subject used for making requests on behalf of a third-party
  713.      *
  714.      * For example, you may be running a marketplace where customers will
  715.      * purchase goods directlry from your clients through your market. In this
  716.      * case, you can use the client's PayPal email address as the subject to
  717.      * initiate a checkout for the customer in your marketplace.
  718.      *
  719.      * @param string $subject the email address of the third-party. Your API
  720.      *                         username may require explicit access be granted
  721.      *                         from the third-party before certain API actions
  722.      *                         will work.
  723.      *
  724.      * @return Payment_PayPal_SOAP the current object, for fluent interface.
  725.      *
  726.      * @see Payment_PayPal_SOAP::__construct()
  727.      * @see Payment_PayPal_SOAP::$_subject
  728.      */
  729.     protected function setSubject($subject)
  730.     {
  731.         $this->_subject = strval($subject);
  732.         return $this;
  733.     }
  734.  
  735.     // }}}
  736.     // {{{ setCertificateFile()
  737.  
  738.     /**
  739.      * Sets the local certificate file used for certificate-based
  740.      * authentication
  741.      *
  742.      * This file is downloaded from your API credentials page when logged into
  743.      * your PayPal account.
  744.      *
  745.      * @param string $certificateFile the local certificate file used for
  746.      *                                 certificate-based authentication.
  747.      *
  748.      * @return Payment_PayPal_SOAP the current object, for fluent interface.
  749.      *
  750.      * @see Payment_PayPal_SOAP::__construct()
  751.      * @see Payment_PayPal_SOAP::$soapOptions
  752.      */
  753.     protected function setCertificateFile($certificateFile)
  754.     {
  755.         $certificateFile strval($certificateFile);
  756.         if ($certificateFile{
  757.             $this->soapOptions['local_cert'$certificateFile;
  758.         }
  759.         return $this;
  760.     }
  761.  
  762.     // }}}
  763.     // {{{ setMode()
  764.  
  765.     /**
  766.      * Sets the mode to use for API calls
  767.      *
  768.      * @param string $mode the mode to use for PayPal API calls. Valid modes
  769.      *                      are:
  770.      *                      - <kbd>sandbox</kbd> - for development and testing
  771.      *                      - <kbd>live</kbd>    - for live payments.
  772.      *
  773.      * @return Payment_PayPal_SOAP the current object, for fluent interface.
  774.      *
  775.      * @throws Payment_PayPal_SOAP_InvalidModeException if an invalid mode is
  776.      *          specified.
  777.      *
  778.      * @see Payment_PayPal_SOAP::__construct()
  779.      */
  780.     protected function setMode($mode)
  781.     {
  782.         $mode strval($mode);
  783.  
  784.         $validModes = array('sandbox''live');
  785.         if (!in_array($mode$validModes)) {
  786.             throw new Payment_PayPal_SOAP_InvalidModeException(
  787.                 'Mode "' $mode '" is invalid. Mode must be either ' .
  788.                 '"sandbox" or "live".'0$mode);
  789.         }
  790.  
  791.         $this->_mode = $mode;
  792.  
  793.         return $this;
  794.     }
  795.  
  796.     // }}}
  797.     // {{{ getWsdlFile()
  798.  
  799.     /**
  800.      * Gets the WSDL file to use when building the SOAP object
  801.      *
  802.      * @return string the WSDL file to use when building the SOAP object.
  803.      */
  804.     protected function getWsdlFile()
  805.     {
  806.         if ($this->useLocalWsdl{
  807.             $path '@data-dir@/Payment_PayPal_SOAP/data/wsdl';
  808.             if (substr($path01=== '@'{
  809.                 $path dirname(__FILE__'/../../data/wsdl';
  810.             }
  811.  
  812.             switch ($this->_mode{
  813.             case 'live':
  814.                 $file $path '/live/PayPalSvc.wsdl';
  815.                 break;
  816.             case 'sandbox':
  817.             default:
  818.                 $file $path '/sandbox/PayPalSvc.wsdl';
  819.                 break;
  820.             }
  821.         else {
  822.             switch ($this->_mode{
  823.             case 'live':
  824.                 $file 'https://www.paypal.com/wsdl/PayPalSvc.wsdl';
  825.                 break;
  826.             case 'sandbox':
  827.             default:
  828.                 $file 'https://www.sandbox.paypal.com/wsdl/PayPalSvc.wsdl';
  829.                 break;
  830.             }
  831.         }
  832.  
  833.         return $file;
  834.     }
  835.  
  836.     // }}}
  837. }
  838.  
  839. ?>

Documentation generated on Tue, 25 Sep 2012 14:30:04 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.