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

Una de las cosas que menos me gusta es estar repitiendo código (recordemos -DRY-) entonces, pues cuando deseaba validar un formulario siempre andaba buscando cual opción era la mejor, y hay muchas opciones y son excelentes en lo que hacen, sin embargo todas tenían un punto débil, por ejemplo que no soportaban ajax, es decir terminaban de validar y se seguían (enviaban el formulario), otros me mandaban mensajes de errores de validación en ciertos colores y en cierto lugar que si bien es correcto, a veces en muchos proyectos no va el estilo o simplemente quieren ponerle un alert o similar.

Bajo ese preámbulo y recordando que siempre quise hacer un validado de formularios con Javascript (hace años hice uno chafita con Javascript).

Entonces pensé por que no hacer uno que fuera muy simple de usar y que no fuera obtrusivo, y así fue como desarrolle simpleValidate que es un plugin el cual como su nombre lo dice solo es un validador de formularios y nada mas.

Les presento a:

simpleValidate – Jquery Plugin

A continuación pongo las características.

• Fácil de usar
• Extremadamente Ligero 2kb (minifed)
• Compatible con Jquery 1.5.2
• No requiere CSS especial
• No obtrusivo
• Posibilidad de inyectar algún tipo de alert especial mediante sus settings
• Completamente personalizable
• Soporta expresiones regulares
• Y valida checkboxes

Su uso es muy simple, solo necesitamos de Jquery y del plugin

<script src="jquery.1.5.2.min.js" type="text/javascript"></script>
 <script src="simpleValidate.1.6.min.js" type="text/javascript"></script>

Y ejecutamos el plugin donde indicamos el id del Formulario en cuestión

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
 <title></title>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <script src="jquery.1.5.2.min.js" type="text/javascript"></script>
 <script src="simpleValidate.1.6.min.js" type="text/javascript"></script>
 <script type="text/javascript">
 $(document).ready(function(){
    $("#testForm").simpleValidate();
 });

 </script>
 </head>
 <body>
 <form action="try.php" method="post" id="testForm">
 <label>Name</label>
 <input type="text" name="name" title="valid[Ingrese un nombre valido]" /><hr />
 <label>Ingrese una cantidad valida (tipo numero.decimal(2 digitos))</label>
 <input type="text" name="cantidad" title="valid[regex,Por favor ingrese un numero con o sin decimales únicamente]" data="^([0-9]+.?[0-9]{0,2})$" /><hr />
 <label>Required</label><input type="checkbox"  name="condiciones" value="Required" title="valid[Debes de aceptar los terminos y condiciones]"/>
 <input type="submit" value="Guardar datos"/>
 </form>
 </body>
</html>

Y con esto ya tenemos funcionando el plugin ahora necesitamos indicarle cuales son los campos a validar lo haremos de la siguiente forma.

En cada input que necesitemos, vamos a agregar lo siguiente en el campo (input) que queramos validar

title=”valid[tipo_de_validacion,{params,}]“

Donde los tipos de validación son los siguientes:

• valid[required,mensaje de error] ==> Solo verifica que el campo tenga algún valor y el segundo parametro es lo que mostrara cuando no pase la validación
• valid[email,mensaje de error] => Valida que sea un email valido y si no muestra el mensaje del segundo parametro.
• valid[zip,mensaje de error] => Valida que sea un código postal valido (5 caracteres numéricos) y si no muestra el mensaje del segundo parámetro.
• valid[minlength,mensaje de error,numero_minimo] => Valida que el campo contenga un mínimo de caracteres indicado el el ultimo parámetro
• valid[maxlength,mensaje de error,numero_maximo] => Valida que el campo contenga un máximo de caracteres indicado el el ultimo parámetro
• valid[regex,mensaje de error] => Este forma de validación necesita un parámetro data dentro del input donde venga especificada la expresión regular a validar y si no pasa lanza el error.
• valid[ensaje de error] =>Este solo es aplicable a los checkboxes y solo contiene como argumento el error que mostrara cuando el checkbox no este marcado

Los valores que se pueden personalizar dentro del plugin son los siguientes.

$(document).ready(function(){

   $("#testForm").simpleValidate({
     text: Array("El campo"," es obligatorio"),
     email: "Ingrese un email valido",
     zip: "Ingrese un codigo postal valido",
     min: Array(5,"Ingrese al menos ", "caracteres"),
     max: Array(10,"Ingrese maximo", "caracteres"),
     checkmessage:'Es necesario marcar el campo',
     field: 'valid',
     msg: function(msg){
      alert(msg);
     }
   });

 });

Donde

