Durante tiempo estuve trabajando en un proyecto, el cual originalmente fue liberado hace unos dias pero hoy es cuando lo presento oficialmente:

Musikli.com

Musikli, el cual ahora esta en fase beta(casi alpha), en este proyecto tenemos muchos objetivos, y metas a realizar, entonces musikli se reume en:

Un sencillo portal donde encontras, letras de canciones, albumnes, información general sobre artistas en la primera parte, posteriormente se tienen contempladas muchas interesantes y utiles mejoras, las cuales estaran siendo liberadas paulatinamente.

Actualmente ya es posible crear tu cuenta “Volverte FAN”, y agregar canciones de el artista que desees, ovbiamente hay pasa por un proceso de revisión antes de ser publicado. En un futuro como FAN podras hacer muchas mas cosas.

Tambien agregamos una cuenta de twitter  @musikli. la de Facebook, estamos en proceso, aunque ya existe facebook.com/musikli, digamos que la cuenta de Facebook esta en fase pre-alpha.

Seguir a @Musikli

Les pido que la visiten la prueben, se registren y nos den un feedback sobre este interesante proyecto, aceptamos sugerencias de todo tipo, criticas, etc, inclusive si deseas participar apoyando de alguna otra forma(financiamento, formar parte del equipo), sera un placer contar con tus comentarios, para ello disponemos de la siguiente dirección de e-mail: contact@musikli.com

Espero que el proyecto sea interesante para todos, apoyanos y participa.

Javier
Fundador de Musikli.com

Solo que esta vez con buenas noticias, dare un Taller completamente gratis con el apoyo de la red Novatecas y las instalaciones de Telmexhub, el taller es sobre como empezar a programar y conocer las ventajas el Framework Kohana PHP Version 3.x.

Taller:

“Desarrollo de Aplicaciones Web con Kohana Framework”

1. Introducción
   1. Conociendo el Framework y por que usarlo
   2. Ventajas
   3. Usando un IDE (Netbeans, Eclipse, Zend Studio)
2. Getting started con Kohana
   1. Instalación
   2. Nuestro Primer programa
   3. La arquitectura de diseño MVC
      1. Modelo
      2. Modulos Database y ORM
      3. Vista
      4. Controlador
3. Creando un Blog con Kohana
   1. Creando nuestros controladores modelos y vistas
   2. Conociendo el paradigma HMVC
   3. Agregando el Panel de control
   4. Conociendo el modulo A1 para autenticacion
   5. Entornos de programación con Kohana
4. Retroalimentación
   1. Que tanto puedo hacer con Kohana
   2. Quienes usan kohana
   3. Como puedo ampliar sus funcionalidades

Requisitos:

Los requisitos que pido para que podamos aprovechar al maximo este tiempo son:

• [Indispensable]Registrarse en novatecas he inscribirse en el evento (menu eventos)en este link: http://novatecas.org/miperfil
• Conocimiento de PHP
• Conocimiento de Programación Orientada a Objetos (Mejor si es tambien en PHP)
• Tener un entorno AMP instalado (Apache/MySQL/PHP)
• Kohana trabaja bien con Linux y Windows
• Idealmente estaria mucho mejor ya traer instalado el modulo Mod-Rewrite de Apache, nos servira de mucho.
• Y si bien para aditar PHP sirve hasta el NotePad, recomiendo traer un IDE como Zend Studio, Aptana, Netbeans, Eclipse nos sera de gran ayuda y todos son gratis excepto el primero.

Lugar y Fecha:

El taller se realizara en las instalaciones de telmexhub, ubicado en: Isabel la Católica No. 51 Colonia Centro, Delegación Cuauhtémoc, D.F.(México)

El dia 28 de Enero del 2012 en un Horario de: 11:00 AM a 4:00 Pm

Nota Importante: El temario esta diseñado para conocer las caracteristicas del framework, y dependera unicamente del avance general para qeu podamos ver todos estos temas, es decir tanto podran cubrirse todos los items aqui descritos, como no:

Entonces los esperamos ese dia, aun hay lugares, habra streaming, pero tambien hay que registrarse en novatecas, para participar, hasta el proximo post

Antes de empezar a usarlo es importante considerar que el modulo usa la el constructor crypt de PHP pero usando como hash CRYPT_BLOWFISH, esto no afecta si estas usando PHP 5.3, pero si tienes este inconveniente al final del post pondré como solucionarlo(o cambiarte de hosting a uno mas actualizado).

Vamos a ver como usarlo para hacer un login.

Requisitos:

• Kohana 3.2
• Kohana A1 module
• Kohana ORM
• Kohana Database

Como dicen los requisitos para usar A1 debemos de estar conectados a una base de datos, también debemos de tener un modulo que abstraiga dicha base de datos, para esto podemos usar Kohana ORM, Automodeler, Jelly, Sprig o entre otros, si estamos haciendo pruebas yo recomiendo usar Kohana ORM, y ya en base a sus requerimientos y necesidades usar el que mas les agrade.

Instalamos kohana de modo que quede en http://localhost/kohana1/ ,creamos una base de datos yo la llamare, “system” y le pondré como datos de conexión ultra-seguros user:root password:root, recuerden activar el modulo database y ORM.

