Kohana A1, es un modulo de kohana el cual nos permite implementar de una forma efectiva, potente y clara, un sistema de autenticación, de una forma fácil y sencilla.

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í:

El framework Kohana PHP, aparte de poseer un interesante y muy completo ORM, tiene otra opción que nos permite mejorar nuestras consultas a la base de datos.

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.

Pues les cuento un preámbulo

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

Pues ya casi no tengo tiempo de escribir, tengo un par de posts en el tintero que no he podido terminar de escribir, es que últimamente ando estudiando bastante por que quiero saber mas jaja, pero bueno el propósito de este post no es quejarme si no platicarles de esto que hace poco me intereso.

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.

Usando Vistas y variables en Kohana PHP Framework

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

En PHP 5 se incluyeron varios métodos mágicos como __construct y __destruct a las clases los cuales no facilitan la forma de programar.

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í.

Este es un post de PHP, ya que si bien es lo que mejor manejo y ademas de que casi no hay posts de PHP en mi blog.

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