• text: Es un array que contiene dos textos que mostrara en el error cuando un campo sea required de la forma (texto1+ nombre_campo+texto2)
• email: Es el error que mostrara cuando un email este invalido
• zip: Error cuando el codigo postal este mal
• min: array en donde viene el error a mostrar y el numero de elementos a validar por default
• max: array en donde viene el error a mostrar y el numero de elementos a validar por default
• checkmessage: Este es el mensaje que mostrara cuando se genere un error al no estar validado un checkbox
• field: es la clave para validar los campos, es decir cuando buscamos title=”valid[etc]” valid es el contenido del title del campo si le ponemos otro, podemos usar dentro de title lo que le hayamos puesto en esta opcion evitando asi posibles colisiones de palabras que esten usando otros plugins.
• msg: esta es una funcion, en donde solo estamos mandando un alert para mostrar el error, sin embargo si posees algun otro plugin como Sexyalertbox o similar puedes meterlos dentro de esta funcion asi cuando se lanza el error mostrara el cuadro de dialogo de la forma como deses (por ejemplo dentro de un Sexyalertbox).

Es importante recalcar que estos parámetros son cambiados por los mensajes establecidos dentro del propio input, así que casi nunca se cambian estos valores.

Además el plugin recibe un parámetro mas el cual es una función anónima (según yo seria un closoure ), la cual se ejecutara cuando termine la validación, es decir si al terminar tu validación deseas que en vez de enviar el formulario normalmente, lo envié por XMLHttpRequest(aka Ajax), esta función al estar agregada hace que tu tomes la decisión de que hacer una vez terminada la validación y pasada obviamente.

Ejemplo complejo, usando JAlert para mostrar los errores (http://www.anieto2k.com/2008/12/31/jquery-alert-dialogs-reemplazo-para-alert-prompt-y-confirm/)

$(document).ready(function(){

   $("#testForm").simpleValidate(
     {
       msg: function(msg){
         jAlert(msg, 'Alert Dialog');
          }
     },
     function (){
       $.post('/account/',
              $(this).serialize(),
              function( Response ){
                 jAlert("Sus datos se han enviado via Ajax");
              });
     }
   );

 });

El ejemplo anterior, hace una validación pero los mensaje de error los muestra de una forma diferente usando otro plugin (JAlert en este caso) además de eso al terminar la validación envía todos los datos del formulario por post usando ajax y cuando recibe respuesta manda un alert.

Como vemos es muy fácil, poderoso y practico de usar.

No se si me explique bien pero estar posteando por la noche da bastante sueño, ojala y les haya gustado mi plugin y sobre todo ojala y les sea útil.

Para bajarlo y ver las actualizaciones aquí dejo la información:

simpleValidate Version 1.6 Beta

GitHub: https://github.com/Ajaxman/simpleValidate (Fork-ME =) )
Plugins Jquery: http://plugins.jquery.com/project/simpleValidate

Cualquier felicitación, duda, comentario, sugerencia, correción , Donación =), con gusto estoy para atenderla, la licencia es GPL =)

Hasta el próximo post

Resulta que via Twitter, me entere sobre una forma de programar mediante pruebas unitarias en PHP mediante PHPUnit, tenia rato que quería saber como hacer eso y creo que si le estoy entendiendo bien, de ahi aprendí que esto se llama TDD(Test-Driven Development) y bueno esto estará en otro post, la cuestión es que me intereso bastante, al final llegue hasta el tema de la ingeniería del software.

Si bien yo no soy ingeniero (Soy Técnico Profesional), me gusta bastante este tema, resulta que para ser un buen programador es muy bueno aprender a implementar la ingeniería del software en el desarrollo del mismo, para nuestro beneficio.

Si bien no es una técnica tipo AJAX o similar, es algo muy importante a considerar ya que aplicando esto no solo te dedicas a programar-codear un script, si no desarrollas una aplicación completa mediante ciertos pasos bien definidos.

Etapas del proceso de la implementación de la Ingeniería del Software.

• Análisis de requerimientos
• Especificación
• Arquitectura del Software
• Programación
• Prueba
• Documentación
• Mantenimiento

Además de lo anterior también hay varios modelos ó paradigmas para implementar dicha Ingeniería del Software, algunos de los mas usados son los siguientes.

• Modelo en cascada o Clásico (modelo tradicional)
• Modelo de prototipos
• Modelo en espiral (modelo evolutivo)
• Desarrollo por etapas
• Desarrollo iterativo y creciente o Iterativo e Incremental
• RAD (Rapid Application Development)
• Desarrollo concurrente
• Proceso Unificado
• RUP (Proceso Unificado de Rational)

