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

Source for file Exceptions.php

Documentation is available at Exceptions.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.  * This file contains various package-specific exception class definitions.
  9.  *
  10.  * PHP version 5
  11.  *
  12.  * LICENSE:
  13.  *
  14.  * Copyright (c) 2008-2012 silverorange
  15.  *
  16.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  17.  * of this software and associated documentation files (the "Software"), to deal
  18.  * in the Software without restriction, including without limitation the rights
  19.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  20.  * copies of the Software, and to permit persons to whom the Software is
  21.  * furnished to do so, subject to the following conditions:
  22.  *
  23.  * The above copyright notice and this permission notice shall be included in
  24.  * all copies or substantial portions of the Software.
  25.  *
  26.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  27.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  28.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  29.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  30.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  31.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  32.  * THE SOFTWARE.
  33.  *
  34.  * @category  Payment
  35.  * @package   Payment_PayPal_SOAP
  36.  * @author    Michael Gauthier <mike@silverorange.com>
  37.  * @copyright 2008-2012 silverorange
  38.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  39.  * @version   CVS: $Id$
  40.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  41.  */
  42.  
  43. /**
  44.  * Error class
  45.  */
  46. require_once 'Payment/PayPal/SOAP/Error.php';
  47.  
  48. // {{{ interface Payment_PayPal_SOAP_Exception
  49.  
  50. /**
  51.  * Base interface for exceptions thrown by the Payment_PayPal_SOAP package
  52.  *
  53.  * @category  Payment
  54.  * @package   Payment_PayPal_SOAP
  55.  * @author    Michael Gauthier <mike@silverorange.com>
  56.  * @copyright 2008-2012 silverorange
  57.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  58.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  59.  */
  60. {
  61. }
  62.  
  63. // }}}
  64. // {{{ class Payment_PayPal_SOAP_InvalidModeException
  65.  
  66. /**
  67.  * Exception thrown when an invalid mode is used in the client constructor
  68.  *
  69.  * @category  Payment
  70.  * @package   Payment_PayPal_SOAP
  71.  * @author    Michael Gauthier <mike@silverorange.com>
  72.  * @copyright 2008-2012 silverorange
  73.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  74.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  75.  */
  76.     extends InvalidArgumentException
  77.     implements Payment_PayPal_SOAP_Exception
  78. {
  79.     // {{{ protected properties
  80.  
  81.     /**
  82.      * The invalid mode that was used
  83.      *
  84.      * @var string 
  85.      *
  86.      * @see Payment_PayPal_SOAP_InvalidModeException::getMode()
  87.      */
  88.     protected $_mode = '';
  89.  
  90.     // }}}
  91.     // {{{ __construct()
  92.  
  93.     /**
  94.      * Creates a new invalid mode exception
  95.      *
  96.      * @param string  $message the exception message.
  97.      * @param integer $code    the exception code.
  98.      * @param string  $mode    the invalid mode that was used.
  99.      */
  100.     public function __construct($message$code = 0$mode '')
  101.     {
  102.         parent::__construct($message$code);
  103.         $this->_mode = $mode;
  104.     }
  105.  
  106.     // }}}
  107.     // {{{ getMode()
  108.  
  109.     /**
  110.      * Gets the invalid mode that was used
  111.      *
  112.      * @return string the invalid mode that was used.
  113.      *
  114.      * @see PaymentPayPal_SOAP_InvalidModeException::$_mode
  115.      */
  116.     public function getMode()
  117.     {
  118.         return $this->_mode;
  119.     }
  120.  
  121.     // }}}
  122. }
  123.  
  124. // }}}
  125. // {{{ class Payment_PayPal_SOAP_InvalidRequestNameException
  126.  
  127. /**
  128.  * Exception thrown when an invalid request name is used in the
  129.  * {@link Payment_PayPal_SOAP_Client::call()} method
  130.  *
  131.  * @category  Payment
  132.  * @package   Payment_PayPal_SOAP
  133.  * @author    Michael Gauthier <mike@silverorange.com>
  134.  * @copyright 2008-2012 silverorange
  135.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  136.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  137.  */
  138.     extends InvalidArgumentException
  139.     implements Payment_PayPal_SOAP_Exception
  140. {
  141.     // {{{ protected properties
  142.  
  143.     /**
  144.      * The invalid request name that was used
  145.      *
  146.      * @var string 
  147.      *
  148.      * @see Payment_PayPal_SOAP_InvalidRequestNameException::getRequestName()
  149.      */
  150.     protected $_requestName = '';
  151.  
  152.     // }}}
  153.     // {{{ __construct()
  154.  
  155.     /**
  156.      * Creates a new invalid request name exception
  157.      *
  158.      * @param string  $message     the exception message.
  159.      * @param integer $code        the exception code.
  160.      * @param string  $requestName the invalid request name that was used.
  161.      */
  162.     public function __construct($message$code = 0$requestName '')
  163.     {
  164.         parent::__construct($message$code);
  165.         $this->_requestName = $requestName;
  166.     }
  167.  
  168.     // }}}
  169.     // {{{ getRequestName()
  170.  
  171.     /**
  172.      * Gets the invalid request name that was used
  173.      *
  174.      * @return string the invalid request name that was used.
  175.      *
  176.      * @see PaymentPayPal_SOAP_InvalidRequestNameException::$_requestName
  177.      */
  178.     public function getRequestName()
  179.     {
  180.         return $this->_requestName;
  181.     }
  182.  
  183.     // }}}
  184. }
  185.  
  186. // }}}
  187. // {{{ class Payment_PayPal_SOAP_MissingPropertyException
  188.  
  189. /**
  190.  * Exception thrown when a required request property is missing in the
  191.  * arguments parameter of a {@link Payment_PayPal_SOAP::call()} method
  192.  * call
  193.  *
  194.  * @category  Payment
  195.  * @package   Payment_PayPal_SOAP
  196.  * @author    Michael Gauthier <mike@silverorange.com>
  197.  * @copyright 2008-2012 silverorange
  198.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  199.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  200.  */
  201.     extends InvalidArgumentException
  202.     implements Payment_PayPal_SOAP_Exception
  203. {
  204.     // {{{ protected properties
  205.  
  206.     /**
  207.      * The name of the property that is missing
  208.      *
  209.      * @var string 
  210.      *
  211.      * @see Payment_PayPal_SOAP_MissingPropertyNameException::getPropertyName()
  212.      */
  213.     protected $_propertyName = '';
  214.  
  215.     // }}}
  216.     // {{{ __construct()
  217.  
  218.     /**
  219.      * Creates a new missing property exception
  220.      *
  221.      * @param string  $message      the exception message.
  222.      * @param integer $code         the exception code.
  223.      * @param string  $propertyName the name of the property that is missing.
  224.      */
  225.     public function __construct($message$code = 0$propertyName '')
  226.     {
  227.         parent::__construct($message$code);
  228.         $this->_propertyName = $propertyName;
  229.     }
  230.  
  231.     // }}}
  232.     // {{{ getRequestName()
  233.  
  234.     /**
  235.      * Gets the name of the property that is missing
  236.      *
  237.      * @return string the name of the property that is missing.
  238.      *
  239.      * @see PaymentPayPal_SOAP_MissingPropertyNameException::$_propertyName
  240.      */
  241.     public function getPropertyName()
  242.     {
  243.         return $this->_propertyName;
  244.     }
  245.  
  246.     // }}}
  247. }
  248.  
  249. // }}}
  250. // {{{ class Payment_PayPal_SOAP_FaultException
  251.  
  252. /**
  253.  * Exception thrown when a SOAP fault occurs
  254.  *
  255.  * @category  Payment
  256.  * @package   Payment_PayPal_SOAP
  257.  * @author    Michael Gauthier <mike@silverorange.com>
  258.  * @copyright 2008-2012 silverorange
  259.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  260.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  261.  */
  262.     extends Exception
  263.     implements Payment_PayPal_SOAP_Exception
  264. {
  265.     // {{{ protected properties
  266.  
  267.     /**
  268.      * The original SoapFault that caused this exception to be thrown
  269.      *
  270.      * @var SoapFault 
  271.      * @see Payment_PayPal_SOAP_FaultException::getSoapFault()
  272.      */
  273.     protected $_soapFault = null;
  274.  
  275.     /**
  276.      * The SOAP client that caused the exception
  277.      *
  278.      * @var SoapClient 
  279.      * @see Payment_PayPal_SOAP_FaultException::getSoapClient()
  280.      */
  281.     protected $_soapClient = null;
  282.  
  283.     // }}}
  284.     // {{{ public function __construct()
  285.  
  286.     /**
  287.      * Creates a new PayPal SOAP fault exception
  288.      *
  289.      * @param string     $message    the exception message.
  290.      * @param integer    $code       the exception code.
  291.      * @param SoapFault  $soapFault  the original SoapFault.
  292.      * @param SoapClient $soapClient the SOAP client that caused the fault.
  293.      */
  294.     public function __construct($message$codeSoapFault $soapFault,
  295.         SoapClient $soapClient)
  296.     {
  297.         parent::__construct($message$code);
  298.         $this->_soapFault  = $soapFault;
  299.         $this->_soapClient = $soapClient;
  300.     }
  301.  
  302.     // }}}
  303.     // {{{ getSoapFault()
  304.  
  305.     /**
  306.      * Gets the original SoapFault that caused this exception to be thrown
  307.      *
  308.      * @return SoapFault the original SoapFault that caused this exception to
  309.      *                    be thrown.
  310.      */
  311.     public function getSoapFault()
  312.     {
  313.         return $this->_soapFault;
  314.     }
  315.  
  316.     // }}}
  317.     // {{{ getSoapClient()
  318.  
  319.     /**
  320.      * Gets the original SOAP client that caused the exception
  321.      *
  322.      * @return SoapClient the SOAP client that caused the exception.
  323.      */
  324.     public function getSoapClient()
  325.     {
  326.         return $this->_soapClient;
  327.     }
  328.  
  329.     // }}}
  330. }
  331.  
  332. // }}}
  333. // {{{ class Payment_PayPal_SOAP_ErrorException
  334.  
  335. /**
  336.  * Exception thrown when the SOAP response contains one or more Error elements
  337.  *
  338.  * A detailed error message is present in the message field. Individual errors
  339.  * can be retrieved using the iterator interface. For example:
  340.  *
  341.  * <code>
  342.  * <?php
  343.  * foreach ($exception as $error) {
  344.  *     echo $error->getMessage(), "\n";
  345.  *     echo $error->getCode(), "\n";
  346.  *     echo $error->getSeverity(), "\n";
  347.  *     echo $error->getType(), "\n";
  348.  * }
  349.  * ?>
  350.  * </code>
  351.  *
  352.  * The full response object may be retrieved using the
  353.  * {@link Payment_PayPal_SOAP_ErrorException::getResponse()} method.
  354.  *
  355.  * @category  Payment
  356.  * @package   Payment_PayPal_SOAP
  357.  * @author    Michael Gauthier <mike@silverorange.com>
  358.  * @copyright 2008-2012 silverorange
  359.  * @license   http://www.opensource.org/licenses/mit-license.html MIT License
  360.  * @link      http://pear.php.net/package/Payment_PayPal_SOAP
  361.  * @see       Payment_PayPal_SOAP_Error
  362.  */
  363.     extends Exception
  364.     implements Payment_PayPal_SOAP_ExceptionIteratorAggregateCountable
  365. {
  366.     // {{{ protected properties
  367.  
  368.     /**
  369.      * The errors aggregated by this exception
  370.      *
  371.      * @var array 
  372.      *
  373.      * @see Payment_PayPal_SOAP_ErrorException::addError()
  374.      * @see Payment_PayPal_SOAP_ErrorException::getIterator()
  375.      * @see Payment_PayPal_SOAP_ErrorException::getSeverity()
  376.      */
  377.     protected $errors = array();
  378.  
  379.     /**
  380.      * The response object that contains the PayPal error(s)
  381.      *
  382.      * @var stdClass 
  383.      *
  384.      * @see Payment_PayPal_SOAP_ErrorException::getResponse()
  385.      */
  386.     protected $response = null;
  387.  
  388.     // }}}
  389.     // {{{ __construct()
  390.  
  391.     /**
  392.      * Creates a new error exception
  393.      *
  394.      * @param string   $message  the exception message.
  395.      * @param integer  $code     the exception code.
  396.      * @param stdClass $response the response object that contains the PayPal
  397.      *                            error(s).
  398.      */
  399.     public function __construct($message$code$response)
  400.     {
  401.         parent::__construct($message$code);
  402.         $this->response = $response;
  403.     }
  404.  
  405.     // }}}
  406.     // {{{ addError()
  407.  
  408.     /**
  409.      * Adds an error to this exception
  410.      *
  411.      * @param string|Payment_PayPal_SOAP_Error$message  either an error object
  412.      *                                                    or a string containing
  413.      *                                                    the error message.
  414.      * @param integer                          $code     optional. The error
  415.      *                                                    code. If first argument
  416.      *                                                    is an object, this is
  417.      *                                                    ignored.
  418.      * @param integer                          $severity optional. The error
  419.      *                                                    severity. If first
  420.      *                                                    argument is an object,
  421.      *                                                    this is ignored.
  422.      * @param integer                          $type     optional. The error
  423.      *                                                    type. If first
  424.      *                                                    argument is an object,
  425.      *                                                    this is ignored.
  426.      *
  427.      * @return Payment_PayPal_SOAP_ErrorException the current object for fluent
  428.      *                                             interface.
  429.      */
  430.     public function addError($message$code = null$severity = null,
  431.         $type = null
  432.     {
  433.         if (!($message instanceof Payment_PayPal_SOAP_Error)) {
  434.             $message = new Payment_PayPal_SOAP_Error(
  435.                 $message,
  436.                 $code,
  437.                 $severity,
  438.                 $type
  439.             );
  440.         }
  441.  
  442.         $this->errors[$message;
  443.     }
  444.  
  445.     // }}}
  446.     // {{{ hasType()
  447.  
  448.     /**
  449.      * Gets whether or not this exception has an aggregated error of the
  450.      * specified type
  451.      *
  452.      * For example:
  453.      * <code>
  454.      * <?php
  455.      * if ($e->hasType(Payment_PayPal_SOAP_Error::TYPE_EXPIRED_TOKEN)) {
  456.      *     echo 'Your token has expired!';
  457.      * }
  458.      * ?>
  459.      * </code>
  460.      *
  461.      * @param integer $type the type for which to check.
  462.      *
  463.      * @return boolean true if this exception has an aggregated error of the
  464.      *                  specified type. Otherwise false.
  465.      */
  466.     public function hasType($type)
  467.     {
  468.         $hasType = false;
  469.  
  470.         foreach ($this->errors as $error{
  471.             if ($error->getType(== $type{
  472.                 $hasType = true;
  473.                 break;
  474.             }
  475.         }
  476.  
  477.         return $hasType;
  478.     }
  479.  
  480.     // }}}
  481.     // {{{ hasSeverity()
  482.  
  483.     /**
  484.      * Gets whether or not this exception has an aggregated error of the
  485.      * specified severity
  486.      *
  487.      * For example:
  488.      * <code>
  489.      * <?php
  490.      * if ($e->hasSeverity(Payment_PayPal_SOAP::ERROR_ERROR)) {
  491.      *     echo 'Uh oh! Something went terribly wrong!';
  492.      * }
  493.      * ?>
  494.      * </code>
  495.      *
  496.      * @param integer $severity the severity for which to check.
  497.      *
  498.      * @return boolean true if this exception has an aggregated error of the
  499.      *                  specified severity. Otherwise false.
  500.      */
  501.     public function hasSeverity($severity)
  502.     {
  503.         $hasSeverity = false;
  504.  
  505.         foreach ($this->errors as $error{
  506.             if ($error->getSeverity(== $severity{
  507.                 $hasSeverity = true;
  508.                 break;
  509.             }
  510.         }
  511.  
  512.         return $hasSeverity;
  513.     }
  514.  
  515.     // }}}
  516.     // {{{ getSeverity()
  517.  
  518.     /**
  519.      * Gets the severity of the PayPal error
  520.      *
  521.      * Will be one of the following:
  522.      *
  523.      * - {@link Payment_PayPal_SOAP::ERROR_WARNING},
  524.      * - {@link Payment_PayPal_SOAP::ERROR_ERROR}, or
  525.      * - {@link Payment_PayPal_SOAP::ERROR_UNKNOWN}
  526.      *
  527.      * @param integer $index optional. The index of the error for which to get
  528.      *                        the severity. If not specified, the severity of
  529.      *                        the first error is returned.
  530.      *
  531.      * @return integer the severity level of the PayPal error.
  532.      */
  533.     public function getSeverity($index = 0)
  534.     {
  535.         $severity Payment_PayPal_SOAP::ERROR_UNKNOWN;
  536.  
  537.         if (isset($this->errors[$index])) {
  538.             $severity $this->errors[$index]->getSeverity();
  539.         }
  540.  
  541.         return $severity;
  542.     }
  543.  
  544.     // }}}
  545.     // {{{ getResponse()
  546.  
  547.     /**
  548.      * Gets the response object containing the PayPal error
  549.      *
  550.      * Additional information about the error may be present here.
  551.      *
  552.      * @return stdClass the response object containing the PayPal error.
  553.      */
  554.     public function getResponse()
  555.     {
  556.         return $this->response;
  557.     }
  558.  
  559.     // }}}
  560.     // {{{ getIterator()
  561.  
  562.     /**
  563.      * Gets an iterator object for the errors of this exception
  564.      *
  565.      * Fulfills the IteratorAggregate interface.
  566.      *
  567.      * @return array an iterator object for the errors of this exception.
  568.      */
  569.     public function getIterator()
  570.     {
  571.         return new ArrayObject($this->errors);
  572.     }
  573.  
  574.     // }}}
  575.     // {{{ getCount()
  576.  
  577.     /**
  578.      * Gets the number of errors aggregated by this exception
  579.      *
  580.      * Fulfills the Countable interface.
  581.      *
  582.      * @return integer the number of errors aggregated by this exception
  583.      */
  584.     public function count()
  585.     {
  586.         return count($this->errors);
  587.     }
  588.  
  589.     // }}}
  590. }
  591.  
  592. // }}}
  593. // {{{ class Payment_PayPal_SOAP_ExpiredTokenException
  594.  
  595. /**
  596.  * Deprecated exception that used to be thrown when a request was made with
  597.  * an expired checkout token
  598.  *
  599.  * This exception class is no longer used. See
  600.  * {@link Payment_PayPal_SOAP_ErrorException} and the
  601.  * {@link Payment_PayPal_SOAP_ErrorException::hasType()} method.
  602.  *
  603.  * @category   Payment
  604.  * @package    Payment_PayPal_SOAP
  605.  * @author     Michael Gauthier <mike@silverorange.com>
  606.  * @copyright  2008-2012 silverorange
  607.  * @license    http://www.opensource.org/licenses/mit-license.html MIT License
  608.  * @link       http://pear.php.net/package/Payment_PayPal_SOAP
  609.  * @deprecated Use {@link Payment_PayPal_SOAP_ErrorException} and the
  610.  *              {@link Payment_PayPal_SOAP_ErrorException::hasType()} method
  611.  *              instead.
  612.  */
  613. {
  614. }
  615.  
  616. // }}}
  617.  
  618. ?>

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