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

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

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

Pues obviamente hay muchos que queremos tener nuestro Framework actualizado, entonces pues me dispuse a migrar un website de la versión 3.0.9 a la 3.0.x.

Las instrucciones de migrar son fáciles, regularmente se basa en reemplazar el directorio system de nuestra aplicación, pero esta nueva versión incorpora muchos cambios los cuales, hacen la migración un poco mas complicada.

El mismo sitio de kohana nos avisa de los siguientes cambios:

//Versión 3.0.x

$this->request->response = 'foo';

//Versión 3.1
$this->response->body('foo');

//Cambios en la clase Request de propiedades a métodos

//Versión 3.0.x  ===>    Versión 3.1
Request::$controller ==> Request::controller()
Request::$action ==> Request::action()
Request::$directory ==> Request::directory()
Request::$uri ==> Request::uri()

Todos lo puntos son marcados aquí
http://kohanaframework.org/3.1/guide/kohana/upgrading.

Ahora bien, a mi los que mas me interesaron, son importantes y no vienen aqui son los siguientes.

Request

//Versión 3.0.x

Request::instance();

El método estático anterior nos devolvía el singleton de nuestra solicitud con dicho método estático podiamos obtener parámetros y una de las cosas para lo que yo la utilizaba era para la creación de mi Breadcrumb.

//Version 3.1

Request::current();

//o

Request::initial();

Aquí como vemos tenemos dos opciones, y se elimino instance, las dos son iguales salvo por un detalle, si usamos HMVC, initial contendrá la información de la petición inicial, es decir si desde un controlador estamos invocando a un Request::factory(), ese sera inital y el factory invocado sera current cuando estemos programando dentro del factory.

Importante, lo anterior hay que tenerlo muy en cuenta ya que algunos módulos pueden usar dicho método estático, entonces, hay que buscar alguna actualización del mismo (me paso con el modulo de paginación)

Bootstrap

Pues creo que hay que destacar que reescribieron bastante de este archivo, por ello hay que reemplazar el que tenemos, obviamente guardando una copia del actual, ya que recordemos que en el bootstrap se guardan las rutas, módulos y muchas configuraciones de Kohana.

Desaparece el método ->render() de la vistas

También es fundamental remarcar este cambio, en versiones anteriores se usaba View::factory($vista)->render(); el cual ya no existe por ello si lo tienen así, quítenle ese método a sus vistas o sea quedaria View::factory($vista); (Nota puede afectar a sus módulos, de nuevo me paso con el modulo de paginación).

Security::xss_clean

También desaparece, podemos usar HTML::chars().

Para generar mi breadcrumb yo lo hacia con una código el cual extraía un array de la url, el cual ya no funciona, ahora hay que tomar la url y volverla array con explode como dice el siguiente código

//versión 3.0.x  $segments es un array con las partes que forman la url

$segments = Request::instance()->param();

//Versión 3.1  Ahora tenemos que tomarla de un string el cual cambio la forma de extraerlo ya que las nuevas clases están mas completas  y convertirla a array
$segments = Request::$current->param();
$segments = explode('/',$segments['uri']);

Bueno pues como verán los cambios si son fuertes, y también ya no viene el modulo de paginación( ahora hay que bajarlo),inclusive el index.php cambia, como vemos el equipo de kohana realizo bastantes cambios, los cuales al principio pueden darnos algún dolor de cabeza, pero es mejor migrar de una vez ya que ya están trabajando en la versión 3.2(la cual saldría en 6 meses aproximadamente) y hasta la 3.3.

Hasta aquí llegamos, con este post, en entregas posteriores tratare de cubrir los temas pendientes de kohana framework

Anuncio del lanzamiento: http://forum.kohanaframework.org/discussion/8024/kohana-v3.1.0-released

Manual de Kohana 3.1.x : http://kohanaframework.org/3.1/guide/

• Apache o un servidor Web como Lighttpd
• Php 5 o superior (de preferencia 5.3)
• MySQL 5

Funcionando y correctamente configurado
Imaginemos que tenemos nuestro Htdocs en E:\www y que ese es nuestro htdocs.

Ahora procedamos

• Bajaremos nuestro kohana 3
• Para ello iremos a la siguiente pagina http://v3.kohanaphp.com/download
  Y descargaremos la versión v3.0.0 “renaissance” que es la estable de la rama 3.x