Claro dirán y todo esto para me sirve, pues para que programes mucho mejor, ya que usando todo esto, como mencione anteriormente no solo escribirás código, si no lo que haces serán soluciones completas, documentadas y seguras, además de que podrás usar los patrones de diseño para optimizar tu código, y bueno muchas cosas de este tipo.

Como verán no soy un experto en esto de la Ingeniería del Software, pero el propósito de este post era darles un preámbulo sobre este tema el cual como mencione se me hace muy interesante y creo que al implementarlo cuando usamos PHP podrá beneficiarnos a nosotros como programadores, a los clientes y a los jefes, bueno en general a todos, como dije antes tiene muchas ventajas.

Espero pronto sacar algún otro post sobre PHP y TDD

Mas información sobre esto en la Wikipedia | Ingeniería de software

Cuando trabajamos con el framework Kohana PHP, una parte muy importante son las vistas, ya que son unos de los pilares del MVC, el cual es altamente utilizado por el framework.

Las vistas son archivos con extensión .php las cuales están pensadas para mostrar contenido, y también existe un modulo que nos permite utilizar plantillas smarty, pero hoy no tocaremos ese tema, estos archivos estarán alojados en ruta_de_instalacion_/application/views/ y pueden contener código Php, aunque la idea es de que dicho código sea lo más pequeño  y simple posible, y sea solo para mostrar resultados por ejemplo de una consulta.

Como vimos en la segunda entrega de este manual, para mostrar algo es imprescindible usar una vista, he invocarla desde nuestro controlador, mediante el método estatico View::factory.

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

class Controller_Tienda extends Controller {

 public function action_index()
 {

 $vista = View::factory('template');
 $this->request->response = $vista;

 }

} // End Tienda

Ahora bien como es de suponerse, podemos enviar datos a nuestra vista para poder mostrarlos en ella, esto nos sirve para por ejemplo enviar un array a nuestra vista y recórrelo para mostrar algún resultado de una consulta.

Hay varias formas de enviar datos a nuestra vista, veamos cuales son:

Mediante Bind o Set, de esta forma podemos pasar una variable, sin importar su valor a nuestra vista y puede ser un string, entero, un array o un objeto y se encadena a nuestro método estático de View::factory, cabe señalar que la única diferencia entre bind y set es que bind asigna la variable por referencia, en lo personal casi no la uso, ya que set satisface mis tareas.

La otra opción es mediante variables globales y para ellos se pueden utilizar dos métodos estáticos (uno se usa como set y otro como bind), los cuales son View::set_global y View::bind_global, la diferencia con las dos formas anteriores es que con estos métodos se crean variables globales que pueden ser usadas por cualquier vista, sin tener que especificar alguna vista en especifico.

Ahora veamos cómo usarlas, como nota, solo voy a mostrar set, ya que como indique no he usado ni he necesitado usar bind, si quieren ver el funcionamiento de bien, simplemente reemplazan set por bien y listo XD.

Usando método set.

controlador.php

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

class Controller_Tienda extends Controller {

 public function action_index()
 {

 $user = 'Ajaxman';
 $vista = View::factory('template')->set('username',$user);// Asignamos $user a una nueva variable $username;
 /* tambien podemos enviar muchas de la siguiente forma
 *
 * $vista = View::factory('template')
 ->set('username',$user)
 ->set('edad','18 Años')
 ->set('pais','mexico'); Y asi podemos seguir enviando mas variables a dicha vista
 */

 $this->request->response = $vista;
 }

} // End Tienda

Vista template.php

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
 <title>Vista para Kohana PHP</title>
</head>
<body>
<h1>Bienvenido <?php echo $username; ?><h1>
 <p>Hola esta es una vista para Kohana PHP</p>
</body>
</html>

Lo anterior mostraría Bienvenido Ajaxman, y de esta forma pueden mandar un array o un objeto(resultado de una consulta), recórrelo mediante foreach y mostrar el resultado del mismo.

Ahora bien para las variables globales solo hay que definirlas con el siguiente método estático y podemos usarlas en cualquier vista que carguemos.

Y algo que se me olvidaba pero igual es muy importante el método estático View::factory se puede usar también dentro de la vista, pero debemos usar un método render para que se envié la salida en pantalla, en el código que sigue veremos cómo usarlo.

controlador.php

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

class Controller_Tienda extends Controller {

 public function action_index()
 {

 $user = 'Ajaxman';

 View::set_global('titulo','Bienvenido '.$user);
 View::set_global('keywords','Php,Kohana,Framework, prueba');

 $vista = View::factory('template'); //Notese que no enviamos nada ya que son variables globales

 $this->request->response = $vista;
 }

} // End Tienda

