Foros del Web » Programando para Internet » PHP » Frameworks y PHP orientado a objetos »

PHP OO Clase 'users'. ¿Es correcta?

 Estas en el tema de Clase 'users'. ¿Es correcta? en el foro de Frameworks y PHP orientado a objetos en Foros del Web. Buenas, He decidido, poco a poco, ir haciendo cositas en POO... asiq, como resultado de eso, y del uso de Slim, Paris, e Idiorm, me ...
  #1 (permalink)  
Antiguo 26/09/2011, 08:53
Avatar de Eleazan  
Fecha de Ingreso: abril-2008
Ubicación: Ibiza
Mensajes: 1.879
Antigüedad: 16 años
Puntos: 326
Clase 'users'. ¿Es correcta?
Buenas,

He decidido, poco a poco, ir haciendo cositas en POO... asiq, como resultado de eso, y del uso de Slim, Paris, e Idiorm, me he creado una clase "Users" para manejar los usuarios... o almenos, lo básico (crear, loguear, autentificar).

Y la verdad, yo creo q está bien hecha (en cuanto a POO, sé que queda aún validación!)

Asiq, si no es mucha molestia, la pongo aqui, y si veis algo mal hecho en POO, decídmelo!

Código PHP:
<?php

class Users extends Model {
    
    private $_islog = false;
    
    public function getUser($dni) {
        return $this->factory('Users')->where('dni', $dni)->find_one();
    }
    
    public function logout() {
        //Borramos las cookies
        setcookie('login','');
    setcookie('rol','');
        setcookie('user', '');
        //El mismo borrará los datos de la sesion al recargar la pag!
    
    //session_unset();
    }
    
    public function islog() {
        return $this->_islog;
    }
    
    //Método para loguear en el sistema
    public function login($dni, $pass) {
        $user = $this->getUser($dni);
        if(!$user) return false; //No existe el usuario!
        if(md5($pass) == $user->pass) {
            $cook = $user->dni;
            $cook.= $user->pass;
            $rol = $user->rol;
            $cookie=md5($cook.$_SERVER["REMOTE_ADDR"].$rol.'pAlABRAmagica');
            setcookie('login',$cookie);
            setcookie('user',$user->dni);
            setcookie('rol',$rol);
            
            return $this->getUser($dni);
        }
        else return false;
                
    }
    
    //Método para, con dos valores de las cookies, comprobar si es correcto!
    public function auth($dni, $login) {
        
        $userN = Model::factory('Users')->where_equal('dni', $dni)->find_one(); //->where_equal('pass', $pass)
        if( $userN ) { //Exists
            
            if(isset($_COOKIE['rol'])) $rol = $_COOKIE['rol'];
            else $rol = '';
            $cookie = md5($dni.$userN->pass.$_SERVER["REMOTE_ADDR"].$rol.'pAlABRAmagica');
            if($cookie == $login) {
                $this->cloneU($userN);
                $this->_islog = true;
                return true;
                
                }
            else {
                $this->logout();
                return false;
            }
        }
        else {
            $this->logout();
            return false;
        }
    }
    
    private function cloneU($u) {
        $this->dni = $u->dni;
        $this->id = $u->id;
        $this->pass = $u->pass;
        $this->control = $u->control;
        $this->rol = $u->rol;
        $this->email = $u->email;
        $this->apellidos = $u->apellidos;
        $this->nombre = $u->nombre;
        
    }
   
    public function register($nombre, $apellidos, $pass, $mail, $dni ) {
        
        //Se carga otra instancia, pq sino sobreescribiria la que está activa y logueada... y eso NO interesa :)
        $u = Model::factory('Users')->create();
        
        $u->nombre = $nombre;
        $u->apellidos = $apellidos;
        $u->pass = md5($pass);
        $u->email = $mail;
        $u->dni = $dni;
        $u->rol = 'user';
        
        
        return $u->save();
    }
    
}
Un saludo, y gracias :)
__________________
>> Eleazan's Source
>> @Eleazan
  #2 (permalink)  