• Lo descomprimimos y veremos dentro una carpeta que se llama kohana, y dentro de ella el framework
• Copiamos esta carpeta kohana a nuestro Htdocs
• Quedaría así E:\www\kohana

Ahora vayamos a nuestro dirección http://localhost/kohana y veremos lo siguiente.

kohana 3

Con ello ya tenemos instalado kohana, fácil verdad? lo que están viendo es el archivo install.php, que no hace otra cosa más que comprobar que tienes un entorno en donde se pueda trabajar con Kohana 3 sin problemas.

En la imagen pudiste ver que me aplicación los obligatorios son los siguientes:
Environment Tests

• PHP Version 5.2.11
• System Directory E:\www\kohana\system\
• Application Directory E:\www\kohana\application\
• Cache Directory E:\www\kohana\application\cache/
• Logs Directory E:\www\kohana\application\logs/
• PCRE UTF-8 Pass
• SPL Enabled Pass
• Reflection Enabled Pass
• Filters Enabled Pass
• Iconv Extension Loaded Pass
• Mbstring Not Overloaded Pass
• URI Determination Pass

Los opcionales son los siguientes:

Optional Tests

• cURL Enabled Kohana requires cURL for the Remote class.
• mcrypt Enabled Pass
• GD Enabled Pass
• PDO Enabled Pass

Como ven hay una opción que está incompleta, es porque no tengo instalada la extensión cURL, la cual al puedo agregar haciendo lo siguiente:

Abriendo el archivo php.ini de mi instalación de Php (en mi casa está en C:\PHP\php.ini)

Y buscar estas líneas

;extension=php_bz2.dll


;extension=php_curl.dll


;extension=php_dba.dll

Y descomentar la que dice curl para que quede así

;extension=php_bz2.dll


extension=php_curl.dll


;extension=php_dba.dll

Reiniciamos el servidor y listo, esto sirve por si nos falta alguna extensión.

Ojo si tenemos algún campo marcado en rojo en Optional Tests, Kohana funcionara aunque en algún momento cuando usemos esa característica fallara(), si hay campos en rojo en la sección de Environment Tests, entonces no funcionara, esto se puede deber a la versión de Php que tengamos instalada, o a los permisos en ciertas carpetas, revisar los permisos de la carpeta Cache Directory E:\www\kohana\application\cache/ o Logs Directory E:\www\kohana\application\logs/.

Ya que no existen, y kohana los crea, entonces si vemos que nos marca error, podemos crearlos a mano y poner les permisos de escritura chmod 676.

Ahora que ya todo funciona borramos el archivo install o lo renombramos (por seguridad elimínalo) y ahora si podemos ver nuestro entorno en funcionamiento
y si vemos el mensaje hello, world! significa que todo es funcionando bien.

Lo que vemos es la ejecución del controlador por default que está en

E:\www\kohana\application\classes\controller\welcome.php ->Este el el controlador por default el cual contiene el siguiente código:

<?php defined('SYSPATH') or die('No direct script access.');

class Controller_Welcome extends Controller {

public function action_index()

{

$this->request->response = 'hello, world!';

}

} // End Welcome

?>

Hasta ahí llegamos hoy, luego les diré como usar bien lo controladores, pero se pueden guiar por nuestro anterior inicio de Codeigniter son parecidos.

Pues como sabrán (x vía Twitter), no tengo pc, por ello no he posteado, y bueno tengo un proyecto entre manos el cual empezare a partir del día de hoy, pensaba hacerlo con Python con el Framework Django o en su caso con Ruby on Rails.

Y la verdad estaba pensando muy seriamente hacerlo con Django pero la verdad estoy con poco tiempo, y después de haber estado usando Kohana en el trabajo me decante por este Framework en su versión 3.0.

El proyecto es un website, pero no daré mas pistas hasta que este casi listo(pronto), lo importante es que se que quiero hacer y tengo con que hacerlo.

kohana 3

Pero el propósito de este post va mas haya les platicare un poco de que se trata este Framework y en medida de lo posible pondré documentación en español la cual esta un poco escasa.

Kohana es un Framework escrito en Php, el cual comenzó siendo un Fork del Framework CodeIgniter, el cual trata de ser mejor que este, esto es en su version 2.3.4

Pero en su nueva versión 3.0 el Framework fue reescrito completamente, agregando mas características importantes, como una mejor implementación de su ORM, se implemento el uso de métodos estáticos para prácticamente todo, para instalarlo se requiere PHP 5 obligatorio, entre otras mejoras.

