File indexing completed on 2025-01-26 05:24:55

 <?php
 /**
  * Zend Framework
  *
  * LICENSE
  *
  * This source file is subject to the new BSD license that is bundled
  * with this package in the file LICENSE.txt.
  * It is also available through the world-wide-web at this URL:
  * http://framework.zend.com/license/new-bsd
  * If you did not receive a copy of the license and are unable to
  * obtain it through the world-wide-web, please send an email
  * to license@zend.com so we can send you a copy immediately.
  *
  * @category   Zend
  * @package    Zend_Controller
  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  * @version    $Id$
  */
 
 
 /** Zend_Loader */
 // require_once 'Zend/Loader.php';
 
 /** Zend_Controller_Action_HelperBroker */
 // require_once 'Zend/Controller/Action/HelperBroker.php';
 
 /** Zend_Controller_Plugin_Broker */
 // require_once 'Zend/Controller/Plugin/Broker.php';
 
 /**
  * @category   Zend
  * @package    Zend_Controller
  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  */
 class Zend_Controller_Front
 {
     /**
      * Base URL
      * @var string
      */
     protected $_baseUrl = null;
 
     /**
      * Directory|ies where controllers are stored
      *
      * @var string|array
      */
     protected $_controllerDir = null;
 
     /**
      * Instance of Zend_Controller_Dispatcher_Interface
      * @var Zend_Controller_Dispatcher_Interface
      */
     protected $_dispatcher = null;
 
     /**
      * Singleton instance
      *
      * Marked only as protected to allow extension of the class. To extend,
      * simply override {@link getInstance()}.
      *
      * @var Zend_Controller_Front
      */
     protected static $_instance = null;
 
     /**
      * Array of invocation parameters to use when instantiating action
      * controllers
      * @var array
      */
     protected $_invokeParams = array();
 
     /**
      * Subdirectory within a module containing controllers; defaults to 'controllers'
      * @var string
      */
     protected $_moduleControllerDirectoryName = 'controllers';
 
     /**
      * Instance of Zend_Controller_Plugin_Broker
      * @var Zend_Controller_Plugin_Broker
      */
     protected $_plugins = null;
 
     /**
      * Instance of Zend_Controller_Request_Abstract
      * @var Zend_Controller_Request_Abstract
      */
     protected $_request = null;
 
     /**
      * Instance of Zend_Controller_Response_Abstract
      * @var Zend_Controller_Response_Abstract
      */
     protected $_response = null;
 
     /**
      * Whether or not to return the response prior to rendering output while in
      * {@link dispatch()}; default is to send headers and render output.
      * @var boolean
      */
     protected $_returnResponse = false;
 
     /**
      * Instance of Zend_Controller_Router_Interface
      * @var Zend_Controller_Router_Interface
      */
     protected $_router = null;
 
     /**
      * Whether or not exceptions encountered in {@link dispatch()} should be
      * thrown or trapped in the response object
      * @var boolean
      */
     protected $_throwExceptions = false;
 
     /**
      * Constructor
      *
      * Instantiate using {@link getInstance()}; front controller is a singleton
      * object.
      *
      * Instantiates the plugin broker.
      *
      * @return void
      */
     protected function __construct()
     {
         $this->_plugins = new Zend_Controller_Plugin_Broker();
     }
 
     /**
      * Enforce singleton; disallow cloning
      *
      * @return void
      */
     private function __clone()
     {
     }
 
     /**
      * Singleton instance
      *
      * @return Zend_Controller_Front
      */
     public static function getInstance()
     {
         if (null === self::$_instance) {
             self::$_instance = new self();
         }
 
         return self::$_instance;
     }
 
     /**
      * Resets all object properties of the singleton instance
      *
      * Primarily used for testing; could be used to chain front controllers.
      *
      * Also resets action helper broker, clearing all registered helpers.
      *
      * @return void
      */
     public function resetInstance()
     {
         $reflection = new ReflectionObject($this);
         foreach ($reflection->getProperties() as $property) {
             $name = $property->getName();
             switch ($name) {
                 case '_instance':
                     break;
                 case '_controllerDir':
                 case '_invokeParams':
                     $this->{$name} = array();
                     break;
                 case '_plugins':
                     $this->{$name} = new Zend_Controller_Plugin_Broker();
                     break;
                 case '_throwExceptions':
                 case '_returnResponse':
                     $this->{$name} = false;
                     break;
                 case '_moduleControllerDirectoryName':
                     $this->{$name} = 'controllers';
                     break;
                 default:
                     $this->{$name} = null;
                     break;
             }
         }
         Zend_Controller_Action_HelperBroker::resetHelpers();
     }
 
     /**
      * Convenience feature, calls setControllerDirectory()->setRouter()->dispatch()
      *
      * In PHP 5.1.x, a call to a static method never populates $this -- so run()
      * may actually be called after setting up your front controller.
      *
      * @param string|array $controllerDirectory Path to Zend_Controller_Action
      * controller classes or array of such paths
      * @return void
      * @throws Zend_Controller_Exception if called from an object instance
      */
     public static function run($controllerDirectory)
     {
         self::getInstance()
             ->setControllerDirectory($controllerDirectory)
             ->dispatch();
     }
 
     /**
      * Add a controller directory to the controller directory stack
      *
      * If $args is presented and is a string, uses it for the array key mapping
      * to the directory specified.
      *
      * @param string $directory
      * @param string $module Optional argument; module with which to associate directory. If none provided, assumes 'default'
      * @return Zend_Controller_Front
      * @throws Zend_Controller_Exception if directory not found or readable
      */
     public function addControllerDirectory($directory, $module = null)
     {
         $this->getDispatcher()->addControllerDirectory($directory, $module);
         return $this;
     }
 
     /**
      * Set controller directory
      *
      * Stores controller directory(ies) in dispatcher. May be an array of
      * directories or a string containing a single directory.
      *
      * @param string|array $directory Path to Zend_Controller_Action controller
      * classes or array of such paths
      * @param  string $module Optional module name to use with string $directory
      * @return Zend_Controller_Front
      */
     public function setControllerDirectory($directory, $module = null)
     {
         $this->getDispatcher()->setControllerDirectory($directory, $module);
         return $this;
     }
 
     /**
      * Retrieve controller directory
      *
      * Retrieves:
      * - Array of all controller directories if no $name passed
      * - String path if $name passed and exists as a key in controller directory array
      * - null if $name passed but does not exist in controller directory keys
      *
      * @param  string $name Default null
      * @return array|string|null
      */
     public function getControllerDirectory($name = null)
     {
         return $this->getDispatcher()->getControllerDirectory($name);
     }
 
     /**
      * Remove a controller directory by module name
      *
      * @param  string $module
      * @return bool
      */
     public function removeControllerDirectory($module)
     {
         return $this->getDispatcher()->removeControllerDirectory($module);
     }
 
     /**
      * Specify a directory as containing modules
      *
      * Iterates through the directory, adding any subdirectories as modules;
      * the subdirectory within each module named after {@link $_moduleControllerDirectoryName}
      * will be used as the controller directory path.
      *
      * @param  string $path
      * @return Zend_Controller_Front
      */
     public function addModuleDirectory($path)
     {
         try{
             $dir = new DirectoryIterator($path);
         } catch(Exception $e) {
             // require_once 'Zend/Controller/Exception.php';
             throw new Zend_Controller_Exception("Directory $path not readable", 0, $e);
         }
         foreach ($dir as $file) {
             if ($file->isDot() || !$file->isDir()) {
                 continue;
             }
 
             $module    = $file->getFilename();
 
             // Don't use SCCS directories as modules
             if (preg_match('/^[^a-z]/i', $module) || ('CVS' == $module)) {
                 continue;
             }
 
             $moduleDir = $file->getPathname() . DIRECTORY_SEPARATOR . $this->getModuleControllerDirectoryName();
             $this->addControllerDirectory($moduleDir, $module);
         }
 
         return $this;
     }
 
     /**
      * Return the path to a module directory (but not the controllers directory within)
      *
      * @param  string $module
      * @return string|null
      */
     public function getModuleDirectory($module = null)
     {
         if (null === $module) {
             $request = $this->getRequest();
             if (null !== $request) {
                 $module = $this->getRequest()->getModuleName();
             }
             if (empty($module)) {
                 $module = $this->getDispatcher()->getDefaultModule();
             }
         }
 
         $controllerDir = $this->getControllerDirectory($module);
 
         if ((null === $controllerDir) || !is_string($controllerDir)) {
             return null;
         }
 
         return dirname($controllerDir);
     }
 
     /**
      * Set the directory name within a module containing controllers
      *
      * @param  string $name
      * @return Zend_Controller_Front
      */
     public function setModuleControllerDirectoryName($name = 'controllers')
     {
         $this->_moduleControllerDirectoryName = (string) $name;
 
         return $this;
     }
 
     /**
      * Return the directory name within a module containing controllers
      *
      * @return string
      */
     public function getModuleControllerDirectoryName()
     {
         return $this->_moduleControllerDirectoryName;
     }
 
     /**
      * Set the default controller (unformatted string)
      *
      * @param string $controller
      * @return Zend_Controller_Front
      */
     public function setDefaultControllerName($controller)
     {
         $dispatcher = $this->getDispatcher();
         $dispatcher->setDefaultControllerName($controller);
         return $this;
     }
 
     /**
      * Retrieve the default controller (unformatted string)
      *
      * @return string
      */
     public function getDefaultControllerName()
     {
         return $this->getDispatcher()->getDefaultControllerName();
     }
 
     /**
      * Set the default action (unformatted string)
      *
      * @param string $action
      * @return Zend_Controller_Front
      */
     public function setDefaultAction($action)
     {
         $dispatcher = $this->getDispatcher();
         $dispatcher->setDefaultAction($action);
         return $this;
     }
 
     /**
      * Retrieve the default action (unformatted string)
      *
      * @return string
      */
     public function getDefaultAction()
     {
         return $this->getDispatcher()->getDefaultAction();
     }
 
     /**
      * Set the default module name
      *
      * @param string $module
      * @return Zend_Controller_Front
      */
     public function setDefaultModule($module)
     {
         $dispatcher = $this->getDispatcher();
         $dispatcher->setDefaultModule($module);
         return $this;
     }
 
     /**
      * Retrieve the default module
      *
      * @return string
      */
     public function getDefaultModule()
     {
         return $this->getDispatcher()->getDefaultModule();
     }
 
     /**
      * Set request class/object
      *
      * Set the request object.  The request holds the request environment.
      *
      * If a class name is provided, it will instantiate it
      *
      * @param string|Zend_Controller_Request_Abstract $request
      * @throws Zend_Controller_Exception if invalid request class
      * @return Zend_Controller_Front
      */
     public function setRequest($request)
     {
         if (is_string($request)) {
             if (!class_exists($request)) {
                 // require_once 'Zend/Loader.php';
                 Zend_Loader::loadClass($request);
             }
             $request = new $request();
         }
         if (!$request instanceof Zend_Controller_Request_Abstract) {
             // require_once 'Zend/Controller/Exception.php';
             throw new Zend_Controller_Exception('Invalid request class');
         }
 
         $this->_request = $request;
 
         return $this;
     }
 
     /**
      * Return the request object.
      *
      * @return null|Zend_Controller_Request_Abstract
      */
     public function getRequest()
     {
         return $this->_request;
     }
 
     /**
      * Set router class/object
      *
      * Set the router object.  The router is responsible for mapping
      * the request to a controller and action.
      *
      * If a class name is provided, instantiates router with any parameters
      * registered via {@link setParam()} or {@link setParams()}.
      *
      * @param string|Zend_Controller_Router_Interface $router
      * @throws Zend_Controller_Exception if invalid router class
      * @return Zend_Controller_Front
      */
     public function setRouter($router)
     {
         if (is_string($router)) {
             if (!class_exists($router)) {
                 // require_once 'Zend/Loader.php';
                 Zend_Loader::loadClass($router);
             }
             $router = new $router();
         }
 
         if (!$router instanceof Zend_Controller_Router_Interface) {
             // require_once 'Zend/Controller/Exception.php';
             throw new Zend_Controller_Exception('Invalid router class');
         }
 
         $router->setFrontController($this);
         $this->_router = $router;
 
         return $this;
     }
 
     /**
      * Return the router object.
      *
      * Instantiates a Zend_Controller_Router_Rewrite object if no router currently set.
      *
      * @return Zend_Controller_Router_Interface
      */
     public function getRouter()
     {
         if (null == $this->_router) {
             // require_once 'Zend/Controller/Router/Rewrite.php';
             $this->setRouter(new Zend_Controller_Router_Rewrite());
         }
 
         return $this->_router;
     }
 
     /**
      * Set the base URL used for requests
      *
      * Use to set the base URL segment of the REQUEST_URI to use when
      * determining PATH_INFO, etc. Examples:
      * - /admin
      * - /myapp
      * - /subdir/index.php
      *
      * Note that the URL should not include the full URI. Do not use:
      * - http://example.com/admin
      * - http://example.com/myapp
      * - http://example.com/subdir/index.php
      *
      * If a null value is passed, this can be used as well for autodiscovery (default).
      *
      * @param string $base
      * @return Zend_Controller_Front
      * @throws Zend_Controller_Exception for non-string $base
      */
     public function setBaseUrl($base = null)
     {
         if (!is_string($base) && (null !== $base)) {
             // require_once 'Zend/Controller/Exception.php';
             throw new Zend_Controller_Exception('Rewrite base must be a string');
         }
 
         $this->_baseUrl = $base;
 
         if ((null !== ($request = $this->getRequest())) && (method_exists($request, 'setBaseUrl'))) {
             $request->setBaseUrl($base);
         }
 
         return $this;
     }
 
     /**
      * Retrieve the currently set base URL
      *
      * @return string
      */
     public function getBaseUrl()
     {
         $request = $this->getRequest();
         if ((null !== $request) && method_exists($request, 'getBaseUrl')) {
             return $request->getBaseUrl();
         }
 
         return $this->_baseUrl;
     }
 
     /**
      * Set the dispatcher object.  The dispatcher is responsible for
      * taking a Zend_Controller_Dispatcher_Token object, instantiating the controller, and
      * call the action method of the controller.
      *
      * @param Zend_Controller_Dispatcher_Interface $dispatcher
      * @return Zend_Controller_Front
      */
     public function setDispatcher(Zend_Controller_Dispatcher_Interface $dispatcher)
     {
         $this->_dispatcher = $dispatcher;
         return $this;
     }
 
     /**
      * Return the dispatcher object.
      *
      * @return Zend_Controller_Dispatcher_Interface
      */
     public function getDispatcher()
     {
         /**
          * Instantiate the default dispatcher if one was not set.
          */
         if (!$this->_dispatcher instanceof Zend_Controller_Dispatcher_Interface) {
             // require_once 'Zend/Controller/Dispatcher/Standard.php';
             $this->_dispatcher = new Zend_Controller_Dispatcher_Standard();
         }
         return $this->_dispatcher;
     }
 
     /**
      * Set response class/object
      *
      * Set the response object.  The response is a container for action
      * responses and headers. Usage is optional.
      *
      * If a class name is provided, instantiates a response object.
      *
      * @param string|Zend_Controller_Response_Abstract $response
      * @throws Zend_Controller_Exception if invalid response class
      * @return Zend_Controller_Front
      */
     public function setResponse($response)
     {
         if (is_string($response)) {
             if (!class_exists($response)) {
                 // require_once 'Zend/Loader.php';
                 Zend_Loader::loadClass($response);
             }
             $response = new $response();
         }
         if (!$response instanceof Zend_Controller_Response_Abstract) {
             // require_once 'Zend/Controller/Exception.php';
             throw new Zend_Controller_Exception('Invalid response class');
         }
 
         $this->_response = $response;
 
         return $this;
     }
 
     /**
      * Return the response object.
      *
      * @return null|Zend_Controller_Response_Abstract
      */
     public function getResponse()
     {
         return $this->_response;
     }
 
     /**
      * Add or modify a parameter to use when instantiating an action controller
      *
      * @param string $name
      * @param mixed $value
      * @return Zend_Controller_Front
      */
     public function setParam($name, $value)
     {
         $name = (string) $name;
         $this->_invokeParams[$name] = $value;
         return $this;
     }
 
     /**
      * Set parameters to pass to action controller constructors
      *
      * @param array $params
      * @return Zend_Controller_Front
      */
     public function setParams(array $params)
     {
         $this->_invokeParams = array_merge($this->_invokeParams, $params);
         return $this;
     }
 
     /**
      * Retrieve a single parameter from the controller parameter stack
      *
      * @param string $name
      * @return mixed
      */
     public function getParam($name)
     {
         if(isset($this->_invokeParams[$name])) {
             return $this->_invokeParams[$name];
         }
 
         return null;
     }
 
     /**
      * Retrieve action controller instantiation parameters
      *
      * @return array
      */
     public function getParams()
     {
         return $this->_invokeParams;
     }
 
     /**
      * Clear the controller parameter stack
      *
      * By default, clears all parameters. If a parameter name is given, clears
      * only that parameter; if an array of parameter names is provided, clears
      * each.
      *
      * @param null|string|array single key or array of keys for params to clear
      * @return Zend_Controller_Front
      */
     public function clearParams($name = null)
     {
         if (null === $name) {
             $this->_invokeParams = array();
         } elseif (is_string($name) && isset($this->_invokeParams[$name])) {
             unset($this->_invokeParams[$name]);
         } elseif (is_array($name)) {
             foreach ($name as $key) {
                 if (is_string($key) && isset($this->_invokeParams[$key])) {
                     unset($this->_invokeParams[$key]);
                 }
             }
         }
 
         return $this;
     }
 
     /**
      * Register a plugin.
      *
      * @param  Zend_Controller_Plugin_Abstract $plugin
      * @param  int $stackIndex Optional; stack index for plugin
      * @return Zend_Controller_Front
      */
     public function registerPlugin(Zend_Controller_Plugin_Abstract $plugin, $stackIndex = null)
     {
         $this->_plugins->registerPlugin($plugin, $stackIndex);
         return $this;
     }
 
     /**
      * Unregister a plugin.
      *
      * @param  string|Zend_Controller_Plugin_Abstract $plugin Plugin class or object to unregister
      * @return Zend_Controller_Front
      */
     public function unregisterPlugin($plugin)
     {
         $this->_plugins->unregisterPlugin($plugin);
         return $this;
     }
 
     /**
      * Is a particular plugin registered?
      *
      * @param  string $class
      * @return bool
      */
     public function hasPlugin($class)
     {
         return $this->_plugins->hasPlugin($class);
     }
 
     /**
      * Retrieve a plugin or plugins by class
      *
      * @param  string $class
      * @return false|Zend_Controller_Plugin_Abstract|array
      */
     public function getPlugin($class)
     {
         return $this->_plugins->getPlugin($class);
     }
 
     /**
      * Retrieve all plugins
      *
      * @return array
      */
     public function getPlugins()
     {
         return $this->_plugins->getPlugins();
     }
 
     /**
      * Set the throwExceptions flag and retrieve current status
      *
      * Set whether exceptions encounted in the dispatch loop should be thrown
      * or caught and trapped in the response object.
      *
      * Default behaviour is to trap them in the response object; call this
      * method to have them thrown.
      *
      * Passing no value will return the current value of the flag; passing a
      * boolean true or false value will set the flag and return the current
      * object instance.
      *
      * @param boolean $flag Defaults to null (return flag state)
      * @return boolean|Zend_Controller_Front Used as a setter, returns object; as a getter, returns boolean
      */
     public function throwExceptions($flag = null)
     {
         if ($flag !== null) {
             $this->_throwExceptions = (bool) $flag;
             return $this;
         }
 
         return $this->_throwExceptions;
     }
 
     /**
      * Set whether {@link dispatch()} should return the response without first
      * rendering output. By default, output is rendered and dispatch() returns
      * nothing.
      *
      * @param boolean $flag
      * @return boolean|Zend_Controller_Front Used as a setter, returns object; as a getter, returns boolean
      */
     public function returnResponse($flag = null)
     {
         if (true === $flag) {
             $this->_returnResponse = true;
             return $this;
         } elseif (false === $flag) {
             $this->_returnResponse = false;
             return $this;
         }
 
         return $this->_returnResponse;
     }
 
     /**
      * Dispatch an HTTP request to a controller/action.
      *
      * @param Zend_Controller_Request_Abstract|null $request
      * @param Zend_Controller_Response_Abstract|null $response
      * @return void|Zend_Controller_Response_Abstract Returns response object if returnResponse() is true
      */
     public function dispatch(Zend_Controller_Request_Abstract $request = null, Zend_Controller_Response_Abstract $response = null)
     {
         if (!$this->getParam('noErrorHandler') && !$this->_plugins->hasPlugin('Zend_Controller_Plugin_ErrorHandler')) {
             // Register with stack index of 100
             // require_once 'Zend/Controller/Plugin/ErrorHandler.php';
             $this->_plugins->registerPlugin(new Zend_Controller_Plugin_ErrorHandler(), 100);
         }
 
         if (!$this->getParam('noViewRenderer') && !Zend_Controller_Action_HelperBroker::hasHelper('viewRenderer')) {
             // require_once 'Zend/Controller/Action/Helper/ViewRenderer.php';
             Zend_Controller_Action_HelperBroker::getStack()->offsetSet(-80, new Zend_Controller_Action_Helper_ViewRenderer());
         }
 
         /**
          * Instantiate default request object (HTTP version) if none provided
          */
         if (null !== $request) {
             $this->setRequest($request);
         } elseif ((null === $request) && (null === ($request = $this->getRequest()))) {
             // require_once 'Zend/Controller/Request/Http.php';
             $request = new Zend_Controller_Request_Http();
             $this->setRequest($request);
         }
 
         /**
          * Set base URL of request object, if available
          */
         if (is_callable(array($this->_request, 'setBaseUrl'))) {
             if (null !== $this->_baseUrl) {
                 $this->_request->setBaseUrl($this->_baseUrl);
             }
         }
 
         /**
          * Instantiate default response object (HTTP version) if none provided
          */
         if (null !== $response) {
             $this->setResponse($response);
         } elseif ((null === $this->_response) && (null === ($this->_response = $this->getResponse()))) {
             // require_once 'Zend/Controller/Response/Http.php';
             $response = new Zend_Controller_Response_Http();
             $this->setResponse($response);
         }
 
         /**
          * Register request and response objects with plugin broker
          */
         $this->_plugins
              ->setRequest($this->_request)
              ->setResponse($this->_response);
 
         /**
          * Initialize router
          */
         $router = $this->getRouter();
         $router->setParams($this->getParams());
 
         /**
          * Initialize dispatcher
          */
         $dispatcher = $this->getDispatcher();
         $dispatcher->setParams($this->getParams())
                    ->setResponse($this->_response);
 
         // Begin dispatch
         try {
             /**
              * Route request to controller/action, if a router is provided
              */
 
             /**
             * Notify plugins of router startup
             */
             $this->_plugins->routeStartup($this->_request);
 
             try {
                 $router->route($this->_request);
             }  catch (Exception $e) {
                 if ($this->throwExceptions()) {
                     throw $e;
                 }
 
                 $this->_response->setException($e);
             }
 
             /**
             * Notify plugins of router completion
             */
             $this->_plugins->routeShutdown($this->_request);
 
             /**
              * Notify plugins of dispatch loop startup
              */
             $this->_plugins->dispatchLoopStartup($this->_request);
 
             /**
              *  Attempt to dispatch the controller/action. If the $this->_request
              *  indicates that it needs to be dispatched, move to the next
              *  action in the request.
              */
             do {
                 $this->_request->setDispatched(true);
 
                 /**
                  * Notify plugins of dispatch startup
                  */
                 $this->_plugins->preDispatch($this->_request);
 
                 /**
                  * Skip requested action if preDispatch() has reset it
                  */
                 if (!$this->_request->isDispatched()) {
                     continue;
                 }
 
                 /**
                  * Dispatch request
                  */
                 try {
                     $dispatcher->dispatch($this->_request, $this->_response);
                 } catch (Exception $e) {
                     if ($this->throwExceptions()) {
                         throw $e;
                     }
                     $this->_response->setException($e);
                 }
 
                 /**
                  * Notify plugins of dispatch completion
                  */
                 $this->_plugins->postDispatch($this->_request);
             } while (!$this->_request->isDispatched());
         } catch (Exception $e) {
             if ($this->throwExceptions()) {
                 throw $e;
             }
 
             $this->_response->setException($e);
         }
 
         /**
          * Notify plugins of dispatch loop completion
          */
         try {
             $this->_plugins->dispatchLoopShutdown();
         } catch (Exception $e) {
             if ($this->throwExceptions()) {
                 throw $e;
             }
 
             $this->_response->setException($e);
         }
 
         if ($this->returnResponse()) {
             return $this->_response;
         }
 
         $this->_response->sendResponse();
     }
 }