Antiguo 26/09/2011, 13:37
Avatar de Webstudio
Colaborador
  
Fecha de Ingreso: noviembre-2001
Ubicación: 127.0.0.1
Mensajes: 3.499
Antigüedad: 22 años, 5 meses
Puntos: 69
Respuesta: Clase 'users'. ¿Es correcta?
Hola. como estás?
Si bien como concepto tu clase User está bien, me parece que una clase de Usuario que se encarga de la autenticación es como que está mezclando dos cosas en un solo objeto.
Dejame proponerte una versión alternativa, y vos me decís, dale?
Por un lado como dejaría yo la jerarquía de clases:
Código PHP: 
Ver original
  1. <?php
  2.  
  3. /**
  4.  * Tu clase "Usuario" no es más que un simple modelo que representa los valores
  5.  * de un usuario dentro de tu sistema. Para el resto de las cosas, podés utilizar
  6.  * un Mapper que te permita "persistir" Usuarios en donde vos quieras.
  7.  */
  8. class User
  9. {
  10.     protected $_isLoged   = false;
  11.  
  12.     protected $dni       = 0;
  13.     protected $id        = 0;
  14.     protected $pass      = '';
  15.     protected $control   = '';
  16.     protected $rol       = 'user';
  17.     protected $email     = '';
  18.     protected $apellidos = '';
  19.     protected $nombre    = '';
  20.  
  21.     public function loadByArray(array $u)
  22.     {
  23.         $u = (object) $u;
  24.  
  25.         $this->dni = $u->dni;
  26.         $this->id = $u->id;
  27.         $this->pass = $u->pass;
  28.         $this->control = $u->control;
  29.         $this->rol = $u->rol;
  30.         $this->email = $u->email;
  31.         $this->apellidos = $u->apellidos;
  32.         $this->nombre = $u->nombre;
  33.  
  34.         return $this;
  35.     }
  36. }
  37.  
  38. /**
  39.  * El Mapper es el objeto encargado de guardar objectos User
  40.  * donde mejor te venga en gana. Este en particular, lo guarda
  41.  * en la base de datos utilizando un Model en particular,
  42.  * pero podrías guardar usando un web-service o MemCache.
  43.  */
  44. class UserMapper extends Model
  45. {
  46.  
  47.     static public function getByDni($dni)
  48.     {
  49.         /* Asumo que este find_one() devuelve un array */
  50.         $u = $this->factory('Users')->where('dni', $dni)->find_one();
  51.         $user = new User();
  52.         return $user->loadByArray($u);
  53.     }
  54.  
  55.     /**
  56.      * Este método no es necesario, directamente podés utilizar la
  57.      * instrucción "clone" de PHP, de esta manera:
  58.      * $newUser = clone $oldUser;
  59.      */
  60.     public function cloneU($u) {
  61.         $this->dni = $u->dni;
  62.         $this->id = $u->id;
  63.         $this->pass = $u->pass;
  64.         $this->control = $u->control;
  65.         $this->rol = $u->rol;
  66.         $this->email = $u->email;
  67.         $this->apellidos = $u->apellidos;
  68.         $this->nombre = $u->nombre;
  69.  
  70.     }
  71.  
  72.     /**
  73.      * Este método, en vez de recibir los valores sueltos,
  74.      * debería recibir un objecto User ya cargado con sus
  75.      * valores, listo para guardar
  76.      */
  77.     static public function save(User $user)
  78.     {
  79.         /* Si necesitás modificar algo antes de grabar, lo hacés acá */
  80.         $user->cambiosNecesarios();
  81.  
  82.         /* Usas tu Model para guardarlo */
  83.         Model::factory('Users')->save($user);
  84.         return $user;
  85.     }
  86.  
  87. }
  88.  
  89. /**
  90.  * Finalmente, esta clase es la que se encarga de hacer el trabajo
  91.  * sucio a la hora de validar usuarios dentro de tu sistema. De
  92.  * esta manera, mantenés un objeto User lo más limpio posible, y
  93.  * delegás las funcionalidades específicas, a Clases específicas.
  94.  */
  95. class Authentication
  96. {
  97.  
  98.     static public function logout() {
  99.         //Borramos las cookies
  100.         setcookie('login','');
  101.         setcookie('rol','');
  102.         setcookie('user', '');
  103.         //El mismo borrará los datos de la sesion al recargar la pag!
  104.         //session_unset();
  105.     }
  106.  
  107.     public function islog(User $user) {
  108.         return $user->_isLoged;
  109.     }
  110.  
  111.     //Método para loguear en el sistema
  112.     public function auth($dni, $pass) {
  113.         $user = UserMapper::getByDni($dni);
  114.  
  115.         if(!$user) return false; //No existe el usuario!
  116.  
  117.         if(md5($pass) == $user->pass) {
  118.             $cookie = Authentication::_getCookieName($user);
  119.             setcookie('login',$cookie);
  120.             setcookie('user',$user->dni);
  121.             setcookie('rol',$user->rol);
  122.  
  123.             return $user;
  124.         }
  125.  
  126.         return false;
  127.     }
  128.  
  129.     //Método para, con dos valores de las cookies, comprobar si es correcto!
  130.     static public function authByCookie($dni, $login) {
  131.  
  132.         $userN = UserMapper::getByDni($dni);
  133.  
  134.         /* Mejor invertir la condición, para evitar If anidados */
  135.         if( !$userN ) {
  136.             Authentication::logout();
  137.             return false;
  138.         }
  139.  
  140.         $cookie = Authentication::_getCookieName($userN);
  141.  
  142.         if($cookie != $login) {
  143.             $this->logout();
  144.             return false;
  145.         }
  146.  
  147.         return $userN->_islog = true;
  148.     }
  149.  
  150.     /**
  151.      * Mejor tener un método que te devuelva el cookie name encriptado
  152.      * asi evitas tener en dos lugares tu palABRAmagica ;)
  153.      */
  154.     static protected function _getCookieName($user)
  155.     {
  156.         $name = $user->dni . $user->pass . $_SERVER['REMOTE_ADDR'];
  157.         $name.= $user->rol . 'pAlABRAmagica';
  158.         return md5($name);
  159.     }
  160. }

