1. sfComponent.class.php
  2. /**
 * sfComponent.
 *
 * @package    symfony
 * @subpackage action
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfComponent.class.php 23922 2009-11-14 14:58:38Z fabien $
 */
  3. abstract class sfComponent
  4. {
  5.   protected
  6.     $moduleName             = '',
  7.     $actionName             = '',
  8.     $context                = null,
  9.     $dispatcher             = null,
  10.     $request                = null,
  11.     $response               = null,
  12.     $varHolder              = null,
  13.     $requestParameterHolder = null;
  15.   /**
  16.    * Class constructor.
  17.    *
  18.    * @see initialize()
  19.    */
  20.   public function __construct($context, $moduleName, $actionName)
  21.   {
  22.     $this->initialize($context, $moduleName, $actionName);
  23.   }
  25.   /**
  26.    * Initializes this component.
  27.    *
  28.    * @param sfContext $context    The current application context.
  29.    * @param string    $moduleName The module name.
  30.    * @param string    $actionName The action name.
  31.    *
  32.    * @return boolean true, if initialization completes successfully, otherwise false
  33.    */
  34.   public function initialize($context, $moduleName, $actionName)
  35.   {
  36.     $this->moduleName             = $moduleName;
  37.     $this->actionName             = $actionName;
  38.     $this->context                = $context;
  39.     $this->dispatcher             = $context->getEventDispatcher();
  40.     $this->varHolder              = new sfParameterHolder();
  41.     $this->request                = $context->getRequest();
  42.     $this->response               = $context->getResponse();
  43.     $this->requestParameterHolder = $this->request->getParameterHolder();
  44.   }
  46.   /**
  47.    * Execute any application/business logic for this component.
  48.    *
  49.    * In a typical database-driven application, execute() handles application
  50.    * logic itself and then proceeds to create a model instance. Once the model
  51.    * instance is initialized it handles all business logic for the action.
  52.    *
  53.    * A model should represent an entity in your application. This could be a
  54.    * user account, a shopping cart, or even a something as simple as a
  55.    * single product.
  56.    *
  57.    * @param sfRequest $request The current sfRequest object
  58.    *
  59.    * @return mixed     A string containing the view name associated with this action
  60.    */
  61.   abstract function execute($request);
  63.   /**
  64.    * Gets the module name associated with this component.
  65.    *
  66.    * @return string A module name
  67.    */
  68.   public function getModuleName()
  69.   {
  70.     return $this->moduleName;
  71.   }
  73.   /**
  74.    * Gets the action name associated with this component.
  75.    *
  76.    * @return string An action name
  77.    */
  78.   public function getActionName()
  79.   {
  80.     return $this->actionName;
  81.   }
  83.   /**
  84.    * Retrieves the current application context.
  85.    *
  86.    * @return sfContext The current sfContext instance
  87.    */
  88.   public final function getContext()
  89.   {
  90.     return $this->context;
  91.   }
  93.   /**
  94.    * Retrieves the current logger instance.
  95.    *
  96.    * @return sfLogger The current sfLogger instance
  97.    */
  98.   public final function getLogger()
  99.   {
  100.     return $this->context->getLogger();
  101.   }
  103.   /**
  104.    * Logs a message using the sfLogger object.
  105.    *
  106.    * @param mixed  $message  String or object containing the message to log
  107.    * @param string $priority The priority of the message
  108.    *                         (available priorities: emerg, alert, crit, err,
  109.    *                         warning, notice, info, debug)
  110.    *
  111.    * @see sfLogger
  112.    */
  113.   public function logMessage($message, $priority = 'info')
  114.   {
  115.     if (sfConfig::get('sf_logging_enabled'))
  116.     {
  117.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array($message, 'priority' => constant('sfLogger::'.strtoupper($priority)))));
  118.     }
  119.   }
  121.   /**
  122.    * Returns the value of a request parameter.
  123.    *
  124.    * This is a proxy method equivalent to:
  125.    *
  126.    * <code>$this->getRequest()->getParameterHolder()->get($name)</code>
  127.    *
  128.    * @param string $name    The parameter name
  129.    * @param mixed  $default The default value if parameter does not exist
  130.    *
  131.    * @return string The request parameter value
  132.    */
  133.   public function getRequestParameter($name, $default = null)
  134.   {
  135.     return $this->requestParameterHolder->get($name, $default);
  136.   }
  138.   /**
  139.    * Returns true if a request parameter exists.
  140.    *
  141.    * This is a proxy method equivalent to:
  142.    *
  143.    * <code>$this->getRequest()->getParameterHolder()->has($name)</code>
  144.    *
  145.    * @param string $name The parameter name
  146.    * @return boolean true if the request parameter exists, false otherwise
  147.    */
  148.   public function hasRequestParameter($name)
  149.   {
  150.     return $this->requestParameterHolder->has($name);
  151.   }
  153.   /**
  154.    * Retrieves the current sfRequest object.
  155.    *
  156.    * This is a proxy method equivalent to:
  157.    *
  158.    * <code>$this->getContext()->getRequest()</code>
  159.    *
  160.    * @return sfRequest The current sfRequest implementation instance
  161.    */
  162.   public function getRequest()
  163.   {
  164.     return $this->request;
  165.   }
  167.   /**
  168.    * Retrieves the current sfResponse object.
  169.    *
  170.    * This is a proxy method equivalent to:
  171.    *
  172.    * <code>$this->getContext()->getResponse()</code>
  173.    *
  174.    * @return sfResponse The current sfResponse implementation instance
  175.    */
  176.   public function getResponse()
  177.   {
  178.     return $this->response;
  179.   }
  181.   /**
  182.    * Retrieves the current sfController object.
  183.    *
  184.    * This is a proxy method equivalent to:
  185.    *
  186.    * <code>$this->getContext()->getController()</code>
  187.    *
  188.    * @return sfController The current sfController implementation instance
  189.    */
  190.   public function getController()
  191.   {
  192.     return $this->context->getController();
  193.   }
  195.   /**
  196.    * Generates a URL for the given route and arguments.
  197.    *
  198.    * This is a proxy method equivalent to:
  199.    *
  200.    * <code>$this->getContext()->getRouting()->generate(...)</code>
  201.    *
  202.    * @param string  The route name
  203.    * @param array   An array of parameters for the route
  204.    * @param Boolean Whether to generate an absolute URL or not
  205.    *
  206.    * @return string  The URL
  207.    */
  208.   public function generateUrl($route, $params = array(), $absolute = false)
  209.   {
  210.     return $this->context->getRouting()->generate($route, $params, $absolute);
  211.   }
  213.   /**
  214.    * Retrieves the current sfUser object.
  215.    *
  216.    * This is a proxy method equivalent to:
  217.    *
  218.    * <code>$this->getContext()->getUser()</code>
  219.    *
  220.    * @return sfUser The current sfUser implementation instance
  221.    */
  222.   public function getUser()
  223.   {
  224.     return $this->context->getUser();
  225.   }
  227.   /**
  228.    * Gets the current mailer instance.
  229.    *
  230.    * @return sfMailer A sfMailer instance
  231.    */
  232.   public function getMailer()
  233.   {
  234.     return $this->getContext()->getMailer();
  235.   }
  237.   /**
  238.    * Sets a variable for the template.
  239.    *
  240.    * If you add a safe value, the variable won't be output escaped
  241.    * by symfony, so this is your responsability to ensure that the
  242.    * value is escaped properly.
  243.    *
  244.    * @param string  $name  The variable name
  245.    * @param mixed   $value The variable value
  246.    * @param Boolean $safe  true if the value is safe for output (false by default)
  247.    */
  248.   public function setVar($name, $value, $safe = false)
  249.   {
  250.     $this->varHolder->set($name, $safe ? new sfOutputEscaperSafe($value) : $value);
  251.   }
  253.   /**
  254.    * Gets a variable set for the template.
  255.    *
  256.    * @param string $name The variable name
  257.    *
  258.    * @return mixed  The variable value
  259.    */
  260.   public function getVar($name)
  261.   {
  262.     return $this->varHolder->get($name);
  263.   }
  265.   /**
  266.    * Gets the sfParameterHolder object that stores the template variables.
  267.    *
  268.    * @return sfParameterHolder The variable holder.
  269.    */
  270.   public function getVarHolder()
  271.   {
  272.     return $this->varHolder;
  273.   }
  275.   /**
  276.    * Sets a variable for the template.
  277.    *
  278.    * This is a shortcut for:
  279.    *
  280.    * <code>$this->setVar('name', 'value')</code>
  281.    *
  282.    * @param string $key   The variable name
  283.    * @param string $value The variable value
  284.    *
  285.    * @return boolean always true
  286.    *
  287.    * @see setVar()
  288.    */
  289.   public function __set($key, $value)
  290.   {
  291.     return $this->varHolder->setByRef($key, $value);
  292.   }
  294.   /**
  295.    * Gets a variable for the template.
  296.    *
  297.    * This is a shortcut for:
  298.    *
  299.    * <code>$this->getVar('name')</code>
  300.    *
  301.    * @param string $key The variable name
  302.    *
  303.    * @return mixed The variable value
  304.    *
  305.    * @see getVar()
  306.    */
  307.   public function & __get($key)
  308.   {
  309.     return $this->varHolder->get($key);
  310.   }
  312.   /**
  313.    * Returns true if a variable for the template is set.
  314.    *
  315.    * This is a shortcut for:
  316.    *
  317.    * <code>$this->getVarHolder()->has('name')</code>
  318.    *
  319.    * @param string $name The variable name
  320.    *
  321.    * @return boolean true if the variable is set
  322.    */
  323.   public function __isset($name)
  324.   {
  325.     return $this->varHolder->has($name);
  326.   }
  328.   /**
  329.    * Removes a variable for the template.
  330.    *
  331.    * This is just really a shortcut for:
  332.    *
  333.    * <code>$this->getVarHolder()->remove('name')</code>
  334.    *
  335.    * @param string $name The variable Name
  336.    */
  337.   public function __unset($name)
  338.   {
  339.     $this->varHolder->remove($name);
  340.   }
  342.   /**
  343.    * Calls methods defined via sfEventDispatcher.
  344.    *
  345.    * @param string $method The method name
  346.    * @param array  $arguments The method arguments
  347.    *
  348.    * @return mixed The returned value of the called method
  349.    *
  350.    * @throws sfException If called method is undefined
  351.    */
  352.   public function __call($method, $arguments)
  353.   {
  354.     $event = $this->dispatcher->notifyUntil(new sfEvent($this, 'component.method_not_found', array('method' => $method, 'arguments' => $arguments)));
  355.     if (!$event->isProcessed())
  356.     {
  357.       throw new sfException(sprintf('Call to undefined method %s::%s.', get_class($this), $method));
  358.     }
  360.     return $event->getReturnValue();
  361.   }
  362. }
Debug toolbar