1. sfUser.class.php
  2. /**
 *
 * sfUser wraps a client session and provides accessor methods for user
 * attributes. It also makes storing and retrieving multiple page form data
 * rather easy by allowing user attributes to be stored in namespaces, which
 * help organize data.
 *
 * @package    symfony
 * @subpackage user
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfUser.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. class sfUser implements ArrayAccess
  4. {
  5.   /**
  6.    * The namespace under which attributes will be stored.
  7.    */
  8.   const ATTRIBUTE_NAMESPACE = 'symfony/user/sfUser/attributes';
  10.   const CULTURE_NAMESPACE = 'symfony/user/sfUser/culture';
  12.   protected
  13.     $options         = array(),
  14.     $attributeHolder = null,
  15.     $culture         = null,
  16.     $storage         = null,
  17.     $dispatcher      = null;
  19.   /**
  20.    * Class constructor.
  21.    *
  22.    * @see initialize()
  23.    */
  24.   public function __construct(sfEventDispatcher $dispatcher, sfStorage $storage, $options = array())
  25.   {
  26.     $this->initialize($dispatcher, $storage, $options);
  28.     if ($this->options['auto_shutdown'])
  29.     {
  30.       register_shutdown_function(array($this, 'shutdown'));
  31.     }
  32.   }
  34.   /**
  35.    * Initializes this sfUser.
  36.    *
  37.    * Available options:
  38.    *
  39.    *  * auto_shutdown:   Whether to automatically save the changes to the session (true by default)
  40.    *  * culture:         The user culture
  41.    *  * default_culture: The default user culture (en by default)
  42.    *  * use_flash:       Whether to enable flash usage (false by default)
  43.    *  * logging:         Whether to enable logging (false by default)
  44.    *
  45.    * @param sfEventDispatcher $dispatcher  An sfEventDispatcher instance.
  46.    * @param sfStorage         $storage     An sfStorage instance.
  47.    * @param array             $options     An associative array of options.
  48.    *
  49.    * @return Boolean          true, if initialization completes successfully, otherwise false.
  50.    */
  51.   public function initialize(sfEventDispatcher $dispatcher, sfStorage $storage, $options = array())
  52.   {
  53.     $this->dispatcher = $dispatcher;
  54.     $this->storage    = $storage;
  56.     $this->options = array_merge(array(
  57.       'auto_shutdown'   => true,
  58.       'culture'         => null,
  59.       'default_culture' => 'en',
  60.       'use_flash'       => false,
  61.       'logging'         => false,
  62.     ), $options);
  64.     $this->attributeHolder = new sfNamespacedParameterHolder(self::ATTRIBUTE_NAMESPACE);
  66.     // read attributes from storage
  67.     $attributes = $storage->read(self::ATTRIBUTE_NAMESPACE);
  68.     if (is_array($attributes))
  69.     {
  70.       foreach ($attributes as $namespace => $values)
  71.       {
  72.         $this->attributeHolder->add($values, $namespace);
  73.       }
  74.     }
  76.     // set the user culture to sf_culture parameter if present in the request
  77.     // otherwise
  78.     //  - use the culture defined in the user session
  79.     //  - use the default culture set in settings.yml
  80.     $currentCulture = $storage->read(self::CULTURE_NAMESPACE);
  81.     $this->setCulture(null !== $this->options['culture'] ? $this->options['culture'] : (null !== $currentCulture ? $currentCulture : $this->options['default_culture']));
  83.     // flag current flash to be removed at shutdown
  84.     if ($this->options['use_flash'] && $names = $this->attributeHolder->getNames('symfony/user/sfUser/flash'))
  85.     {
  86.       if ($this->options['logging'])
  87.       {
  88.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Flag old flash messages ("%s")', implode('", "', $names)))));
  89.       }
  91.       foreach ($names as $name)
  92.       {
  93.         $this->attributeHolder->set($name, true, 'symfony/user/sfUser/flash/remove');
  94.       }
  95.     }
  96.   }
  98.   /**
  99.    * Returns the initialization options
  100.    *
  101.    * @return array The options used to initialize sfUser
  102.    */
  103.   public function getOptions()
  104.   {
  105.     return $this->options;
  106.   }
  108.   /**
  109.    * Sets the user culture.
  110.    *
  111.    * @param string $culture
  112.    */
  113.   public function setCulture($culture)
  114.   {
  115.     if ($this->culture != $culture)
  116.     {
  117.       $this->culture = $culture;
  119.       $this->dispatcher->notify(new sfEvent($this, 'user.change_culture', array('culture' => $culture)));
  120.     }
  121.   }
  123.   /**
  124.    * Sets a flash variable that will be passed to the very next action.
  125.    *
  126.    * @param  string $name     The name of the flash variable
  127.    * @param  string $value    The value of the flash variable
  128.    * @param  bool   $persist  true if the flash have to persist for the following request (true by default)
  129.    */
  130.   public function setFlash($name, $value, $persist = true)
  131.   {
  132.     if (!$this->options['use_flash'])
  133.     {
  134.       return;
  135.     }
  137.     $this->setAttribute($name, $value, 'symfony/user/sfUser/flash');
  139.     if ($persist)
  140.     {
  141.       // clear removal flag
  142.       $this->attributeHolder->remove($name, null, 'symfony/user/sfUser/flash/remove');
  143.     }
  144.     else
  145.     {
  146.       $this->setAttribute($name, true, 'symfony/user/sfUser/flash/remove');
  147.     }
  148.   }
  150.   /**
  151.    * Gets a flash variable.
  152.    *
  153.    * @param  string $name     The name of the flash variable
  154.    * @param  string $default  The default value returned when named variable does not exist.
  155.    *
  156.    * @return mixed The value of the flash variable
  157.    */
  158.   public function getFlash($name, $default = null)
  159.   {
  160.     if (!$this->options['use_flash'])
  161.     {
  162.       return $default;
  163.     }
  165.     return $this->getAttribute($name, $default, 'symfony/user/sfUser/flash');
  166.   }
  168.   /**
  169.    * Returns true if a flash variable of the specified name exists.
  170.    *
  171.    * @param  string $name  The name of the flash variable
  172.    *
  173.    * @return bool true if the variable exists, false otherwise
  174.    */
  175.   public function hasFlash($name)
  176.   {
  177.     if (!$this->options['use_flash'])
  178.     {
  179.       return false;
  180.     }
  182.     return $this->hasAttribute($name, 'symfony/user/sfUser/flash');
  183.   }
  185.   /**
  186.    * Gets culture.
  187.    *
  188.    * @return string
  189.    */
  190.   public function getCulture()
  191.   {
  192.     return $this->culture;
  193.   }
  195.   /**
  196.    * Returns true if the user attribute exists (implements the ArrayAccess interface).
  197.    *
  198.    * @param  string $name The name of the user attribute
  199.    *
  200.    * @return Boolean true if the user attribute exists, false otherwise
  201.    */
  202.   public function offsetExists($name)
  203.   {
  204.     return $this->hasAttribute($name);
  205.   }
  207.   /**
  208.    * Returns the user attribute associated with the name (implements the ArrayAccess interface).
  209.    *
  210.    * @param  string $name  The offset of the value to get
  211.    *
  212.    * @return mixed The user attribute if exists, null otherwise
  213.    */
  214.   public function offsetGet($name)
  215.   {
  216.     return $this->getAttribute($name, false);
  217.   }
  219.   /**
  220.    * Sets the user attribute associated with the offset (implements the ArrayAccess interface).
  221.    *
  222.    * @param string $offset The parameter name
  223.    * @param string $value The parameter value
  224.    */
  225.   public function offsetSet($offset, $value)
  226.   {
  227.     $this->setAttribute($offset, $value);
  228.   }
  230.   /**
  231.    * Unsets the user attribute associated with the offset (implements the ArrayAccess interface).
  232.    *
  233.    * @param string $offset The parameter name
  234.    */
  235.   public function offsetUnset($offset)
  236.   {
  237.     $this->getAttributeHolder()->remove($offset);
  238.   }
  240.   public function getAttributeHolder()
  241.   {
  242.     return $this->attributeHolder;
  243.   }
  245.   public function getAttribute($name, $default = null, $ns = null)
  246.   {
  247.     return $this->attributeHolder->get($name, $default, $ns);
  248.   }
  250.   public function hasAttribute($name, $ns = null)
  251.   {
  252.     return $this->attributeHolder->has($name, $ns);
  253.   }
  255.   public function setAttribute($name, $value, $ns = null)
  256.   {
  257.     return $this->attributeHolder->set($name, $value, $ns);
  258.   }
  260.   /**
  261.    * Executes the shutdown procedure.
  262.    */
  263.   public function shutdown()
  264.   {
  265.     // remove flash that are tagged to be removed
  266.     if ($this->options['use_flash'] && $names = $this->attributeHolder->getNames('symfony/user/sfUser/flash/remove'))
  267.     {
  268.       if ($this->options['logging'])
  269.       {
  270.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Remove old flash messages ("%s")', implode('", "', $names)))));
  271.       }
  273.       foreach ($names as $name)
  274.       {
  275.         $this->attributeHolder->remove($name, null, 'symfony/user/sfUser/flash');
  276.         $this->attributeHolder->remove($name, null, 'symfony/user/sfUser/flash/remove');
  277.       }
  278.     }
  280.     $attributes = array();
  281.     foreach ($this->attributeHolder->getNamespaces() as $namespace)
  282.     {
  283.       $attributes[$namespace] = $this->attributeHolder->getAll($namespace);
  284.     }
  286.     // write attributes to the storage
  287.     $this->storage->write(self::ATTRIBUTE_NAMESPACE, $attributes);
  289.     // write culture to the storage
  290.     $this->storage->write(self::CULTURE_NAMESPACE, $this->culture);
  291.   }
  293.   /**
  294.    * Calls methods defined via sfEventDispatcher.
  295.    *
  296.    * @param string $method     The method name
  297.    * @param array  $arguments  The method arguments
  298.    *
  299.    * @return mixed The returned value of the called method
  300.    *
  301.    * @throws sfException If the calls fails
  302.    */
  303.   public function __call($method, $arguments)
  304.   {
  305.     $event = $this->dispatcher->notifyUntil(new sfEvent($this, 'user.method_not_found', array('method' => $method, 'arguments' => $arguments)));
  306.     if (!$event->isProcessed())
  307.     {
  308.       throw new sfException(sprintf('Call to undefined method %s::%s.', get_class($this), $method));
  309.     }
  311.     return $event->getReturnValue();
  312.   }
  313. }
Debug toolbar