Source for file User.class.php

Documentation is available at User.class.php

  1. <?php
  2. /**
  3.  * Gumbo Library Framework
  4.  *
  5.  * LICENSE
  6.  * This library is being released under the terms of the New BSD License.  A
  7.  * copy of the license is packaged with the software (LICENSE.txt).  If no
  8.  * copy is found, a copy of the license template can be found at:
  9.  * http://www.opensource.org/licenses/bsd-license.php
  10.  * 
  11.  * @category Gumbo
  12.  * @package Session
  13.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  14.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  15.  * @author Michael Luster <mluster79@yahoo.com>
  16.  * @link http://sourceforge.net/projects/phpgumbo
  17.  * @version 0.0.1
  18.  */
  19.  
  20. /**
  21.  * User Session Class
  22.  *
  23.  * @category Gumbo
  24.  * @package Session
  25.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  26.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  27.  * @author Michael Luster <mluster79@yahoo.com>
  28.  * @link http://sourceforge.net/projects/phpgumbo
  29.  * @desc User Session Class
  30.  * @version 0.0.1
  31.  */
  32.  
  33. gumbo_load ("Interface_Session_User");
  34. gumbo_load ("Session_Encrypt");
  35. gumbo_load ("Date");
  36.  
  37. class Gumbo_Session_User extends Gumbo_Session_Encrypt implements Gumbo_Interface_Session_User {
  38.     
  39.     /** @var string $_user_key SESSION key name for User data */
  40.     private $_user_key = "user";
  41.     /** @var int|string$_user_id User ID */
  42.     private $_user_id;
  43.     /** @var boolean $_user_loaded if user was successfully loaded */
  44.     private $_user_loaded;
  45.     
  46.     
  47.     
  48.     /**
  49.      * Constructor
  50.      * @param string $user_key SESSION [key] name for User data
  51.      */
  52.     public function __construct ($user_key=null) {
  53.         if (!is_null ($user_key)) { $this->setUserKey ($user_key); }
  54.     }
  55.     
  56.     /** ACTION METHODS **/
  57.     /**
  58.      * Loads the User SESSION data
  59.      * The User Session Encrypted String is saved in the following format:
  60.      * session_id||user_id||agent||ip_address||date
  61.      * @postcondition setUser ()
  62.      * @postcondition _setUserLoaded ([true|false])
  63.      * @throws Gumbo_Exception
  64.      * @uses Gumbo_Date
  65.      */
  66.     public function loadUser () {
  67.         try {
  68.             // verify precondition
  69.             $key = $this->getUserKey ();
  70.             if (isset ($this->$key) && !$this->getUser ()) {
  71.                 $data = explode ("||", $this->get ($key));
  72.                 if (count ($data) != 5) {
  73.                     throw new Gumbo_Exception ("Invalid User Session Data: {$this->get ($key)}");
  74.                 }
  75.                 
  76.                 $id = null;
  77.                 $user = null;
  78.                 $agent = null;
  79.                 $ip = null;
  80.                 $date = null;
  81.                 
  82.                 foreach ($data as $key=>$val) {
  83.                     switch ($key) {
  84.                         case 0 : $id = $val; break; // Session ID
  85.                         case 1 : $user = $val; break; // User ID
  86.                         case 2 : $agent = $val; break; // $_SERVER ['HTTP_USER_AGENT']
  87.                         case 3 : $ip = long2ip ($val); break; // IP Address $_SERVER ['REMOTE_ADDR']
  88.                         case 4 : $date = new Gumbo_Date ($val); break; // Logged In or Saved Session
  89.                     }
  90.                 }
  91.                 
  92.                 // check that Session ID is equal
  93.                 if ($id !== $this->getId ()) {
  94.                     throw new Gumbo_Exception ("User Session ID Invalid: {$this->getId ()} != {$id}");
  95.                 }
  96.                 
  97.                 // check that User Agents match
  98.                 if ($agent !== $_SERVER ['HTTP_USER_AGENT']) {
  99.                     throw new Gumbo_Exception ("User Agent Invalid: {$_SERVER ['HTTP_USER_AGENT']} != {$agent}");
  100.                 }
  101.                 
  102.                 // check that the Session hasn't expired
  103.                 if (abs ($date->diffSeconds (new Gumbo_Date ())) >= $this->getLifetime ()) {
  104.                     throw new Gumbo_Exception ("Session has Expired: {$date->get ()}");
  105.                 }
  106.                 
  107.                 // check the IP Address, or IP Range is accurate
  108.                 if ($ip !== $_SERVER ['REMOTE_ADDR']) {
  109.                     // check the IP range
  110.                     foreach (explode (".", $ip) as $key=>$val) {
  111.                         if ($key == 2) { break; }
  112.                         $new_ip = $val . ".";
  113.                     }
  114.                     if (substr ($_SERVER ['REMOTE_ADDR'], 0, strlen ($new_ip)) !== $new_ip) {
  115.                         throw new Gumbo_Exception ("Session IP Address Invalid: {$_SERVER ['REMOTE_ADDR']} != {$ip}");
  116.                     }
  117.                 }
  118.                 
  119.                 $this->setUser ($user);
  120.             }
  121.             
  122.             $this->_saveUser ();
  123.                 
  124.         } catch (Gumbo_Exception $e) {
  125.             $e->setFunction (__METHOD__);
  126.             gumbo_trigger ($e);
  127.             $this->killUser ();
  128.         }
  129.     }
  130.     
  131.     /**
  132.      * Saves the User Session
  133.      * The User Session Encrypted String is saved in the following format:
  134.      * session_id||user_id||agent||ip_address||date
  135.      * @precondition getUser()
  136.      * @throws Gumbo_Exception
  137.      * @uses Gumbo_Date
  138.      */
  139.     private function _saveUser () {
  140.         try {
  141.             // verify precondition
  142.             if (!$this->getUser ()) {
  143.                 throw new Gumbo_Exception ("Session User ID Undefined");
  144.             }
  145.             
  146.             $date = new Gumbo_Date ();
  147.             $this->$key = $this->getId () . "||" . $this->getUser () . "||" . $_SERVER ['HTTP_USER_AGENT'] . "||" . $_SERVER ['REMOTE_ADDR'] . "||" . $date->get ();
  148.         } catch (Gumbo_Exception $e) {
  149.             $e->setFunction (__METHOD__);
  150.             gumbo_trigger ($e);
  151.         }
  152.     }
  153.     
  154.     
  155.     
  156.     /** MUTATOR METHODS **/
  157.     /**
  158.      * Sets the User Key
  159.      * @param string $key 
  160.      * @throws Gumbo_Exception
  161.      */
  162.     public function setUserKey ($key) {
  163.         try {
  164.             // verify precondition
  165.             if (!is_string ($key)) {
  166.                 throw new Gumbo_Exception ("Invalid Argument 'key:str' => {$key}:" . gettype ($key));
  167.             }
  168.             
  169.             $this->_user_key = $key;
  170.         } catch (Gumbo_Exception $e) {
  171.             $e->setFunction (__METHOD__);
  172.             gumbo_trigger ($e);
  173.         }
  174.     }
  175.     
  176.     /**
  177.      * Sets the User ID
  178.      * @param int|string$userID 
  179.      * @throws Gumbo_Exception
  180.      */
  181.     public function setUser ($userID) {
  182.         try {
  183.             // verify precondition
  184.             if (!is_string ($userID) && !is_numeric ($userID)) {
  185.                 throw new Gumbo_Exception_InvalidArgument ("userID", $userID, "string|int");
  186.             }
  187.             if (is_numeric ($userID)) { $userID = (int) $userID; }
  188.             
  189.             $this->_user_id = $userID;
  190.         } catch (Gumbo_Exception $e) {
  191.             $e->setFunction (__METHOD__);
  192.             gumbo_trigger ($e);
  193.         }
  194.     }
  195.     
  196.     /**
  197.      * Sets if the User was properly loaded
  198.      * @param bool $val 
  199.      * @throws Gumbo_Exception
  200.      */
  201.     private function _setUserLoaded ($val) {
  202.         try {
  203.             // verify precondition
  204.             if (!is_bool ($val)) {
  205.                 throw new Gumbo_Exception ("Invalid Argument 'val:bool' => {$val}:" . gettype ($val));
  206.             }
  207.             
  208.             $this->_user_loaded = $val;
  209.         } catch (Gumbo_Exception $e) {
  210.             $e->setFunction (__METHOD__);
  211.             gumbo_trigger ($e);
  212.         }
  213.     }
  214.     
  215.     
  216.     
  217.     /** ACCESSOR METHODS **/
  218.     /**
  219.      * Returns the User Key
  220.      * @return string 
  221.      */
  222.     public function getUserKey () {
  223.         return $this->_user_key;
  224.     }
  225.     
  226.     /**
  227.      * Returns the User ID
  228.      * @return string|int
  229.      */
  230.     public function getUser () {
  231.         return $this->_user_id;
  232.     }
  233.     
  234.     /**
  235.      * Returns if the User has been loaded
  236.      * @return bool 
  237.      */
  238.     public function isUserLoaded () {
  239.         return $this->_user_loaded;
  240.     }
  241.     
  242. }
  243.  
  244. ?>