Y luego unos ejemplos de uso básicos, ya vos los podrás adaptar a tus casos de uso más personales :
Código PHP: 
Ver original
  1. // Obtenemos un usuario ya existente
  2. $user = UserMapper::getByDni('26965061');
  3.  
  4. // Lo modificamos y grabamos
  5. $user->nombre = 'Pablo';
  6. UserMapper::save($user);
  7.  
  8. /* Si tuvieramos en un array todos los datos de un usuarios
  9.    y lo queremos guardar en la base de datos */
  10. $user = new User;
  11. UserMapper::save($user->loadByArray($datos));
  12.  
  13. /* Si tenés DNI y PASS de un usuario, y querés saber si existe */
  14. if($user = Authentication::auth('26965061', 'pepelepu')) { // Si, va un solo igual
  15.     var_dump($user);
  16. }
  17.  
  18. /* Y si querés saber si el usuario que está logueado, es uno válido */
  19. if($user = Authentication::authByCookie($_COOKIE['dni'], $_COOKIE['cookie']) {
  20.     var_dump($user);
  21. }

Te lo dejo para que lo revises y me digas que pensás. Seguramente tiene algún error de sintaxis, o quizás de objetos y todo, pero sucede que lo tipee mientras iba modificando. Cualquier cosa lo vamos mejorando de a poco.

Abrazos !
__________________
Tutoriales Photoshop | Web-Studio.com.ar
Artículos PHP | ZonaPHP.com

Etiquetas: clase, php, poo, usuarios
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta


« Tema Anterior | Próximo Tema »


La zona horaria es GMT -6. Ahora son las 17:21.