1. sfController.class.php
  2. /**
 * sfController directs application flow.
 *
 * @package    symfony
 * @subpackage controller
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfController.class.php 24265 2009-11-23 11:55:33Z Kris.Wallsmith $
 */
  3. abstract class sfController
  4. {
  5.   protected
  6.     $context           = null,
  7.     $dispatcher        = null,
  8.     $controllerClasses = array(),
  9.     $renderMode        = sfView::RENDER_CLIENT;
  11.   /**
  12.    * Class constructor.
  13.    *
  14.    * @see initialize()
  15.    */
  16.   public function __construct($context)
  17.   {
  18.     $this->initialize($context);
  19.   }
  21.   /**
  22.    * Initializes this controller.
  23.    *
  24.    * @param sfContext $context A sfContext implementation instance
  25.    */
  26.   public function initialize($context)
  27.   {
  28.     $this->context    = $context;
  29.     $this->dispatcher = $context->getEventDispatcher();
  30.   }
  32.   /**
  33.    * Indicates whether or not a module has a specific component.
  34.    *
  35.    * @param string $moduleName    A module name
  36.    * @param string $componentName An component name
  37.    *
  38.    * @return bool true, if the component exists, otherwise false
  39.    */
  40.   public function componentExists($moduleName, $componentName)
  41.   {
  42.     return $this->controllerExists($moduleName, $componentName, 'component', false);
  43.   }
  45.   /**
  46.    * Indicates whether or not a module has a specific action.
  47.    *
  48.    * @param string $moduleName A module name
  49.    * @param string $actionName An action name
  50.    *
  51.    * @return bool true, if the action exists, otherwise false
  52.    */
  53.   public function actionExists($moduleName, $actionName)
  54.   {
  55.     return $this->controllerExists($moduleName, $actionName, 'action', false);
  56.   }
  58.   /**
  59.    * Looks for a controller and optionally throw exceptions if existence is required (i.e.
  60.    * in the case of {@link getController()}).
  61.    *
  62.    * @param string  $moduleName      The name of the module
  63.    * @param string  $controllerName  The name of the controller within the module
  64.    * @param string  $extension       Either 'action' or 'component' depending on the type of controller to look for
  65.    * @param boolean $throwExceptions Whether to throw exceptions if the controller doesn't exist
  66.    *
  67.    * @throws sfConfigurationException thrown if the module is not enabled
  68.    * @throws sfControllerException    thrown if the controller doesn't exist and the $throwExceptions parameter is set to true
  69.    *
  70.    * @return boolean true if the controller exists, false otherwise
  71.    */
  72.   protected function controllerExists($moduleName, $controllerName, $extension, $throwExceptions)
  73.   {
  74.     $dirs = $this->context->getConfiguration()->getControllerDirs($moduleName);
  75.     foreach ($dirs as $dir => $checkEnabled)
  76.     {
  77.       // plugin module enabled?
  78.       if ($checkEnabled && !in_array($moduleName, sfConfig::get('sf_enabled_modules')) && is_readable($dir))
  79.       {
  80.         throw new sfConfigurationException(sprintf('The module "%s" is not enabled.', $moduleName));
  81.       }
  83.       // one action per file or one file for all actions
  84.       $classFile   = strtolower($extension);
  85.       $classSuffix = ucfirst(strtolower($extension));
  86.       $file        = $dir.'/'.$controllerName.$classSuffix.'.class.php';
  87.       if (is_readable($file))
  88.       {
  89.         // action class exists
  90.         require_once($file);
  92.         $this->controllerClasses[$moduleName.'_'.$controllerName.'_'.$classSuffix] = $controllerName.$classSuffix;
  94.         return true;
  95.       }
  97.       $module_file = $dir.'/'.$classFile.'s.class.php';
  98.       if (is_readable($module_file))
  99.       {
  100.         // module class exists
  101.         require_once($module_file);
  103.         if (!class_exists($moduleName.$classSuffix.'s', false))
  104.         {
  105.           if ($throwExceptions)
  106.           {
  107.             throw new sfControllerException(sprintf('There is no "%s" class in your action file "%s".', $moduleName.$classSuffix.'s', $module_file));
  108.           }
  110.           return false;
  111.         }
  113.         // action is defined in this class?
  114.         if (!in_array('execute'.ucfirst($controllerName), get_class_methods($moduleName.$classSuffix.'s')))
  115.         {
  116.           if ($throwExceptions)
  117.           {
  118.             throw new sfControllerException(sprintf('There is no "%s" method in your action class "%s".', 'execute'.ucfirst($controllerName), $moduleName.$classSuffix.'s'));
  119.           }
  121.           return false;
  122.         }
  124.         $this->controllerClasses[$moduleName.'_'.$controllerName.'_'.$classSuffix] = $moduleName.$classSuffix.'s';
  125.         return true;
  126.       }
  127.     }
  129.     // send an exception if debug
  130.     if ($throwExceptions && sfConfig::get('sf_debug'))
  131.     {
  132.       $dirs = array_map(array('sfDebug', 'shortenFilePath'), array_keys($dirs));
  134.       throw new sfControllerException(sprintf('Controller "%s/%s" does not exist in: %s.', $moduleName, $controllerName, implode(', ', $dirs)));
  135.     }
  137.     return false;
  138.   }
  140.   /**
  141.    * Forwards the request to another action.
  142.    *
  143.    * @param string $moduleName A module name
  144.    * @param string $actionName An action name
  145.    *
  146.    * @throws sfConfigurationException  If an invalid configuration setting has been found
  147.    * @throws sfForwardException        If an error occurs while forwarding the request
  148.    * @throws sfError404Exception       If the action not exist
  149.    * @throws sfInitializationException If the action could not be initialized
  150.    */
  151.   public function forward($moduleName, $actionName)
  152.   {
  153.     // replace unwanted characters
  154.     $moduleName = preg_replace('/[^a-z0-9_]+/i', '', $moduleName);
  155.     $actionName = preg_replace('/[^a-z0-9_]+/i', '', $actionName);
  157.     if ($this->getActionStack()->getSize() >= 5)
  158.     {
  159.       // let's kill this party before it turns into cpu cycle hell
  160.       throw new sfForwardException('Too many forwards have been detected for this request.');
  161.     }
  163.     // check for a module generator config file
  164.     $this->context->getConfigCache()->import('modules/'.$moduleName.'/config/generator.yml', false, true);
  166.     if (!$this->actionExists($moduleName, $actionName))
  167.     {
  168.       // the requested action doesn't exist
  169.       if (sfConfig::get('sf_logging_enabled'))
  170.       {
  171.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Action "%s/%s" does not exist', $moduleName, $actionName))));
  172.       }
  174.       throw new sfError404Exception(sprintf('Action "%s/%s" does not exist.', $moduleName, $actionName));
  175.     }
  177.     // create an instance of the action
  178.     $actionInstance = $this->getAction($moduleName, $actionName);
  180.     // add a new action stack entry
  181.     $this->getActionStack()->addEntry($moduleName, $actionName, $actionInstance);
  183.     // include module configuration
  184.     require($this->context->getConfigCache()->checkConfig('modules/'.$moduleName.'/config/module.yml'));
  186.     // module enabled?
  187.     if (sfConfig::get('mod_'.strtolower($moduleName).'_enabled'))
  188.     {
  189.       // check for a module config.php
  190.       $moduleConfig = sfConfig::get('sf_app_module_dir').'/'.$moduleName.'/config/config.php';
  191.       if (is_readable($moduleConfig))
  192.       {
  193.         require_once($moduleConfig);
  194.       }
  196.       // create a new filter chain
  197.       $filterChain = new sfFilterChain();
  198.       $filterChain->loadConfiguration($actionInstance);
  200.       $this->context->getEventDispatcher()->notify(new sfEvent($this, 'controller.change_action', array('module' => $moduleName, 'action' => $actionName)));
  202.       if ($moduleName == sfConfig::get('sf_error_404_module') && $actionName == sfConfig::get('sf_error_404_action'))
  203.       {
  204.         $this->context->getResponse()->setStatusCode(404);
  205.         $this->context->getResponse()->setHttpHeader('Status', '404 Not Found');
  207.         $this->dispatcher->notify(new sfEvent($this, 'controller.page_not_found', array('module' => $moduleName, 'action' => $actionName)));
  208.       }
  210.       // process the filter chain
  211.       $filterChain->execute();
  212.     }
  213.     else
  214.     {
  215.       $moduleName = sfConfig::get('sf_module_disabled_module');
  216.       $actionName = sfConfig::get('sf_module_disabled_action');
  218.       if (!$this->actionExists($moduleName, $actionName))
  219.       {
  220.         // cannot find mod disabled module/action
  221.         throw new sfConfigurationException(sprintf('Invalid configuration settings: [sf_module_disabled_module] "%s", [sf_module_disabled_action] "%s".', $moduleName, $actionName));
  222.       }
  224.       $this->forward($moduleName, $actionName);
  225.     }
  226.   }
  228.   /**
  229.    * Retrieves an sfAction implementation instance.
  230.    *
  231.    * @param string $moduleName A module name
  232.    * @param string $actionName An action name
  233.    *
  234.    * @return sfAction An sfAction implementation instance, if the action exists, otherwise null
  235.    */
  236.   public function getAction($moduleName, $actionName)
  237.   {
  238.     return $this->getController($moduleName, $actionName, 'action');
  239.   }
  241.   /**
  242.    * Retrieves a sfComponent implementation instance.
  243.    *
  244.    * @param string $moduleName    A module name
  245.    * @param string $componentName A component name
  246.    *
  247.    * @return sfComponent A sfComponent implementation instance, if the component exists, otherwise null
  248.    */
  249.   public function getComponent($moduleName, $componentName)
  250.   {
  251.     return $this->getController($moduleName, $componentName, 'component');
  252.   }
  254.   /**
  255.    * Retrieves a controller implementation instance.
  256.    *
  257.    * @param string $moduleName     A module name
  258.    * @param string $controllerName A component name
  259.    * @param string $extension      Either 'action' or 'component' depending on the type of controller to look for
  260.    *
  261.    * @return object A controller implementation instance, if the controller exists, otherwise null
  262.    *
  263.    * @see getComponent(), getAction()
  264.    */
  265.   protected function getController($moduleName, $controllerName, $extension)
  266.   {
  267.     $classSuffix = ucfirst(strtolower($extension));
  268.     if (!isset($this->controllerClasses[$moduleName.'_'.$controllerName.'_'.$classSuffix]))
  269.     {
  270.       $this->controllerExists($moduleName, $controllerName, $extension, true);
  271.     }
  273.     $class = $this->controllerClasses[$moduleName.'_'.$controllerName.'_'.$classSuffix];
  275.     // fix for same name classes
  276.     $moduleClass = $moduleName.'_'.$class;
  278.     if (class_exists($moduleClass, false))
  279.     {
  280.       $class = $moduleClass;
  281.     }
  283.     return new $class($this->context, $moduleName, $controllerName);
  284.   }
  286.   /**
  287.    * Retrieves the action stack.
  288.    *
  289.    * @return sfActionStack An sfActionStack instance, if the action stack is enabled, otherwise null
  290.    */
  291.   public function getActionStack()
  292.   {
  293.     return $this->context->getActionStack();
  294.   }
  296.   /**
  297.    * Retrieves the presentation rendering mode.
  298.    *
  299.    * @return int One of the following:
  300.    *             - sfView::RENDER_CLIENT
  301.    *             - sfView::RENDER_VAR
  302.    */
  303.   public function getRenderMode()
  304.   {
  305.     return $this->renderMode;
  306.   }
  308.   /**
  309.    * Retrieves a sfView implementation instance.
  310.    *
  311.    * @param string $moduleName A module name
  312.    * @param string $actionName An action name
  313.    * @param string $viewName   A view name
  314.    *
  315.    * @return sfView A sfView implementation instance, if the view exists, otherwise null
  316.    */
  317.   public function getView($moduleName, $actionName, $viewName)
  318.   {
  319.     // user view exists?
  320.     $file = sfConfig::get('sf_app_module_dir').'/'.$moduleName.'/view/'.$actionName.$viewName.'View.class.php';
  322.     if (is_readable($file))
  323.     {
  324.       require_once($file);
  326.       $class = $actionName.$viewName.'View';
  328.       // fix for same name classes
  329.       $moduleClass = $moduleName.'_'.$class;
  331.       if (class_exists($moduleClass, false))
  332.       {
  333.         $class = $moduleClass;
  334.       }
  335.     }
  336.     else
  337.     {
  338.       // view class (as configured in module.yml or defined in action)
  339.       $class = sfConfig::get('mod_'.strtolower($moduleName).'_view_class', 'sfPHP').'View';
  340.     }
  342.     return new $class($this->context, $moduleName, $actionName, $viewName);
  343.   }
  345.   /**
  346.    * Returns the rendered view presentation of a given module/action.
  347.    *
  348.    * @param string $module   A module name
  349.    * @param string $action   An action name
  350.    * @param string $viewName A View class name
  351.    *
  352.    * @return string The generated content
  353.    */
  354.   public function getPresentationFor($module, $action, $viewName = null)
  355.   {
  356.     if (sfConfig::get('sf_logging_enabled'))
  357.     {
  358.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Get presentation for action "%s/%s" (view class: "%s")', $module, $action, $viewName))));
  359.     }
  361.     // get original render mode
  362.     $renderMode = $this->getRenderMode();
  364.     // set render mode to var
  365.     $this->setRenderMode(sfView::RENDER_VAR);
  367.     // grab the action stack
  368.     $actionStack = $this->getActionStack();
  370.     // grab this next forward's action stack index
  371.     $index = $actionStack->getSize();
  373.     // set viewName if needed
  374.     if ($viewName)
  375.     {
  376.       $currentViewName = sfConfig::get('mod_'.strtolower($module).'_view_class');
  377.       sfConfig::set('mod_'.strtolower($module).'_view_class', $viewName);
  378.     }
  380.     try
  381.     {
  382.       // forward to the mail action
  383.       $this->forward($module, $action);
  384.     }
  385.     catch (Exception $e)
  386.     {
  387.       // put render mode back
  388.       $this->setRenderMode($renderMode);
  390.       // remove viewName
  391.       if ($viewName)
  392.       {
  393.         sfConfig::set('mod_'.strtolower($module).'_view_class', $currentViewName);
  394.       }
  396.       throw $e;
  397.     }
  399.     // grab the action entry from this forward
  400.     $actionEntry = $actionStack->getEntry($index);
  402.     // get raw email content
  403.     $presentation =& $actionEntry->getPresentation();
  405.     // put render mode back
  406.     $this->setRenderMode($renderMode);
  408.     // remove the action entry
  409.     $nb = $actionStack->getSize() - $index;
  410.     while ($nb-- > 0)
  411.     {
  412.       $actionEntry = $actionStack->popEntry();
  414.       if ($actionEntry->getModuleName() == sfConfig::get('sf_login_module') && $actionEntry->getActionName() == sfConfig::get('sf_login_action'))
  415.       {
  416.         throw new sfException('Your action is secured, but the user is not authenticated.');
  417.       }
  418.       else if ($actionEntry->getModuleName() == sfConfig::get('sf_secure_module') && $actionEntry->getActionName() == sfConfig::get('sf_secure_action'))
  419.       {
  420.         throw new sfException('Your action is secured, but the user does not have access.');
  421.       }
  422.     }
  424.     // remove viewName
  425.     if ($viewName)
  426.     {
  427.       sfConfig::set('mod_'.strtolower($module).'_view_class', $currentViewName);
  428.     }
  430.     return $presentation;
  431.   }
  433.   /**
  434.    * Sets the presentation rendering mode.
  435.    *
  436.    * @param int $mode A rendering mode one of the following:
  437.    *                  - sfView::RENDER_CLIENT
  438.    *                  - sfView::RENDER_VAR
  439.    *                  - sfView::RENDER_NONE
  440.    *
  441.    * @return true
  442.    *
  443.    * @throws sfRenderException If an invalid render mode has been set
  444.    */
  445.   public function setRenderMode($mode)
  446.   {
  447.     if ($mode == sfView::RENDER_CLIENT || $mode == sfView::RENDER_VAR || $mode == sfView::RENDER_NONE)
  448.     {
  449.       $this->renderMode = $mode;
  451.       return;
  452.     }
  454.     // invalid rendering mode type
  455.     throw new sfRenderException(sprintf('Invalid rendering mode: %s.', $mode));
  456.   }
  458.   /**
  459.    * Indicates whether or not we were called using the CLI version of PHP.
  460.    *
  461.    * @return bool true, if using cli, otherwise false.
  462.    */
  463.   public function inCLI()
  464.   {
  465.     return 0 == strncasecmp(PHP_SAPI, 'cli', 3);
  466.   }
  468.   /**
  469.    * Calls methods defined via sfEventDispatcher.
  470.    *
  471.    * @param string $method    The method name
  472.    * @param array  $arguments The method arguments
  473.    *
  474.    * @return mixed The returned value of the called method
  475.    */
  476.   public function __call($method, $arguments)
  477.   {
  478.     $event = $this->dispatcher->notifyUntil(new sfEvent($this, 'controller.method_not_found', array('method' => $method, 'arguments' => $arguments)));
  479.     if (!$event->isProcessed())
  480.     {
  481.       throw new sfException(sprintf('Call to undefined method %s::%s.', get_class($this), $method));
  482.     }
  484.     return $event->getReturnValue();
  485.   }
  486. }
Debug toolbar