Frontend
[ class tree: Frontend ] [ index: Frontend ] [ all elements ]

Source for file User.php

Documentation is available at User.php

  1. <?php
  2. /**
  3. * DotBoost Technologies Inc.
  4. * DotKernel Application Framework
  5. *
  6. @category   DotKernel
  7. @package    Frontend
  8. @copyright  Copyright (c) 2009 DotBoost  Technologies (http://www.dotboost.com)
  9. @license    http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
  10. @version    $Id: User.php 160 2010-06-28 04:24:28Z teo $
  11. */
  12.  
  13. /**
  14. * User Model
  15. * Here are all the actions related to the user
  16. @category   DotKernel
  17. @package    Frontend
  18. @author     DotKernel Team <team@dotkernel.com>
  19. */
  20.  
  21. class User
  22. {
  23.     /**
  24.      * Constructor
  25.      * @access public
  26.      * @return User 
  27.      */
  28.     public function __construct()
  29.     {        
  30.         $this->db Zend_Registry::get('database');
  31.         $this->option Zend_Registry::get('option');        
  32.     }
  33.     /**
  34.      * Check to see if user can login
  35.      * @access public
  36.      * @param array $data 
  37.      * @return array 
  38.      */
  39.     public function checkLogin($data)
  40.     {
  41.         $select $this->db->select()
  42.                            ->from('user')
  43.                            ->where('isActive = ?','1')
  44.                            ->where('username = ?'$data['username'])
  45.                            ->where('password = ?'$data['password']);
  46.         $result $this->db->fetchAll($select);
  47.         == count($result)) $return $result[0$return array();
  48.         return $return;
  49.     }    
  50.     /**
  51.      * Get user by field
  52.      * @access public
  53.      * @param string $field 
  54.      * @param string $value 
  55.      * @return array 
  56.      */
  57.     public function getUserBy($field ''$value '')
  58.     {        
  59.         $select $this->db->select()
  60.                        ->from('user')
  61.                        ->where($field.' = ?'$value)
  62.                        ->limit(1);                       
  63.         $result $this->db->fetchRow($select);
  64.         return $result;
  65.     }    
  66.     /**
  67.      * Get user info
  68.      * @access public
  69.      * @param int $id 
  70.      * @return array 
  71.      */
  72.     public function getUserInfo($id)
  73.     {
  74.         $select $this->db->select()
  75.                        ->from('user')
  76.                        ->where('id = ?'$id);
  77.         return $this->db->fetchRow($select);
  78.     }        
  79.     /**
  80.      * Add new user
  81.      * @access public
  82.      * @param array $data 
  83.      * @return void 
  84.      */
  85.     public function addUser($data)
  86.     {        
  87.         // if you want to add an inactive user, un-comment the below line, default: isActive = 1
  88.         // $data['isActive'] = 0;
  89.         $this->db->insert('user',$data);        
  90.     }
  91.     /**
  92.      * Update user
  93.      * @access public
  94.      * @param array $data 
  95.      * @return void 
  96.      */
  97.     public function updateUser($data)
  98.     {
  99.         $id $data['id'];
  100.         unset ($data['id']);
  101.         $this->db->update('user'$data'id = '.$id);
  102.     }
  103.     /**
  104.      * Register logins data
  105.      * @access public
  106.      * @param array $data 
  107.      * @return void 
  108.      */
  109.     public function registerLogin($data)
  110.     {
  111.         $this->db->insert('userLogin'$data);
  112.     }    
  113.     /**
  114.      * Validate the data that comes from login form
  115.      * @access public
  116.      * @param string $username 
  117.      * @param string $password 
  118.      * @param string $send [optional] which is a control key
  119.      * @return bool 
  120.      */
  121.     public function validateLogin($username$password$send 'off')
  122.     {
  123.         $login array();
  124.         $error array()
  125.         if ($send =='on')
  126.         {
  127.             $validatorUsername new Zend_Validate();
  128.             $validatorUsername->addValidator(new Zend_Validate_Alnum())
  129.                               ->addValidator(new Zend_Validate_StringLength(
  130.                                                 $this->option->validate->username->lengthMin
  131.                                                 $this->option->validate->username->lengthMax
  132.                                             ));
  133.             if ($validatorUsername->isValid($username))
  134.             {
  135.                 $login['username'$username;
  136.             }
  137.             else
  138.             {
  139.                 $error['username'$this->option->errorMessage->invalidUsername;
  140.                 $login['username''';
  141.             }
  142.             $validatorPassword new Zend_Validate();
  143.             $validatorPassword->addValidator(new Zend_Validate_StringLength(
  144.                                                 $this->option->validate->password->lengthMin
  145.                                                 $this->option->validate->password->lengthMax
  146.                                             ));
  147.             if ($validatorPassword->isValid($password))
  148.             {
  149.                 $login['password'$password;
  150.             }
  151.             else
  152.             {
  153.                 $error['password'$this->option->errorMessage->invalidPassword;
  154.                 $login['password''';
  155.             }            
  156.         }
  157.         return array('login'=>$login'error'=>$error);
  158.     }
  159.     /**
  160.      * Validate user input, add or update form
  161.      * $values is an array on multiple levels. On first level, the key suggest what validation will be done.
  162.      * - details     - only filter the input
  163.      * - username    - validate with Zend_Validate_Alnum, Zend_Validate_StringLength and filter the input
  164.      * - email        - validate with Zend_Validate_EmailAddress and filter the input
  165.      * - password    - validate with Zend_Validate_StringLength and filter the input
  166.      * @access public
  167.      * @param array $values 
  168.      * @return array 
  169.      */
  170.     public function validateUser($values)
  171.     {$data array();
  172.         $error array();
  173.         //validate the input data - username, password and email will be also filtered
  174.         $validatorChain new Zend_Validate();
  175.         //validate details parameters    
  176.         if(array_key_exists('details'$values))
  177.         {
  178.             $validDetails Dot_Kernel::validateFilter($validatorChain$values['details']);
  179.             $data array_merge($data$validDetails['data']);
  180.             $error array_merge($error$validDetails['error']);
  181.         }        
  182.         //validate username
  183.         if(array_key_exists('username'$values))
  184.         {
  185.             $validatorChain new Zend_Validate();
  186.             $validatorChain->addValidator(new Zend_Validate_Alnum())
  187.                            ->addValidator(new Zend_Validate_StringLength(
  188.                                                     $this->option->validate->details->lengthMin
  189.                                                     $this->option->validate->details->lengthMax
  190.                                                 ));
  191.             $validUsername Dot_Kernel::validateFilter($validatorChain$values['username']);
  192.             $data array_merge($data$validUsername['data']);
  193.             $error array_merge($error$validUsername['error']);
  194.         }
  195.         //validate email
  196.         if(array_key_exists('email'$values))
  197.         {
  198.             $validatorEmail new Zend_Validate_EmailAddress();        
  199.             $validEmail Dot_Kernel::validateFilter($validatorEmail$values['email']);
  200.             $data array_merge($data$validEmail['data']);
  201.             $error array_merge($error$validEmail['error']);
  202.         }    
  203.         //validate password                
  204.         if(array_key_exists('password'$values))
  205.         {            
  206.             if($values['password']['password'== $values['password']['password2'])
  207.             {
  208.                 unset($values['password']['password2']);
  209.                 $validatorChain new Zend_Validate();
  210.                 $validatorChain->addValidator(new Zend_Validate_StringLength(
  211.                                                 $this->option->validate->password->lengthMin
  212.                                                 $this->option->validate->password->lengthMax
  213.                                             ));            
  214.                 $validPass Dot_Kernel::validateFilter($validatorChain$values['password']);
  215.                 $data array_merge($data$validPass['data']);
  216.                 $error array_merge($error$validPass['error']);    
  217.             }
  218.             else
  219.             {
  220.                 $error['password'$this->option->errorMessage->passwordTwice;
  221.             }
  222.         }
  223.         return array('data' => $data'error' => $error);
  224.     }
  225.     /**
  226.      * Validate email user input
  227.      * @access public
  228.      * @param string $email 
  229.      * @return array 
  230.      */
  231.     public function validateEmail($email)
  232.     {
  233.         $data array();
  234.         $error array();
  235.         $validatorEmail new Zend_Validate_EmailAddress();        
  236.         $validEmail Dot_Kernel::validateFilter($validatorEmailarray('email'=>$email));
  237.         return $validEmail;
  238.     }
  239.     /**
  240.      * Send forgot password to user
  241.      * @access public
  242.      * @param string $email 
  243.      * @return void 
  244.      */
  245.     public function forgotPassword($email)
  246.     {
  247.         $session Zend_Registry::get('session');
  248.         $value $this->getUserBy('email'$email);
  249.         if(!empty($value))
  250.         {
  251.             $dotEmail new Dot_Email();
  252.             $dotEmail->addTo($email);
  253.             $dotEmail->setSubject($this->option->forgotPassword->subject);
  254.             $msg str_replace(array('%FIRSTNAME%''%PASSWORD%')
  255.                                array($value['firstName']$value['password'])
  256.                               $this->option->forgotPassword->message);
  257.             $dotEmail->setBodyText($msg);            
  258.             $succeed $dotEmail->send();
  259.             if($succeed)
  260.             {
  261.                 $session->message['txt'$this->option->errorMessage->emailSent.$email;
  262.                 $session->message['type''info';
  263.             }
  264.             else
  265.             {
  266.                 $session->message['txt'$this->option->errorMessage->emailNotSent.$email;
  267.                 $session->message['type''error';
  268.             }        
  269.         }
  270.         else
  271.         {
  272.             $session->message['txt'$email.$this->option->errorMessage->emailNotFound;
  273.             $session->message['type''error';
  274.         }        
  275.     }    
  276. }

Documentation generated on Wed, 21 Jul 2010 07:34:45 +0000 by phpDocumentor 1.4.3