Vista template.php

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
 <title><php echo $titulo; ?></title>
 <meta name="keywords" content="<?php echo $keywords; ?>">
</head>
<body>
<div>
 <div>
 <?php echo View::factory("head_display")->render();?>
 <!-- Con lo anterior estamos invocando a una vista -->
 </div>
</div>
</body>
</html>

Vista header_display.php

<h1><?php echo $titulo; ?> </h1>
<a href="/logout">Cerrar sesión</a>

Y listo con esto ya estaríamos trabajando con las vistas, ya saben si tienen dudas pueden dejar un comentario, si me tardo en responder no se alteren es que a veces ando muy ocupado, pero siempre respondo.

En la siguiente entrega veremos más a fondo los ORMS para después hacer un ejemplo ya útil con todo lo aprendido.

Y bien si no sabes que son estos métodos, aquí los veremos para que te des una idea de como usarlos y para que sirven.

Imaginemos el siguiente código que nos servirá para mostrar los datos de un usuario

<?php
class User {
  private $name;
  private $link;
  private $pais;

  public function setData($name = '', $link = '', $pais = '')
  {
    $this->name = $name;
    $this->link = $link;
    $this->pais = $pais;
  }

  public function getData()
  {
    echo "Nombre::".$this->name."n";
    echo "Link::".$this->link."n";
    echo "Pais::".$this->pais."n";
  }
}

$user = new User();
$user->setData('Ajaxman','http://www.ajaxman.net','Mexico'); // Lease User,Link,Pais
$user->getData();
?>

Hasta ahí todo bien,sin embargo si vemos el código notamos que tenemos el método setData unicamente para asignar datos, esto se podría hacer de esta forma

<?php
$user = new User('Ajaxman','http://www.ajaxman.net','Mexico');// Lease User,Link,Pais
$user->getData();
?>

Y si queremos que funcione simplemente hay que llamar a un método igual que el nombre d e la clase de la siguiente forma.

<?php
class User {
  private $name;
  private $link;
  private $pais;

  public function User($name = '', $link = '', $pais = '')
  {
    $this->name = $name;
    $this->link = $link;
    $this->pais = $pais;
  }

  public function getData()
  {
    echo "Nombre::".$this->name."n";
    echo "Link::".$this->link."n";
    echo "Pais::".$this->pais."n";
  }
}

?>

Ahora bien, desde que surgió PHP5 se puede usar métodos mágicos, uno de ellos es __construct el cual se ejecuta cuando se inicia la carga de la clase, la ventaja es que siempre se debe de llamar así y no tendrás que estar poniendo métodos con el mismo nombre de la clase y quedaría así.

<?php
class User {
  private $name;
  private $link;
  private $pais;
public function __construct($name = '', $link = '', $pais = '')
  {
    $this->name = $name;
    $this->link = $link;
    $this->pais = $pais;
  }

  public function getData()
  {
    echo "Nombre::".$this->name."n";
    echo "Link::".$this->link."n";
    echo "Pais::".$this->pais."n";
  }
}
?>

Se podría decir que tiene poca utilidad, sin embargo en diversas ocasiones verán que usar el método __construct les resolverá mucho problemas.

Recuerden __construct se ejecuta automáticamente al instancia la clase, osea $obj = new Class();, si recuerdan los métodos estáticos, en el post anterior, recordaran que nunca se instancia, por lo cual no funciona en los métodos estáticos.

El otro método se llama __destruct y funciona a la inversa, se ejecuta cuando se termina la clase, y este puede usarse para destruir variables o valores que ya no vayamos a usar.

Personalmente yo no había usado nunca __destruct(), hasta hace un par de días cuando debía hacer lo siguiente.

Movimos un website montado en Joomla a otro server y no funcionaba una lista de noticias, todo estaba bien, entonces revise el código y quise hacer un debug, pensé en usar un var_dump(); pero no funciono, entonces se me ocurrió que para evaluar esa variable debía usar __destruct() ya que se ejecuta cuando termina la clase, así que no debería de haber problemas y efectivamente todo funciono bien y pude depurar mis variables.

Claro es un uso que le encontré, pero puede haber muchos mas, creo que me extendí bastante, pero es para dar una idea a personas que no saben aun que onda con los métodos constructores y destructores de la clase.

Nota: Nos vemos el el Campus Party México 2010

Bien empecemos por el principio.

Cuando estamos programando a veces no deseamos estar instanciando una clase, ya que puede que el método sea algo que simplemente devuelva algún valor, por ejemplo un parser o similar, entonces se vuelve tedioso estar haciendo, $obj =new Clase();, la solución para esto es usar un método estático.