Y posteriormente nos toca, agregar el siguiente código SQL a nuestra base de datos, obviamente lo pueden modificar a su gusto, aunque de momento dejémoslo así.

 CREATE TABLE IF NOT EXISTS `users` (
	  `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT,
	  `email` varchar(127) NOT NULL,
	  `username` varchar(32) NOT NULL DEFAULT '',
	  `password` char(80) NOT NULL,
          `token` char(80) NOT NULL DEFAULT '',
	  `logins` int(10) UNSIGNED NOT NULL DEFAULT '0',
	  `last_login` int(10) UNSIGNED,
	  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

Ahora procedemos a bajar el modulo A1, que esta aquí: https://github.com/Wouterrr/A1/

Y lo ponemos en nuestro carpeta modules nombrando a la carpeta A1 de modo que quedara asi “modules/A1″.Dentro de dicha “modules/A1″ hay una carpeta config y dentro de ella un archivo llamado a1.php, bien este archivo es el archivo de configuración del modulo Kohana A1, de igual forma que se hace con todos los módulos hay que copiar este archivo a “application/config/” para poder editarlo y que no afecte directamente al modulo.

El archivo se ve de la siguiente forma:

<?php

return array(

	'driver'     => 'ORM', // orm/jelly/mango/sprig
	'user_model' => 'user',
	'cost'       => 12,    // Bcrypt Cost - any number between 4 and 31 -> higher = stronger hash

	'cookie'     => array(
		'key'         => 'a1_{name}_autologin',
		'lifetime'    => 1209600, // two weeks
	),

	'columns'   => array(
		'username'    => 'username',
		'password'    => 'password',
		'token'       => 'token',
		//'last_login'=> 'last_login', // (optional)
		//'logins'    => 'logins'      // (optional)
	),

	'session'  => array(
		'type'        => 'native' // native or database
	)
);

Aquí pongo la descripción de cada elemento:

• driver: EL ORM que usara (ORM,jelly,mango,sprig[se pueden agregar mas pero hay que modificar el modulo o extenderlo])
• user_model: tabla(modelo) que se usara ‘user’
• cost: fuerza (tamaño de la clave) entre 4 y 31, lo ideal es 12, si ponen un numero muy grande tomar en cuenta que consumirá mas recursos.
• cookie: los datos de la cookie que generara a1, para hacer el login(nombre y duración)
• columns: aquí le estamos asignando a los items de A1, las columnas de la base de datos, es decir si en su base de datos el nombre de usuarios están en el campo nombre, tendrán que poner ‘username’ => ‘nombre’, modificando lo que esta en el array, los campos opcionales de momento no los usaremos, aunque cabe señalar que solo guardan información extra.
• session: Aquí es donde definimos el tipo de sesión, de momento y regularmente bastara con dejarlo como esta, si su aplicación correrá en varios servidores conviene ponerlo en modo database(aunque en este caso hay que hacer un par de cosas mas, espero postear pronto sobre esto)

.

No se les olvide activar le modulo en el bootstrap, el cual en la sección módulos debería verse así:

<?php
//more code
/**
 * Enable modules. Modules are referenced by a relative or absolute path.
 */
Kohana::modules(array(
	// 'auth'       => MODPATH.'auth',       // Basic authentication
	// 'cache'      => MODPATH.'cache',      // Caching with multiple backends
	// 'codebench'  => MODPATH.'codebench',  // Benchmarking tool
         'A1'         => MODPATH.'A1',           //A1 authentication
	 'database'   => MODPATH.'database',   // Database access
	// 'image'      => MODPATH.'image',      // Image manipulation
	 'orm'        => MODPATH.'orm',        // Object Relationship Mapping
	// 'unittest'   => MODPATH.'unittest',   // Unit testing
	// 'userguide'  => MODPATH.'userguide',  // User guide and API documentation
	));

Ahora vamos a crear un controlador que sera en este caso el backend, el cual verificara que si estas logueado te deja entrar a ejecutar cualquier acción, si no te re-direccionara a un controlador “account” y al action “login” que tendra la vista del formulario de login, y también tendrá un link a registrarse usando este modulo A1.

En este controlador “backend” tenemos una action, llamada index que cargara un vista, en donde mostraremos un mensaje que dirá “bienvenido Nombre_de_usuario”

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * Controller_Backend 
 * 
 * Este es el backend de una aplicacion que esta usando A1 como metodo de autenticación
 * 
 * @author Javier
 * @package Backend
 * 
 */
class Controller_Backend extends Controller {

    /**
     *
     * @var User $auth contains object a1 user 
     */
    public $auth;
    
    /**
     * (non-PHPdoc)
     * @see system/classes/kohana/Kohana_Controller::before()
     */
    public function before()
    {
        parent::before();
        $this->auth = A1::instance();
        $this->_prevent_back();
        if($this->auth->logged_in()=== FALSE)
        {
            $this->request->redirect(Route::url('default',array('controller' => 'account', 'action' => 'login')));
            return;
        }
        view::set_global('logout',Route::url('default',array('controller' => 'account', 'action' => 'logout')));
    }
    
    public function action_index()
    {
        $view = View::factory("backend/home")
                        ->set("auth",$this->auth);
        
        $this->response->body($view);
    }

    private function _prevent_back()
    {
    	$this->response->headers("Cache-Control","no-store, no-cache, must-revalidate");
    }
} // End Welcome

Las partes importantes a destacar son:

• En el método before asignamos a $this->auth (variable publica) una instancia de A1, que es el modulo que hará el login.
• Luego preguntamos mediante el método $this->auth->logged_in() que seria lo mismo que usar A1::instance()->logged_in(), que si es FALSE, significa que no esta logeado entonces lo redirecciona a la siguiente url:
• Route::url(‘default’,array(‘controller’ => ‘account’, ‘action’ => ‘login’) la cual dice: que usando el route llamado default construya un url basada en cierto controlador, cierta acción y cierto id.
• Tenemos un action (metodo) index que mostrara una vista que estará en la carpeta backend, la vista se llama home y le digo que envié los datos de autenticación usando la variable auth.

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title></title>
    </head>
    <body>
        <div>
            <p>Bienvenido al sistema <strong><?php echo $auth->get_user()->email; ?></strong></p>
            <p style="float:right;">
            	<a href="<?php echo $logout ?>" >Salir</a>
            </p>
        </div>
    </body>
</html>

Este es el código del controlador account, con sus metodos/acciones de registro y login.

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * Controller_Account
 * 
 * Aqui estaran las funcionalidades de login y registro
 * 
 * @author Javier
 * @package Backend
 * 
 */
class Controller_Account extends Controller {

    /**
     *
     * @var User $auth contains object a1 user 
     */
    public $auth;
    
    /**
     * 
     * Variable que guardara la sesión
     * @var Session $session
     */
    public $session;
    
    /**
     * 
     * Vista que usara el sistema
     * @var View|String $view
     */
    public $view;
    
    /**
     * 
     * Aqui se cargara el modelo users
     * @var Model_Users $users
     */
    public $users;
    
    /**
     * (non-PHPdoc)
     * @see system/classes/kohana/Kohana_Controller::before()
     */
    public function before()
    {
        parent::before();
        $this->auth = A1::instance();
        $this->session =  Session::instance();
        $this->users   = new Model_Users();
    }
    
    public function action_index()
    {
        $this->action_login();
    }
    
    public function action_login()
    {
        $errors =  array();
        if($this->request->method()=="POST")
        { 
            
            $username = Arr::get($_POST, 'username');
            $password = Arr::get($_POST, 'password');
            $remember = (isset($_POST['remember']))?TRUE:FALSE;
            
            if($this->auth->login($username,$password,$remember))
            {      
                $session = $this->auth->session()->as_array();
                $session["user"] = $this->auth->get_user();
                $this->session = $session;
                $this->request->redirect(Route::url('default',array('controller' => 'backend','action' => FALSE))); 
            }
            else
            {
                $errors['login'] = "Datos no validos";
            }
        }
        $this->view = View::factory('backend/login')
        					->set('posturl',Route::url('default',array('controller' => 'account', 'action' => 'login')))
        					->set('registerurl',Route::url('default',array('controller' => 'account', 'action' => 'register')))
                            ->set("errors",$errors);
    }
    
    public function action_register()
    {
    	$errors =  array();
        if($this->request->method()== "POST")
        {
        	$username = Arr::get($_POST, 'username');
            $password = Arr::get($_POST, 'password');
            $errors['register'] = "Error al intentar registrarse";
            if($this->users->unique_user($username)=== FALSE)
            {
         		   	$new_user = $this->users->save_user($username,$password,$this->auth);
         		   	if($new_user->saved())
         		   	{
         		   		$this->auth->complete_login($new_user);
         		   		$this->request->redirect(Route::url('default',array('controller' => 'account', 'action' => 'login')).'?saved');
         		   	}
         		   	$errors["register"] = "No se pudo guardar el nuevo registro";
            }
            $errors['register'] = "El usuario {$username} ya existe en la base de datos";
        }
        $this->view = View::factory('backend/register')
        						->set('errors',$errors)
            					->set('posturl',Route::url('default',array('controller' => 'account', 'action' => 'login')))
        						->set('registerurl',Route::url('default',array('controller' => 'account', 'action' => 'register')));    
    }
    
    public function action_logout()
    {
    	$this->auth->logout();
    	$this->request->redirect(Route::url('default',array('controller' => 'backend','action' => FALSE)));
    }
    
    public function after()
    {
        $this->response->body($this->view);
        parent::after();
    }

} // End Account

Como vemos este controlador, tenemos el método before que se ejecuta antes de cualquier “action” en donde establecemos el valor de algunas propiedades de la clase como la autenticación, la sesión y el modelo (entidad).

También le indico que si recibo el método action_index, en realidad ejecute el método action_login, que es el que hará el trabajo.

El método action_login, lo que hace es mostrar la vista login, la cual tiene esta estructura.

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title></title>
    </head>
    <body>
        <div>
        <h2>Iniciar sesión</h2>
        <?php if(isset($errors['login'])):?>
        <p style="border:#F00 1px solid;background:#dd0000;color:#fff;width:auto;">
        	<?php echo $errors['login'] ?>
        </p>
        <?php endif; ?>
        <form action="<?php echo $posturl ?>" method="POST">
            <p>
                <label>Usuario</label>
                <input type="text" value="" name="username" />
            </p>
            <p>
                <label>Password</label>
                <input type="password" value="" name="password" />
            </p>
            <p>
                <input type="checkbox" name="remember" />
                <label>Recordar password</label>
            <p>
                <input type="submit" value="Iniciar sesión" name="login" >            
            </p>            
        </form>
        <p>
            <a href="<?php echo $registerurl ?>">Registrarse</a>
        </p>
        </div>
    </body>
</html>

Que como vemos, es un simple formulario.

En el mismo método action_index, tiene un if que comprueba si recibe una petición POST, si es así extraemos las variables usando Arr::get de kohana, también verificamos si existe la variable remember, la cual actúa como una FLAG, que en caso de ser verdadero lo usaremos para recordar los datos del usuario.

Aquí es donde ocurre, toda la “magia”, y haremos hincapié en esto.

if($this->auth->login($username,$password,$remember)) :

Este código lo que hace es hacer el login, y el ultimo parámetro remember tiene la capacidad de generar el recordatorio del password.

Si el login es correcto, se creara un sesión y hará la lógica de asignación de variables del usuario a la sesión, posteriormente se redirecciona a el backend del sistema.

En caso de no hacer el login, tenemos anteriormente un array, que en este caso asignara a una clave llamada login, un mensaje de error., el cual se mostrara en la vista login.

También tenemos un método action_register, que posee, un formulario similar al de login, y que en este caso hace el registro de un usuario, usando el modelo users, el cual también hace validación de que no exista un usuario con el mismo nombre(obviamente la validación puede ser diferente).

Y también tenemos el método save_user que es encargado de hacer el insert del nuevo usuario, aquí vemos que usamos para el password, $auth->hash(), que es un método de A1, que lo estamos inyectando como dependencia (DI), y es importante usar este método ya que con esto generamos el password usando el algoritmo de cifrado que incluye A1, aunque lo podremos modificar, pero es indispensable convertir el password al guardarlo, al hacer el login no es necesario convertirlo A1 lo hace en automático.

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * 
 * Model_Users 
 * 
 * Modelo/entidad de la tabla users
 * 
 * @author Javier
 * @package backend
 */
class Model_Users extends ORM {

	/**
	 * 
	 * Evitamos que convierta mi tabla a plural
	 * @var boolean $_table_names_plural
	 */
	protected $_table_names_plural = FALSE;


	/**
	 * 
	 * Comprueba que no exista en la base de datos(evita duplicados)
	 * @param String $username
	 * @return boolean 
	 * 
	 */
	public function unique_user($username)
	{
		$user = ORM::factory($this->_table_name)->where('email','=',$username)->find();
		return (bool) $user->loaded();
	}

	/**
	 * 
	 * Inserta un nuevo usuario
	 * @param String $username
	 * @param String $password
	 * @param A1 $auth
	 * @return Model_Users $user
	 * 
	 */
	public function save_user($username, $password, A1 $auth)
	{
		$user = ORM::factory($this->_table_name);
		$user->email = $username;
		$user->password = $auth->hash($password);
		$user->save();
		return $user;
	}

}

Regresando al controlador, después de que el nuevo usuario se haya registrado, se redirecciona al login, si no simplemente avisa del error, mandando esta información, a la vista.

En el mismo controlador tenemos un método action_logout, que lo que hace es cerrar la sesión, y redireccionar, aquí creo que no hace falta mas explicación.

En el método after lo que hago es lanzar la vista a la pantalla usando $this->response->body

Quizá un poco larga la explicación pero es mejor que quede claro.

En resumen, creamos nuestro controlador que haga el login, y otro que cree las cuentas, usamos A1, para manejar el password, para registrar el usuario y para hacer el login, evitando volver a reescribir este proceso cada vez que necesitemos hacer un login.

Como nota adicional, verán en el controlador backend un método privado que se llama: _prevent_back(), este método evita que cuando hagamos logout, al dar clic en el botón atrás, no regrese a la sesión como si nunca hubiéramos salido por que esta cacheado, aunque realmente hayamos finalizado la sesión y no permita hacer nada. Estoy en contacto con el creador del modulo y mande la propuesta de agregar este control de cache al core del modulo, y la parecer en breve ya vendrá por default y ya no tendrán que agregar este método(sera configurable desde el archivo de configuración del modulo).

Tambien me falto agregar que el campo de la base de datos para el password, debe de ser de al menos 70-80 caracteres, o más, por que las cadenas que genera A1, para los passwords son muy grandes, y si aumentan el cost en el config, aun seran mas grandes.

Aparte de los gists, dejo el proyecto en github, para que quien guste lo puede tomarlo y bajarlo:

Hasta el próximo post.

Github: kohana A1 implementación.
Parche para usar A1 pero con sha1 si necesidad de usar bcrypt: https://gist.github.com/1352205
Colocar el archivo del parche (a1.php) en application/classes/ y ahora sus password que generen o usen usaran sha1 y no brcypt con CRYPT_BLOWFISH

<?php
/**
 *
 * Clase abstracta que define los metodos que implementaran los databaseManagers
 * @author Javier Lopez Lopez
 * @abstract
 *
 */
abstract class DatabaseManager{
	abstract public function findAll();
}


/**
 *
 * Clase Mysql Database manager (el singleton)
 * @author Javier Lopez Lopez
 *
 */
class Mysql extends DatabaseManager {

	private static $instance;

	private function __construct(){	}

	private function __clone(){ }

	public static function getInstance()
	{
		if(!(self::$instance instanceof self))
		{
			self::$instance = new self;
		}
		return self::$instance;
	}
	//...MORE CODE

	public function findAll()
	{
		//return all results
	}
}

/**
 * Usando el singleton
 */
class Controller {

	protected $database;

	public function __construct()
	{
		//Como se que debo de incluirlo si nunca lo solicito en la ejecución de la clase
		//Ademas me limita a usar solo databasemanager de tipo MySQL
		//Evita que crezca el servicio no puedo agregar mas databases;
		$this->database = Mysql::getInstance();
	}

	public function getAll()
	{
		return 	$this->database->findAll();
	}
}

//Uso

$controller = new Controller();
$controler->getAll();
//nunca sabemos que adentro lleva un clase que se llama Mysql,
//entonces puede fallar, tambien no sabemos que se necesita Databasemanager

En la primera clase tenemos la implementación del singleton, y en la segunda clase en el constructor estamos llamando al singleton, sin embargo, caemos en una mala practica, la cual si vemos Mysql::getInstance() es como si fuera una llamada a una clase estática global, la cual es como si estuviéramos usando variables globales, lo cual es totalmente desaconsejado de usar, como comentan en mundogeek por las siguientes cosas:

• El código es más difícil de entender
• El código es más difícil de depurar
• El código es más difícil de testear
• El código es más difícil de mantener
• El código es más difícil de reutilizar
• Las variables globales matan gatitos

Extraído de: http://mundogeek.net/archivos/2011/07/12/variables-globales/

Entonces vemos que a pesar que de es posible usar Singleton no deberíamos de usarlo, solo en casos muy excepcionales, aunque es mejor buscar algún otro patrón de diseño.

Lo que deberíamos usar el la inyección de dependencias, que si bien es fácil de usar puede ser un poco complejo de entender:

La inyección de dependencias soluciona todos los items anteriores, y nos da una accesibilidad concreta a cada clase que necesitemos, si pasamos el código anterior a inyección de dependencia seria de la siguiente forma:

<?php
/**
 *
 * Clase abstracta que define los metodos que implementaran los databaseManagers
 * @author Javier Lopez Lopez
 * @abstract
 *
 */
abstract class DatabaseManager{
	abstract public function findAll();
}


/**
 * Clase Dependencia llamada Mysql
 * @author Javier Lopez Lopez
 */

class Mysql extends DatabaseManager {

	public function __construct()
	{
		//code of mysql
	}

	public function findAll()
	{
		//return all results
	}
}


/**
 * Usando el Inyección de dependencias
 */
class Controller {

	protected $database;

	public function __construct(DatabaseManager $database)
	{
		$this->database = $database;
	}

	public function getAll()
	{
	 	return $this->database->findAll();
	}
}

//Uso
//opción 1
$databaseManager = new Mysql();
$controller = new Controller($databaseManager);

//Opción 2
$controller = new Controller(new Mysql);

//Opcion 3 cambiando de database manager sin problemas
$controller = new Controller(new SqlServer);
//suponiendo que tenemos un clase SqlServer

//resultado
$controller->getAll();

Como vemos es simple de implementar pero debemos estudiar bien el código, para que con esto no solo evitemos el uso de Singletons (“globales glorificadas”), si no que además podamos usar TDD(Desarrollo Guiado por Pruebas) sin ninguna complicación, además de tener un código claro y fácil de reutilizar componentes.

Como en este caso, podemos tener varios manejadores de base de datos como Mysql, SqlServer, etc, y podemos definir claramente cual necesitamos.

Como nota aclaratoria, yo no condeno el uso de singletons pero su uso debe de ser muy excepcional, de hecho Kohana Framework los usa pero para casos muy concretos de hecho casi todo su código usa inyección de dependencias.

La verdad me gustó mucho aunque creo que me extendí demasiado, total que terminamos en 1 hora y media, pero aun así mi temario que tenía preparado no se terminó, llegue como a la mitad, aunque trate de sentar las bases del framework y estoy en espera de que si lo solicitan puede haber una parte dos.

Iniciamos con una breve introducción de unos cuantos slides, en donde aborde conceptos básicos del framework, como POO, MVC, HMVC, Cascading Files, entre otros, posteriormente pasamos a bajar el framework he instalarlo, de ahí nos pusimos a revisar el bootstrap, y crear nuestro !Hello World!, también comentamos sobre los módulos, y activamos los módulos de Database y ORM, he hicimos un modelo y una vista para hacer consultas desde nuestro controlador.

Estuvo muy interesante sin embargo quedaron muchas cosas en el tintero como, hablar sobre modrewrite, crear, actualizar y borrar registros en la base de datos, crear más controladores, más vistas, conocer Controller_Template y hacer un feedback sobre todo esto, la verdad hay bastante para una segunda parte que puede durar casi lo mismo, además de que parte de este material me servirá para crear el temario de un taller completo de Kohana en México en Telmexhub cortesía de ComunidadPHP.

De momento solo me resta decir que fue una agradable experiencia, donde trate de mostrar las ventajas de utilizar este framework, y trate de mostrar que hay mejores formas de hacer las cosas con PHP, para ser cada vez mejores en este lenguaje.

Como prometí, la practica la subí a github y los slides a slideshare, abajo pongo los links, bueno hasta el próximo post que espero sea muy pronto.

Código en github: https://github.com/Ajaxman/Kohana3/
Slides en Slideshare: http://www.slideshare.net/Ajaxman/desarrollo-web-con-kohana-framework-php
Manual de kohana: http://kohanaframework.org/3.2/guide/
Api de kohana: http://kohanaframework.org/3.2/guide/api

Les  platico un poco de que ha sido de mi durante este paro de labores(blog).

Primero lo mas importante hace 2 meses fui papa por segunda vez, en esta ocasión de una niña hermosa llamada Avril.

Mi hijo angel ya sabe usar paint(windows) y tuxpaint(Debian linux) y al parecer le gusta la informática, los números, las letras,los colores.

También hace dias cumpli  3 años de casado y feliz.

También, pasaron otras cosas como cambio de trabajo, y en lo profesional empecé a interesarme aun mas en PHP y las best practiques  como refactorización, más OOP, namespaces, TDD, DRY, KISS, SOLID, DI, y hasta integración continua, si bien aun me falta mucho por aprender(y no conozco todo eso pero me gustaría) estoy esforzándome en llevar esto a la practica.

Conoci git y github(Control de versiones) y me gusta mucho usarlo, y recomendarlo.

Entonces que es lo que viene, bueno de momento, el miércoles tengo una sesión relámpago de kohana via streaming para México y Colombia, también en breve anunciare la fecha del taller de Kohana en telmexhub(esta en proceso), también vienen más proyectos en mente pero el más próximo es que es probable que en el siguiente año forme mi empresa (Desarrollo web con alta calidad (Q&A)), y quizas hasta lance un libro sobre kohana en español, en fin muchos proyectos, poco a poco informare de cada uno de ellos, de momento mi primer pendiente es retomar el blog, eso si no prometo postear mucho pero eso si contenido de calidad e interesante buen eso tratare.

En fin, muchas cosas se vienen ojala les gusten, y de paso si quieren saber más sobre todo esto o desean algún servicio (freelance), no duden en contactarme, ya sea en el contacto o por mi twitter  @ajaxman

Ha y gracias por seguir visitando el blog

Sin embargo hay una tecnica bastante usada que a veces muchos desconocemos y esta usar la url, pero usando el nombre del archivo o script que estamos procesando esto es.

Si nuestra url es asi:

www.ajaxman.net/index.php?post=15&name=PHP-en-la-web

Podremos tener urls amigables sin necesidad de usar Modrewrite en Apache o sin necesidad de configurar nada de la siguiente forma.

www.ajaxman.net/index.php/PHP-en-la-web/15.html

Como vemos esta url si la indexaria Google y los demas buscadores, pero no hubo necesidad de configurar nada, entonces ello nos daria un buen posicionamiento, por ejemplo si buscamos automoviles en mexico o computadoras en Monterrey, podriamos usar este texto como parte de la url sin meternos en problemas con el servidor.

Ahora bien para tomar esta variable es muy facil, solo basta con usar la siguiente variable del servidor.

var_dump($_SERVER['PATH_INFO']);

Si ejecutamos el codigo anterior veremos que nos arrojara lo siguiente (usando la url de ejemplo de arriba)

string(22) “/PHP-en-la-web/15.html”

Como vemos usando simplemente esta variable del servidor podemos obtener la url que le enviamos y posteriormente procesarla para lanzar nuestro controlador o clase que deseemos.

Como recomendacion nunca reciban el parametro para incluir ese mismo archivo algo asi

Podremos tener urls amigables sin necesidad de usar Modrewrite en Apache o sin necesidad de configurar nada de la siguiente forma.

www.ajaxman.net/index.php/productos_15.php // Que invocaria al archivo productos_15.php

Pero el cual puede ser un grave fallo de seguridad y puede dar lugar a que nos inyecten codigo en nuestra aplicación.

Bueno este solo fue un tip y ya me extendi como siempre, pronto mas posts sobre kohana php, y sobre como enlazarlo con el sistema de plantillas twig, el ORM Doctrine y tambien intentare mejorar un modulo de kohana para usar Zend Search Lucene, pero luego les platico más.

Este se llama QueryBuilder, el cual como su nombre lo indica es un constructor de consultas.

En el post anterior, comente como usar el ORM de kohana, el cual como vemos nos ahorra mucho trabajo y nos permite hacer consultas complejas mediante el uso de la orientación a objetos, sin embargo no todo es tan maravilloso como suena, una de las cosas mas contraproducentes que tiene este y la mayoría de ORM’s es la siguiente.

Ejemplo de lo que sucede al hacer una consulta usando el ORM

//Consulta ORM
$result = ORM::factory('users')->find_all();

//Consulta generada
$sql = 'select * from users';

Como vemos por default, nos esta haciendo un select *, esta consulta puede afectar seriamente nuestro rendimiento cuando nuestra tabla contiene muchos registro o muchos campos, además de que cuando tenemos tablas con un campo ambiguo, hacer funcionar bien el ORM puede darnos varios dolores de cabeza.

Los desarrolladores de kohana, antes de lanzar el ORM, crearon un constructor de consultas, el cual nos da toda la potencia de el lenguaje SQL, pero usando técnicas de orientación a objetos usando PHP.

Para usarla lo haremos configurando todo lo necesario como lo hicimos en el post anterior, y crearemos los querys de la siguiente forma.

* Uso de método estático DB::query()

//Sintaxis
$query = DB::query(integer $type,String $sql);

Esta es una de las herramientas mas completas que tenemos dentro del QueryBuilder, básicamente es un método estático en donde recibe dos parámetros, el primero de tipo integer que en realidad es una constante de la clase Database, en donde le indicamos que tipo de consulta haremos( select, delete, insert, update), veamos su equivalencia.

Database::SELECT;  // corresponde a 1
Database::INSERT;  // corresponde a 2
Database::UPDATE;  // corresponde a 3
Database::DELETE;  // corresponde a 4

El segundo parámetro es string donde indicamos la consulta que necesitemos hacer la cual puede incluir algunas variables las cuales estarán indicadas mediante dos puntos y el nombre de variable, el cual no tiene nada que ver con las variables de PHP, y posteriormente se le puede indicar el valor de dicha variable mediante el método param, parameters o bind.

Veamos como quedarí­a una consulta normal

$user = 'ajaxman';

//Nótese la variable :user

$query = DB::query(Database::SELECT, 'SELECT id,username FROM users WHERE username = :user');

//Asignación de la variable :user a variable PHP $user.

$query->param(':user',$user);

/***  Ejemplo de como seria en modo normal de PHP y MySQL ***/

$query = 'SELECT id,username FROM users WHERE username = '.$user;

Pero aun no tenemos terminada nuestra consulta, para que se ejecute debemos especificarlo explícitamente mediante el método execute.
Veamos algunos ejemplos de como usar lo que hemos visto en un query complejo y algunas variantes de como hacer esto.

//Declaración de variables en hardcode, esto debe de ser de otra forma,
// dentro de una clase (Modelo) y un método correspondiente
// Solo esta así por que es ejemplo
$user = 'ajaxman';
$password = 'passworddificil001';

//Forma 1

$query = DB::query(Database::SELECT, 'SELECT id,username FROM users WHERE username = :user and password = :pass');
$query->param(':user',$user);
$query->param(':pass',$password);
$query->execute();

//Forma 2
//También podemos hacer el query de esta forma, y podemos usar la que mas nos guste

$query = DB::query(Database::SELECT, 'SELECT id,username FROM users WHERE username = :user and password = :pass')
             ->param(':user',$user);
             ->param(':pass',$password);
             ->execute();
//Nótese que son métodos que se adhieren al mismo método estático (luego veremos como usar esta técnica)
//ya que nos permite un código mas claro

//Forma 3
//Los parámetros podemos pasarlos como un array,veamos el tercer ejemplo

$query = DB::query(Database::SELECT, 'SELECT id,username FROM users WHERE username = :user and password = :pass')
$query->parameters(array(
               ':user' => $user,
               ':pass' => $pass,
));
$query->execute();

//Forma 4
//Esta forma es mediante el uso de el método bind y es útil para hacer muchos inserts ya que se apoya de
//El uso de arrays, y foreach para hacer los inserts

$users =  array(
    'ajaxman' => 'passworddificil002',
    'javier' => 'passworddificil003'
 );

$query = DB::query(Database::INSERT, 'INSERT INTO users (username, password) VALUES (:user, :pass)')
             ->bind(':user', $username)
             ->bind(':pass', $password);
foreach ($users as $username => $password)
{
     $query->execute();
}

//El ejemplo anterior vemos que con el foreach se esta ejecutando el query pero además antes de ejecutarse reemplaza :user y :pass
//por cada uno de los elementos del array que definimos arriba

Como vemos hay muchas formas de usar DB::query(), y podemos hacer la mayoría de consultas con este método estático.

Cuando empecé este post, pensaba abarcar otros métodos del QueryBuilder como DB::select, DB::expr, entre otros, sin embargo creo que se extendió demasiado este método, asi que esta sera la parte I, en la próxima parte veremos si acabo el post, si no de todas formas, ahí les aviso, de momento esperen la parte 2.

Toda esta información fue basada en mi experiencia con kohana y documentación de las siguientes API’s

API:Database
API: Database_Query

Y la documentación de kohana framework (Version 3.1.x): Prepared Statements

El único punto en contra es que solo tiene soporte para MySQL, pero como la mayoría usamos la combinación LAMP o mejor  MySQL+ PHP, creo que vale la pena estudiarlo a fondo.

Para usarlo recordemos que solo basta con descomentar el modulo en el bootstrap y mover el archivo de configuración database.php a nuestra configuración de la aplicación.

Ahora bien vamos a describir como usar el ORM y como usar la mayoría de sus características.

Haciendo una simple consulta.

Es importante recordar que hay que agregar una clase para manejar cada tabla, aunque esto a veces se puede omitir ayuda mucho tener todo refactorizado ya que mejora la organización del código ya la vez su mantenimiento.

PROBLEMA: Como hacer una consulta de todos los datos de una tabla(‘users’);

//Consulta normal
$sql = 'select * from users';
$results = mysql_query($sql,$conection);
if($results) {
//Resultados
}

//Consulta ORM

$results = ORM::factory('users')->find_all();
if($results->loaded())
{
// Resultados
}

Como vemos es muy fácil de usar el orm, ahora veamos otros ejemplos mas avanzados

PROBLEMA: Consultar la tabla mediante un id único

$id = 5; //id unico

//Consulta normal
$sql = 'select * from users where id = '.$id;
$results = mysql_query($sql,$conection);
if($results)
{
// Resultados
}

//ORM Forma:1
$results = ORM::factory('users',$id)->find();
if($results->loaded())
{
// Resultados
}

//ORM Forma:2
$results = ORM::factory('users')
->where('id','=',$id)
->find();
if($results->loaded())
{
// Resultados
}

Como vemos podemos hay dos formas de hacer la consulta con el ORM, ya se indicándole el id al factory o mediante where, al final es lo mismo, solo que la primero forma sirve para el id únicamente(el nombre del campo debe de ser id por default aunque también se puede modificar).

Algunos de los métodos que podemos usar son los siguientes(no son todos pero tratare de poner los mas importantes)

• where
• where_open
• where_close
• join
• on
• order_by
• offset
• limit
• group_by
• or_where
• and_where

Obviamente combinando todos podemos crear consultas complejas, por ejemplo la siguiente.

//Consulta normal
$sql = 'select articulos.* from articulos ';
$sql .= 'where (articulos.activo = 1) or (articulos.activo = 2) ';
$sql .= 'inner join subcategorias ';
$sql .= 'on subcategorias.id = articulos.idsubcategoria ';
$sql .= 'limit 20 order by id DESC ';
$results = mysql_query($sql,$conection);
if($results) {
//Resultados
}

//Consulta ORM
$results = ORM::factory("articulos")
->join('subcategorias', 'INNER')
->on("subcategorias.id","=","articulos.idsubcategoria")
->where("articulos.activo", "=",1)
->or_where("articulos.activo", "=",2)
->limit(20);
->order_by('id','DESC')
->find_all();

if($results->loaded())
{
//Resultados
}

Como vemos el ORM nos permite hacerlo todo desde un punto de vista orientado a objetos.

Para ver más capacidades recomiendo leer la guía de la documentación de kohana y también darle un vistazo a al API del ORM donde viene ejemplos de todo.

Algunas recomendaciones útiles son

• Usar una clase(un modelo) por cada tabla(a veces hay excepciones)
• Las consultas deberán de ir dentro de métodos de tu clase modelo algo así

class Model_Articulos  extends ORM {

public function getArticlesBySubcategory()
{
$results = ORM::factory("articulos")
->join('subcategorias', 'INNER')
->on("subcategorias.id","=","articulos.idsubcategoria")
->where("articulos.activo", "=",1)
->or_where("articulos.activo", "=",2)
->limit(20);
->order_by('id','DESC')
->find_all();
return $results;
}

//more methods

}

Así toda la capa de persistencia la tenemos aparte sin mezclarla con la capa de lógica(controlador).

• Usar nombres de tablas en plural
• Usar nombre de campo en singular
• Para evitar tener problemas con la pluralización de kohana yo le indico que use el nombre como se lo puse mediante esto.

class Model_Users extends ORM {

protected $_table_names_plural = FALSE;
//....
}

De esta forma evito que me cambie el nombre de la tabla a useres (kohana le agrega el “es”) por la pluralidad, así que mejor yo le dijo que no la cambie.

• También se le puede especificar otro nombre de tabla a usar que no sea necesariamente el nombre de nuestra clase modelo

class Model_Posts extends ORM {

protected $_table_name = 'wp_posts';
//...
}

Como vemos kohana tiene un completo ORM, al cual si bien le faltan algunas cosas va por buen camino y es bueno ir aprendiendo todas sus capacidades, para trabajar con el.

En el próximo post veremos como mejorar el performance de nuestros querys, eliminado pequeños detalles que genera dicho ORM, ya que no alcance a terminarlo hoy.

1.- Kohana PHP

Es un framework escrito en PHP para acelerar el desarrollo de aplicaciones web, originalmente basado en CodeIgniter pero reescrito desde cero.

2.- Las ventajas de kohana PHP

Bueno son muchas, aquí pondré algunas

• Extremadamente ligero
• PHP 5 Estricto
• OOP
• Arquitectura HMVC
• Curva de aprendizaje fácil, pero extensa
• Se puede usar con Doctrine ORM, Smarty, Twig y hasta con tus propias clases sin problemas.
• IDE – Trabaja muy bien con Netbeans.

3.- Las versiones de Kohana PHP

Kohana surgió como un fork de Codeigniter(CI) tratando de mejorarlo, y la versión 2.x es basado en CI y actualmente hay soporte para la misma y es manejada por Jeremy Bush( aka zombor).

Sin embargo la versión que uso y recomiendo en las 3.x, mas específicamente la 3.1.3.1, la cual también es estable, la recomiendo por que esta reescrita desde cero pensando en puro PHP5 Y OOP, , es mas fácil de usar, y con muchas mejoras a nivel código, de la versión 3.0 y 3.1.1, hubo cambios algo fuertes y puede que tu código no funcione bien.

En resumen usa la versión 3.1.3.1 y evitate problemas.

4.-Instalando Kohana PHP

Tengo aquí un post que menciona como instalar Kohana PHP, que no es mas que descomprimir, ver si tenemos todos los requisitos y ya.

Además de eso recomiendo que su servidor tenga soporte para .htaccess y el modulo ModRewrite instalado y en ese archivo comenta esta linea, ya que puede generarte problemas con la ubicación de tu kohana

# Installation directory
#RewriteBase /

5.-  Configura tus rutas dentro del bootstrap

Configura tus rutas dentro del archivo Bootstrap, por default viene configurada una ruta que se llama default la cual apunta al controlador welcome, elimina ese archivo y configura tus rutas o ponlo para que apunte al controlador por default de tu proyecto

//reescribir estas lineas de acuerdo a tu proyecto
Route::set('default', '(<controller>(/<action>(/<id>)))')
->defaults(array(
 'controller' => 'welcome',
 'action'     => 'index',
));

6.- Elimina tu archivo de instalación

Cuando se instala kohana siempre trae un archivo que se llama install.php, el cual se encarga de verificar y mostrar que tengas todos los requisitos para usar kohana, después de que verifiques que todo esta ok, debes borrarlo ya que contiene información sensible que puede ser accesible muy fácilmente.

7.- Cada cosa en su lugar

Si bien cuando uno empieza a probar kohana sin leer mucho, hay cosas que podemos hacer pero que no están bien como poner consultas en los controladores, o en las vistas, hay que organizar todo, es mucho mejor.

Estas son las reglas

• Ruteos en el Bootstrap
• Capa de lógica en el Controlador
• Capa de persistencia de datos en los modelos
• Capa de presentación en las vistas

8.- Configura tu init del bootstrap

Configura en tu bootstrap tu url_base que es donde esta la dirección de tu sitio, es decir si tu sitio es http://www.ajaxman.net y ahí estas usando kohana en tu bootstrap debe de estar así

Y de preferencia usa urls amigables solo indicando, index_file como FALSE.

Kohana::init(array(
 'base_url'   => 'http://www.ajaxman.net/',
 'index_file' => FALSE
));

9.- Usa un IDE

Para desarrollar con kohana, sirve hasta el bloc de notas (o el vi), pero a veces no es lo mejor, yo recomiendo que usen un IDE (Entorno de Desarrollo Integrado) como Eclipse, Zend Studio, Netbeans, Aptana,etc.

Yo uso Netbeans y trabaja de maravilla, reconoce todos los métodos y clases de kohana, además de que Netbeans te sirve para programar en Java, C, C++, Python entre otros y es Open Source

10.- La configuración de tu aplicaciones

Todos los módulos y algunas clases de kohana viene con una carpeta config y dentro de estas aparece un archivo con el nombre de la clase, estos archivos, contienen la configuración de cada clase que necesita configuración.

Para tenerlos mas claros estos se encuentran dentro de:

• *configuraciones del sistema
  • System
    • config
• *configuraciones de los módulos
  • Modules
    • nombre_del_modulo
      • config

Y si bien se puede configurar desde ahí, no es recomendable, entonces lo que hay que hacer es que cada vez que necesites usar algo lo debes de configurar, para hacerlo solo debes de copiar estos archivos dentro de la ruta de aplicación esto es.

• *configuraciones de tu aplicación
  • application
    • config

Y ahí configurarlos así tienes todo dentro de tu aplicación.

11.- Cambia tus permisos en tus archivos de logs

Cuando uno empieza a programar en kohana a veces veremos errores del tipo:

ErrorException [ 2 ]: file_put_contents(/home/tuwebsite/public_html/application/logs/2011/05/10.php) function.file-put-contents]: failed to open stream: Permission denied ~ SYSPATH/classes/kohana/log/file.php [ 82 ]

Esto sucede por que que no tienes permisos para escribir en el archivo 10.php lo que hay que hacer aparte de cambiar los permisos de application/logs y todos sus directorios también hay que crear un archivo en blanco con el nombre del día que nos este mostrando en este caso es el 10.php, y darle permisos 777, para que escriba los logs, en este caso el error es por que no existe mi controlador.

Entonces mas que nada hay que tener dicho archivo y permisos de escritura para que guarde ahí el error.

Si no quieren usar este archivo hay que comentar la siguiente linea en el bootstrap

/**
 * Attach the file write to logging. Multiple writers are supported.
 */
Kohana::$log->attach(new Log_File(APPPATH.'logs')); //Comentar esta linea

12.- Quita el user_guide

Por último otra recomendación útil es quitar el modulo user_guide ya que no sirve de mucho mostrar esta información al usuario y puede ser un agujero de seguridad.

Solo hay que borrarlo dentro de la carpeta modules.

Con estos 12 tips espero que les sea más fácil de usar kohana además de que ojala y sirva de base para que migren de otros frameworks, si tienen algún duda pues me avisan en lo comentarios, ha también se viene el congreso de PHP, pronto mas detalles.

Kohana FrameWork: Kohana: The Swift PHP Framework