Además de que a diferencia de Codeigniter la carpeta de la aplicación esta fuera de la del sistema, haciéndolo mas seguro.

Bien ahora a programar, les informare de los avances.

A mi siempre me ha gusto programar directamente sin usar algún tipo de Framework
o algo similar (a excepción del Blog que uso WordPress), sin embargo ahora que estoy viendo como programar el proyecto empecé a buscar opciones que aligerarán mi carga de trabajo, pero a la vez que fuera muy flexible para meter código donde fuera necesario (claro de una manera ordenada).

Entonces empecé a buscar algún Framework que me satisficiera, pensé en Zend, en Smarty, Phpbb, Xtemplate, etc, sin embargo esta dudoso, como que una parte me decía que si y otra que no, entonces conocí a CodeIgniter, un Framework que si bien no es tan conocido como Zend o Symphony, si es muy potente y muy simple de usar y puede llegar a ser tan potente como los dos anteriores.

Ahora bien, me puse a investigar como instalar y como hacer mi !Hello Word!, así que aquí les pongo como le hice y como quedo.

[PASO:1]

Requisitos:

• Tener php 4 o superior instalado
• Base de datos MySQL(soporta otras)

[PASO:2]

• Obtenemos CodeIgniter de la siguiente URL  http://codeigniter.com/download.php
• Lo copiamos dentro de nuestra carpeta raíz de htdocs (en Apache)
• Hay dos carpetas una se llama system y otra user_guide, además de otros archivos

[PASO:3]

• Ahora procederemos a configurar nuestro CodeIgniter
• Primero abrimos el siguiente archivo system/application/config/config.php y buscamos la línea $config['base_url'] = “http://localhost/CodeIgniter/”; en donde pondremos la ruta de nuestra carpeta que acabamos de descomprimir
• Para conectar la base de datos hay que editar el archivo system/application/config/database.php en donde dice

$db['default']['hostname'] = “localhost”;

$db['default']['username'] = “”;

$db['default']['password'] = “”;

$db['default']['database'] = “”;

y Ahi colocamos los valores que usamos para conectarnos a nuestra base de datos.

[PASO:4] Ahora debes de entrar a la url que pusiste y te debe de aparecer el siguiente mensaje.

[PASO:5]
Ahora si entras a system/application veras muchas carpetas, las que nos interesan son las siguientes config, controlles, views y models.
Abrimos el archivo system/application/config/routes.php en donde buscaremos lo siguiente $route['default_controller'] = “welcome”; (esta en la línea 43 aproximadamente) esta la vamos a cambiar por el nombre de nuestro controlador que vamos a usar, su sintaxis es muy simple, debe de ser el nombre del archivo donde haremos el controlador, por ejemplo si nuestro archivo controlador se llamara test.php quedara así $route['default_controller'] = “test”; si el controlador se llamara delfines.php quedaría $route['default_controller'] = “delfines”;
Nota: Es muy importante lo anterior ya que toda la sintaxis que usa CodeIgniter sigue esta estructura
Ya que lo editamos cerramos ya abrimos el controlador, por default esta el controlador welcome, el cual recordemos que estaba por default dentro de routes.php, ahora creamos nuestro controlador con el nombre que deseemos, por ejemplo biblioteca.php, (recuerden cambiar en routes.php $route['default_controller'] = “welcome”; a $route['default_controller'] = “biblioteca”; )
Abrimos nuestro controlador y escribimos lo siguiente.

class Welcome extends Controller {

function Welcome()
{

parent::Controller();

}
function index()
{
echo "Hola Mundo";
}
}

Lo que tenemos en muy simple, creamos una clase la cual extiende de Controller con lo cual obtiene todos los métodos y propiedades de un controlador genérico de CodeIgniter, vemos el método Welcome, el cual es necesario ya que tu constructor local anularia al constructor de la clase padre Controller, por lo tanto necesitamos llamarlo manualmente. en el caso de php5 podemos optar por usar.

function __construct()
{
parent::Controller();
}

Es lo mismo.

Luego tenemos el método index, el cual se ejecuta cuando entremos al index.php(después del método constructor) y le decimos que escriba “Hola mundo”, si bien esto no tiene nada de MVC, es para ver que esta funcionando deberemos entrar a

http://localhost/codeigniter/biblioteca/

Y nos deberá arrojar “Hola Mundo”

Queda pendiente el ejemplo MVC completo, cualquier duda pueden preguntar, recuerden pueden empezar a probar para que vean como funciona.