Pues otra vez aca posteando mucho trabajo y poco tiempo para postear jaja como siempre.

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

Taller:

“Desarrollo de Aplicaciones Web con Kohana Framework”

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

Requisitos:

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

PHP es un lenguaje con el cual podemos usar herramientas avanzadas de desarrollo, algunas de estas herramientas son los patrones de diseño (Design Patterns),regularmente cuando empezamos a adentrarnos a esto de los patrones de diseño, uno de los primeros patrones que empezamos a usar es el patrón singleton, el cual garantiza un único acceso a cierto clase como una base de datos la implementación que yo uso/usaba es la siguiente:

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

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

	private static $instance;

	private function __construct(){	}

	private function __clone(){ }

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

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

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

	protected $database;	

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

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

//Uso

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

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

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

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

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

Kohana PHP, es el framework que como bien saben me gusta mucho por muchas cosas, y en esta ocasión el conocer sobre kohana me ha dado una nueva experiencia, en este caso se trató de dar una platica “rápida” vía streaming a programadores  PHP, principalmente de Colombia aunque claro estaba dirigida para todo el que quisiera.

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

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

Las urls amigables son indispensables en el desarrollo de aplicaciones web, y con PHP no supone mayor inconveniente el implementarlas salvo configurar bien el servidor (Apache + ModRewrite, Ngix, Lighttp, IIS).

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

Si nuestra url es asi:

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

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

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

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

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

var_dump($_SERVER['PATH_INFO']);

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

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

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

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

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

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

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

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

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.

Kohana PHP Framework, trae un ORM (ver más sobre ORM’s), sencillo pero poderoso, sencillo por que es muy fácil de usar y poderoso por que podemos hacer casi cualquier cosa con dicho ORM.

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

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

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

Haciendo una simple consulta.

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

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

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

//Consulta ORM

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

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

PROBLEMA: Consultar la tabla mediante un id único

$id = 5; //id unico

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

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

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

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

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

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

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