Los métodos estáticos no necesitan ser instanciandos ademas de que son ligeramente mas rápido que los métodos normales, si bien esto no significa que debamos de dejar de usar los métodos normales, estos pueden ser muy útiles para hacer por ejemplo una especie de catalogo de funciones, aunque claro su uso depende de cada quien.

Veamos una clase con un método normal y posteriormente como seria si fuera estático.

<?php
 //Clase
class Tools{
  /// Metodo normal
  public function today($paramString = '')
  {
    setlocale(LC_ALL,'es_MX');
    $date = $paramString.utf8_encode(strftime("%A %d de %B del %Y"));
    return $date;
  }
}
$Helps = new Tools();
echo $Helps->today("Hoy es "); //Salida  Hoy es jueves 29 de julio del 2010
?>

Ahora veamos como se haría usando un método estático

<?php
 //Clase
class Tools{

 /// Metodo estatico
 public static function today($paramString = '')
 {
   setlocale(LC_ALL,'es_MX');
   $date = $paramString.utf8_encode(strftime("%A %d de %B del %Y"));
   return $date;
 }
}

echo Tools::today("Hoy es "); //Salida  Hoy es jueves 29 de julio del 2010

?>

Como podemos ver es mas simple llamarlo, claro que como menciono hay algunas cosas a tener en cuenta, las mas importantes son:

• No existen los métodos “mágicos” __construct ni __destruct, puesto que jamas se instancia la clase, en su lugar se puede invocar otro método estático que asigne, las variables
• No existe $this, se debe usar en su lugar self, aunque las variables tienen que ser igualmente estáticas, esto se aplica tanto en variables como métodos

Haremos un ejemplo un poco mas complejo para ver como usar self en vez de this

<?php
/**
*
* Nota
* Este ejemplo funciona solo deben de copiar y pegar el codigo para probar
*/

 //Clase
class Tools
{
 /// Variable estatica
 public static $pais = 'Mexico';

 //Metodo estatico
 public static function setPais($pais = 'Mexico')
 {
   //Set de el pais
   /**
   * Notese la sintaxis self::$Variable
   */
   self::$pais = $pais;
 }

 /// Metodo estatico
 public static function today($paramString = '',$pais=FALSE)
 {
   setlocale(LC_ALL,'es_MX');
   $date = $paramString.utf8_encode(strftime("%A %d de %B del %Y"));
   if($pais != FALSE)
   {
   $date .= ' en '.self::$pais; //Notese la forma de obtener la variable
   }
   return $date;
 }
}

echo Tools::$pais; //Salida Mexico
Tools::setPais('Brasil');
echo Tools::$pais; //Salida Brasil
echo Tools::today("Hoy es "); //Salida  Hoy es jueves 29 de julio del 2010

Tools::$pais = 'Canada'; //Nota tambien es posible asignar valores de esta forma

echo Tools::today("Hoy es ",TRUE); //Salida Hoy es jueves 29 de julio del 2010 en Canda

?>

Con ello podríamos resumir que this es similar a self solo que hay que tratarlo con cuidado, y usar lo siguiente cuando se intenta invocar esto desde nuestra clase:

• self::$var en vez de $this->var
• self::function() en vez de $this->function()

Bueno creo que me excedí un poco con este post, pero lo importante es que creo que si quedado claro, dudas ya saben a en lo comentarios.

Ya sabemos cómo instalarlo ahora procedamos a trabajar.

Como ejemplo haremos una aplicación que liste productos, maneje altas y bajas de una tienda con un Front-End y un Back-End.

Para empezar necesitamos lo siguiente

*Requisitos

• Apache (ModRewrite instalado)
• PHP 5.2
• MySQL
• Kohana 3 Framework

*Opcionales

• SQlFront
• Phpmyadmin
• Editor de código como Webuilder (Luego veremos cómo hacer casi lo mismo con Netbeans un IDE completo)

Haremos una nueva instalación de Kohana, en nuestra PC que será nuestro servidor (localhost) copiamos el contenido del framework a una carpeta que se llame tienda (en mi caso E:/www/tienda/)

Y acceso a mi website escribiendo http://localhost/tienda/  y ahí veremos nuestro install ahora navegamos hasta  E:/www/tienda/ y ahí estará ese archivo, lo borramos (si todo salió ok, si no corregir y verificar hasta que todo este en verde)

Esta vez vamos empezar por los datos para que al final hagamos el website.
Necesitamos una tabla de productos usaremos el siguiente SQL con los datos básicos de cada producto.

Como regla general hay que tener en cuenta que la base de datos debe de tener las siguientes características:

• Nombre de la tabla en Plural (“productos”)
• Nombre de los campos en Singular (“descripción”)
• La clave principal se llamara id, en minúsculas (Se puede poner otra cosa pero habría que editar nuestra clase que manejara esa tabla por ello lo dejaremos como id)

CREATE TABLE <code>productos</code> (
 <code>id</code> int(11) NOT NULL AUTO_INCREMENT,
 <code>nombre</code> varchar(255) DEFAULT NULL,
 <code>descripcion</code> text,
 <code>activo</code> int(1) DEFAULT '1',
 PRIMARY KEY (<code>id</code>)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

Agregamos el siguiente contenido

INSERT INTO <code>productos</code> VALUES (1,'Agua Debian','Agua Embotellada 1 Lts Marca Debian',1);
INSERT INTO <code>productos</code> VALUES (2,'Refresco Php','Refresco 2 Lts Marca Php Sabor Uva',1);
INSERT INTO <code>productos</code> VALUES (3,'Paleta Ubuntu','Paleta Ubuntu sabor Cafe 1pza',1);

Ahora editaremos nuestro bootstrap   (E:/www/tienda/application/bootstrap.php)
Buscaremos el configuración del init y escribiremos los siguiente

<?php
//...
//...
Kohana::init(array(
 'base_url'   => 'http://localhost/tienda/',//Aqui le decimos cual será la url del proyecto
 'index_file' => FALSE, //                  //Le indicamos que usara urls amigables (sin .php)
));
...
...
//Buscaremos el Route en el mismo script y lo editaremos
..
...
Route::set('default', '(<controller>(/<action>(/<id>)))')
 ->defaults(array(
 'controller' => 'tienda',  //Nombre del controlador por default
 'action'     => 'index',   //Acción por default (lo dejamos en index)
 ));

Lo guardamos (:wq XD ) y vamos a ver que en la raíz del proyecto hay una archivo llamado example.htaccess lo renombramos a .htaccess que será el que manejara las urls amigables para no tener el tienda/index.php/controlador ser tienda/controlador.

Les recomiendo comentar la siguiente línea para no tener problemas en las direcciones

# Installation directory
#RewriteBase /kohana/ pueden poner /tienda y va a funcionar pero es mejor quitarla
# ya que con ello evitaremos problemas cuando estemos cambiando de un servidor local
# a un servidor de producción

Lo guardamos (:wq XD )  Y ahora vayamos a crear nuestro controlador.

Entramos a E:/www/tienda/application/classes/controller y creamos tienda.php
Y creamos nuestro controlador

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

class Controller_Tienda extends Controller {
/**
 * Controller_Tienda Es el controlador por default recuerden el bootstrap
 * todos los controladores llevan esta sintaxis, Controller_<Nombre_del_controlador>
 *
 *  action_index() Es la acción por default (ejemplo http://localhost/tienda/accion)
 *  si no se especifica en la url (ejemplo http://localhost/tienda/accion, se usara
 *  index por default y la sintaxis es action_<nombre_de_la_accion>
 */
 public function action_index()
 {
 echo "Programando ....";
 }

} // End Tienda

Lo guardamos (:wq XD ) y naveguemos a http://localhost/tienda/ veremos que dirá “Programando ….”, si no vemos eso es que algo hicimos mal y hay que volver a ver en donde nos fallo

Ahora bien, procederemos a conectar la base de datos, para ello vamos a editar el archivo de configuración de la base de datos E:/www/tienda/modules/database/config/database.php

Y agregaremos la conexión mysql, pueden usar PDO(pero prefiero hacerlo como ejemplo de forma tradicional)

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

return array
(
 'default' => array
 (
 'type'       => 'mysql',
 'connection' => array(
 /**
 * The following options are available for MySQL:
 *
 * string   hostname
 * string   username
 * string   password
 * boolean  persistent
 * string   database
 *
 * Ports and sockets may be appended to the hostname.
 */
 'hostname'   => 'localhost',  ////Usa los datos de tu conexión MYSQL
 'username'   => "root",       ////Usa los datos de tu conexión MYSQL
 'password'   => "localhost",  ////Usa los datos de tu conexión MYSQL
 'persistent' => FALSE,        ////Opcional
 'database'   => 'kh_tienda',  ////Usa los datos de tu conexión MYSQL
 ),
 'table_prefix' => '',
 'charset'      => 'utf8',
 'caching'      => FALSE,
 'profiling'    => TRUE,
 ),
 //Aquí continúa con el PDO, ese de momento no hay que tocarlo
 //..
 //....
 //......
)

Ahora que ya lo tenemos vamos a decirle a kohana que agregue los módulos de base de datos y orm, necesarios para que funcione nuestro ejemplo, para ello hay que editar otra vez nuestro archivo bootstrap ya descomentar los módulos de manera que quede así.

<?php
//..
//....
/**
 * 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
 'database'   => MODPATH.'database',   // Database access
 // 'image'      => MODPATH.'image',      // Image manipulation
 'orm'        => MODPATH.'orm',        // Object Relationship Mapping
 // 'pagination' => MODPATH.'pagination', // Paging of results
 // 'userguide'  => MODPATH.'userguide',  // User guide and API documentation
 ));

Lo guardamos y ahora hay que agregar el Modelo ORM que manejara la base de datos, para ello hay que crear un archivo llamado con el mismo nombre de nuestra tabla,

En E:/www/tienda/application/classes/model hay que agregar el modelo productos.php si no existe esta carpeta model hay que crearla.

En el modelo agregaremos el siguiente contenido

<?php defined('SYSPATH') or die('No direct script access.');
/**
 * Description of Model_Productos
 *
 * @author Javier
 */
 //// Importante el nombre de nuestra  clase debe de llevar la siguiente sintaxis
 ////  Model_<Nombre_de_la_tabla>

class Model_Productos extends ORM {

 protected $_table_names_plural = false;
 /// Ojo con esto este campo es true por default pero hace que Kohana maneje a su gusto
 /// Los nombres de la tablas agregándole "s" o "es" a las mismas
 /// Es decir trata de pluralizar el nombre automáticamente, puede que sea muy útil
 /// Pero en lo personal no me gusta prefiero yo usar lo nombres a mi gusto
 /// Por ello con esta indicación le decimos a kohana:
 /// "Deja el nombre de la tabla como se llama la clase y no le hagas cambios"


}

Y bien ya casi terminamos, ahora hagamos una prueba para ver si todo ha salido bien.

Vayamos a nuestro controlador y agreguemos el siguiente código

<?php
 //..
 //.....
 public function action_index()
 {
 //echo "Programando ....";
 $productos = ORM::factory('productos')->find_all();
 foreach($productos as $producto)
 {
 echo "[[Producto=".$producto->descripcion."]]";
 }

 }

Ojo no es MVC todavía pero es para pruebas, expliquemos el código:
Para hacer una consulta al ORM, usaremos el siguiente código (se puede de varias formas, esta es la mas fácil)
$productos = ORM::factory(‘<Nombre_del_Modelo>’)->otros_metodos()
Donde

• $productos: es la variable donde se almacenara nuestro contenido de la consulta
• ORM::factory(): Es el método estático para usar el ORM y el parámetro será el nombre del modelo
• otros_metodos: Es donde le podemos agregar métodos where, join, order_by, find,find_all, etc., digamos como una especie de parámetros del query, algo importante a destacar es
  • si usamos ->find() Kohana hará automáticamente un limit 1
  • Si usamos ->find_all() Kohana traerá todos los resultados
• Hay muchos parámetros poco a poco los iremos viendo.

Por último con el foreach recorremos nuestro objeto y mostramos sus propiedades las cuales son las mismas que los campos de la tabla y listo.

Guardamos nuestro controlador y al entrar a http://localhost/tienda/, nos debe aparecer algo como lo siguiente:

[[Producto=Agua Embotellada 1 Lts Marca Debian]][[Producto=Refresco 2 Lts Marca Php Sabor Uva]][[Producto=Paleta Ubuntu sabor Cafe 1pza]]

Con eso terminamos la parte 1, Como verán siento que fue bastante rápido, que quizá se me hayan quedado cosas, sin escribir, si notan algún error, o algo no funciona pueden comentarlo.

Hasta hoy apenas me vengo enterando de esto, les platico rápidamente.

El 15 de Mayo de este año (2010), se llevara a cabo en Londres, una conferencia de desarrolladores del Framework Kohana:
KOnference – The London Kohana Conference 2010.

La verdad estoy con unas tremendas ganas de ir sin embargo dudo mucho que pueda, por que no creo que en la chamba me paguen la ida y pues ahorita no hay mucho presupuesto.

Me puse ha investigar y aquí les dejo la agenda, la cual se ve va a estar bien interesante.

• Inicio || Duración || Sesión
• 10:30 || 25″ || Registration
• 10:55 || 5″ || Welcome
• 11:00 || 55″ || Building Swiftly with Kohana 3 – KO3
• 11:55 || 40″ || Designing for Scalability with HMVC – KO3
• 12:35 || 15″ || Break
• 12:50 || 35″ || Migrating existing codebases to Kohana – KO2
• 13:25 || 30″ || Advanced ORM – theory and practice – KO3
• 13:55 || 30″ || Lunch
• 14:25 || 30″ || Discovery Session
• 14:55 || 20″ || Rapid site prototyping – KO2
• 15:15 || 30″ || Templating with Twig – KO3
• 15:45 || 30″ || Break
• 16:15 || 25″ || An introduction to using Gearman with Kohana – KO2
• 16:40 || 20″ || Deploying Kohana on a large scale application – KO2
• 17:00 || 10″ || Mukuru.com – Kohana meets E-Commerce
• 17:10 || N/A- || Beers & dinner

Como ven habra platicas tanto de Ko3 como de Ko2, el unico pero que veo es que sera hasta Londres y pues es algo complicado ir.

Ojala y leyeran este post y pronto hagan una aunque sea en EUA.

Al parecer el costo sera de 15 GBP (Libras) (unos $300 MXN), el pago se realiza mediante Paypal y el registro sera a las 10:30 (Hora Local), recomiendan llegar a tiempo ya que como ellos dicen hay mucho que ver y el tiempo esta contado.

Pues ojala y eventos como este le den mas presencia a este increible framework y lo ayuden a crecer, por que se lo merece.

Mas info en los siguientes Links:
KOnference – The London Kohana Conference 2010

KOnference – The London Kohana Conference 2010 Calendar

El mapeo objeto-relacional u ORM (Object-Relational Mapping), una técnica de programación para convertir datos entre el sistema de tipos utilizado en un lenguaje de programación orientado a objetos y el utilizado en una base de datos relacional. En la práctica esto crea una base de datos orientada a objetos virtual, sobre la base de datos relacional. Wikipedia

Ose nos permite “pasar” una base de datos a programación orientada objetos, es decir tu solo te encargas de configurar tu conexión y mediante métodos puedes hacer los querys que quieras, y todo son objetos.

Existen muchos ORMS, para diferentes lenguajes de programación, pero obviamente nos enfocaremos a Php, y según se (no estoy 100% seguro) pero los ORMS están basados en Hibérnate de Java se supone que fue como el primer ORM.

En Php tenemos los siguientes ORMS:

• Doctrine
• Propel
• Kohana ORM
• Bender-modeler (Este es de un amigo, aunque este es muy completo y va mas allá)
• Junction PHP
• PHP Object Generator
• ADOdb Active Record
• EZPDO
• DB_DataObject
• Entre otras

Yo no he visto como trabajan cada una y se dé muy buenas fuentes que las mejores estan entre Doctrine y Propel.

Claro que depende de que desees hacer, de hecho aun no he probado bender-modeler pero por lo que veo es muy completa (Y no es comercial he) ya que como dije va mas allá ya que te genera los modelos que usaras en tu bd automáticamente (incluidos getters y setter).

Voy a mostrar a que me refiero con todo esto del ORM desde la vista de Kohana ORM ya que es donde he trabajado y es muy fácil.

Antes que nada quiero aclarar que son solo ejemplos, prometo que después de esto seguirá nuestra primer MVC con base datos, ORMS y todo, esto solo es para que se den una idea de que hablo cuando digo que esta buenos los ORM´s.

Para empezar solo necesitamos crear nuestra tabla (p.ejem. ‘usuarios’), y crear un modelo con la siguiente sintaxis.

usuarios.php

<?php

class Model_Usuarios extends ORM {

}

?>

Lo único que debemos de cambiar es Model_Usuarios donde Usuarios es el nombre de nuestra tabla y listo.

Y ahora veremos la diferencia

<?php

//Anterior
$resultado = mysql_query("select * from usuarios",$conecct);

//en ORM
$resultado = ORM::factory('usuarios')->find_all();

?>

Y además el resultado es un objeto no un array, aunque si deseamos usar array agregamos as_array() y listo y por ejemplo si necesitamos ver los usuarios que tuvieron 10 accesos sería algo así.

<?php

//Esta es una forma
 $resultado = ORM::factory('usuarios')->where('accesos','=',10)->find_all();

 //También se puede separar el código para que se a mas fácil leer
 $resultado = ORM::factory('usuarios')
 ->where('accesos','=',10)
 ->find_all();
?>

Como puedes ver es muy fácil de usar, y usa el patrón de diseño Factory para acceder a los modelos(tablas), y luego le agregas os métodos, where, orderby, limit, etc.

Claro y pensaras ¿y el modelo solo ese es su contenido, un par de líneas? claro que no, pero ese es más avanzado, podemos hacer joins y demás, pero vayamos por partes, en la siguiente entrega veremos un ejemplo real de una aplicación web en kohana con MVC y una base de datos.