Sistema de Identificación simple en Laravel 4

Los sistemas de identificación son la primera capa de seguridad de nuestras aplicaciones, permitiendo autenticar a un usuario mediante sus credenciales y de este modo poder restringir el acceso o la realización de acciones no deseadas. De éste podemos derivar el control de acceso por grupos, permisos especiales y/o condiciones únicas dependiendo de la acción que se desea realizar. Un sistema de identificación puede ser bastante simple como muy complejo, y todo dependerá de las funcionalidades y requisitos que nos demande nuestro proyecto.

Laravel 4 nos facilita enormemente la realización de esta tarea. El framwerok de por si incluye un set de herramientas de seguridad las cuales nos permitirán tener en segundos un sistema de autenticación funcionando. En esta entrada también trataré de temas como las rutas, migraciones, realizar seeding de datos, creación de vistas utilizando Blade y otras pequeñas cosas más.

Veamos como ocupar esas herramientas para lograr nuestro objetivo.

ÍNDICE

• Como lo vamos a hacer
• Proyecto en GitHub
• El modelo usuario
• Configurando la autentificación
• Configurando nuestra base de datos
• Creando la tabla ‘usuarios’
• Alimentando la tabla ‘usuarios’
• Controlador de autentificación
• Definiendo la rutas
• Definiendo algunos filtros
• Creando las vistas
• Conclusiones

# COMO LO VAMOS A HACER

En primera instancia vamos a tener una lista de usuarios, los cuales simplemente tendrán un correo electrónico, un nick y una contraseña. El sistema verificará el e-mail y contraseña ingresada por el usuario en contra de la base de datos y finalmente si las credenciales son correctas el usuario podrá ingresar.

Para ellos vamos a necesitar un modelo que contenga al usuario, un controlador que maneje el proceso de identificación y tres vistas, una como base, una para la identificación y otra para el sector privado del usuario.

# PROYECTO EN GITHUB

Antes de empezar, pueden descargar este proyecto desde GitHub, de ese modo pueden revisar los archivos de manera local. En esa misma página hay unos pequeños pasos que deben seguir antes de poder utilizar el proyecto.

# EL MODELO USUARIO

Laravel por defecto viene con un modelo de usuario llamado Model ubicado en ‘app/models’. Lo vamos a utilizar tal cual como viene, y no realizaremos ningún tipo de cambio en él.

# CONFIGURANDO LA AUTENTIFICACIÓN

El framework viene con una herramienta interna para poder autenticar usuarios. Si siguen esta guía paso a paso no hay necesidad de modificar la configuración de ésta. Por el contrario, si desean por ejemplo ocupar otro modelo para los usuarios o cambiar la tabla de donde obtienen los datos les recomiendo leer mi entrada sobre la configuración de Laravel 4.

# CONFIGURANDO NUESTRA BASE DE DATOS

En primera instancia debemos permitir que Laravel se puede conectar a nuestra base de datos, y de ese modo poder hacer la verificación de datos. Para ello debemos dirigirnos a la carpeta ‘app/config’ y abrir el archivo ‘database.php’. En él debemos definir que conexión vamos a utilizar y configurar los parámetros de ésta.

En este caso vamos a utilizar la archiconocida base de datos MySQL, por lo que deben indicar en el campo ‘default’ que van a ocupar esa conexión:

'default' => 'mysql',

Ahora deben configurar la conexión de acuerdo a los datos de su servidor – por lo general basta el usuario,  contraseña y nombre de la base de datos – :

'mysql' => array(
	'driver'    => 'mysql',
	'host'      => 'localhost',
	'database'  => 'database', // Nombre base de datos
	'username'  => 'root', // Nombre de usuario
	'password'  => '', // Contraseña
	'charset'   => 'utf8',
	'collation' => 'utf8_unicode_ci',
	'prefix'    => '',
),

Es importante que no cambien el valor de ‘charset’ y de ‘collation’  ya que les aseguro una correcta codificación de los textos en la mayoría de los idiomas.

Lamentablemente no hay forma simple de probar la conexión a la base de datos, por lo cual tendremos que esperar a interactuar con ella para ver si algún problema aparece.

# CREANDO LA TABLA ‘USUARIOS’

En este paso vamos a hacer uso de las llamadas migraciones, las cuales nos permiten administrar un versionamiento de nuestra base de datos vía código y ejecutarlas vía consola. Para los que no quieran utilizar las migraciones, voy a dejar el esquema – bastante simple, sin SQL – que deben crear en MySQL:

id - int - PK - AUTOINCREMENT
email - varchar(100) - NOT NULL
nick - varchar(20) - NOT NULL
password - varchar(64) - NOT NULL

Los campos son bastantes obvios, y lo único que podría agregar es que la contraseña irá hasheada y nunca tendrá un largo mayor a 64 caracteres – así lo define la clase que utilizaremos – y que ocuparemos el campo e-mail para realizar la autenticación. Ah, por obligación la tabla debe ser llamada ‘users‘, de lo contrario tendrá que realizar modificaciones al modelo y en la configuración de autenticación – auth.php -.

Para poder empezar a utilizar migraciones, primero debemos instalar la tabla que las administra. Para ello debemos escribir en consola – dentro del directorio del proyecto – lo siguiente:

php artisan migrate:install

Lo que debe retornar Migration table created successfully, y si nos fijamos en la lista de tablas de nuestra base de datos, veremos una tabla llamada migrations:

mysql> DESCRIBE migrations;
+-----------+--------------+------+-----+---------+-------+
| Field     | Type         | Null | Key | Default | Extra |
+-----------+--------------+------+-----+---------+-------+
| migration | varchar(255) | NO   |     | NULL    |       |
| batch     | int(11)      | NO   |     | NULL    |       |
+-----------+--------------+------+-----+---------+-------+
2 rows in set (0.01 sec)

Bien, ahora debemos crear la migración, en consola escribimos:

php artisan migrate:make create_users_table

El nombre create_users_table lo definen ustedes – puede ser cualquier cosa -, pero lo ideal es manejar nombres descriptivos de acuerdo a lo que realiza la migración. De ese modo al ver el nombre del archivo podrán saber de que se trata la migración, otros ejemplos – para que lo entiendan bien -:

create_games_table
add_name_to_games_table
add_fk_to_games_table

Si se dan cuenta, son nombres descriptivos y para mi gusto deberían estar en inglés, al igual que el código que escriben y sus tablas de la base de datos. Pero eso ya es otro tema, algo personal.

Ahora bien, volviendo a la migración que estábamos realizando, se debió haber creado en la carpeta ‘app/database/migrations’ un archivo que contiene en primer lugar la fecha en cual fue creada esa migración y luego el nombre que le indicamos. Las migraciones se basan en un modelo para crear las tablas, estos modelos se llaman esquemas – Schema Builder – el cual es bastante fácil de entender y muy amigable, por lo que el archivo debe quedar de esta manera:

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('users', function($table) {
			$table->increments('id');
			$table->string('email', 100);
			$table->string('password', 64);
			$table->string('nick', 20);
		});
	}

	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('users');
	}

En el método up() entregamos las ordenes de cómo debe ser creada nuestra tabla y el método down() define todo lo contrario, en este caso, como eliminar la tabla que hemos creado, por lo que up() es llamado cuando ejecutamos la migración y down() es llamado cuando hacemos un rollback de ésta.

Ahora es momento de ejecutar nuestra migración, por lo que debemos escribir:

php artisan migrate

Lo que nos devolverá algo como Migrated: 2013_06_27_051948_create_users_table y nuestra tabla ya debería estar creada.

# ALIMENTANDO LA TABLA ‘USUARIOS’

Laravel entrega la posibilidad de realizar el ingreso de datos directamente sin la necesidad de ir a tu administrador de base de datos y realizar el ingreso manual. A esto se le llama seeding y cuando te acostumbras a cierto flujo de trabajo es ideal para realizar pruebas rápidas, ingresando datos de prueba o simplemente para poder cargar automáticamente datos a ciertas tablas cuando estás instalando tu proyecto terminado.

Para generar un seeder debemos ir a la carpeta ‘app/database/seeds’ y crear un archivo llamado UserTableSeeder.php. El nombre del archivo no es importante, pero si es útil que tenga un nombre descriptivo y de cierta convención – es una buena práctica -. Dentro del archivo deben escribir lo siguiente:

class UserTableSeeder extends Seeder {

	public function run()
 	{
		$users = [
			['nick' => 'Juan', 'password' => Hash::make('111'), 'email' => 'juan@email.com'],
			['nick' => 'Pedro', 'password' => Hash::make('222'), 'email' => 'pedro@email.com'],
			['nick' => 'Diego', 'password' => Hash::make('333'), 'email' => 'diego@email.com']
		];

		DB::table('users')->insert($users);
	}

}

Simplemente tenemos una matriz con los datos de los usuarios que vamos a ingresar. Si se fijan, en los campos contraseña estamos utilizando la clase Hash y su método make(), el cual automáticamente hashea el texto entregado. Finalmente insertamos los datos utilizando el Query Builder de Laravel, también conocido como Fluent.

El siguiente paso es ejecutar este seed para nuestra tabla. Para ello, son dos pasos, el primero es indicarla al framework que seeding vamos a realizar, así que debemos abrir el archivo DatabaseSeeder.php – ubicado en la misma carpeta – y dejarlo como se muestra a continuación:

class DatabaseSeeder extends Seeder {

	/**
	 * Run the database seeds.
	 *
	 * @return void
	 */
	public function run()
	{
		Eloquent::unguard();

		$this->call('UserTableSeeder');
	}

}

Primero le indicamos a Laravel que desactive una capa de seguridad al momento de ingresar datos – Eloquent::unguard() – dejando el camino libre para que se ejecute el seeding de nuestra tabla con $this->call('UserTableSeeder'); el cual hace referencia a la clase que creamos anteriormente.

Finalmente, en consola:

php artisan db:seed

Ya podemos ver los usuarios en nuestra base de datos:

mysql> SELECT * FROM users;
+----+-----------------+--------------------------------------------------------------+-------+
| id | email           | password                                                     | nick  |
+----+-----------------+--------------------------------------------------------------+-------+
|  1 | juan@email.com  | $2y$08$vq/odtnLuNYrDc4BFehs0uLXjfUiw/oeE8eV6ApausKj4znMgzfU6 | Juan  |
|  2 | pedro@email.com | $2y$08$.xEloH2G5U57ofwOgmd03OcRm/DL1mU2NgmvZxjfL9dHgzYdjKAWe | Pedro |
|  3 | diego@email.com | $2y$08$0djAzg4kFvPhfqp4DxRn6erHmGv6gY0Fh71tikmuf7QE1UiCCytXW | Diego |
+----+-----------------+--------------------------------------------------------------+-------+
3 rows in set (0.00 sec)

# CONTROLADOR DE AUTENTIFICACIÓN

Ya tenemos usuarios registrados en nuestra sistema, por lo que ahora vamos a crear el controlado que se encargará de dar o no dar acceso a un usuario de acuerdo a las credenciales que nos entregue.

Vamos a crear un archivo llamado AuthController.php dentro de la carpeta ‘app/controllers’. Este controlador tendrá simplemente dos métodos, uno encargado de la identificación y otro para poder salir del sistema – log out -:

class AuthController extends BaseController {

	/**
	 * Attempt user login
	 */
	public function doLogin()
	{
		// Obtenemos el email, borramos los espacios
		// y convertimos todo a minúscula
		$email = mb_strtolower(trim(Input::get('email')));
		// Obtenemos la contraseña enviada
		$password = Input::get('password');

		// Realizamos la autenticación
		if (Auth::attempt(['email' => $email, 'password' => $password]))
		{
			// Aquí también pueden devolver una llamada a otro controlador o
			// devolver una vista
			return Redirect::to('/hidden');
		}

		// La autenticación ha fallado re-direccionamos
		// a la página anterior con los datos enviados
		// y con un mensaje de error
		return Redirect::back()->with('msg', 'Datos incorrectos, vuelve a intentarlo.');
	}

	public function doLogout()
	{
		//Desconctamos al usuario
		Auth::logout();

		//Redireccionamos al inicio de la app con un mensaje
		return Redirect::to('/')->with('msg', 'Gracias por visitarnos!.');
	}

}

En el controlador simplemente ocupamos dos clases de Laravel. La primera es es Auth la cual nos entrega varios métodos de autenticación, ocupando en este caso attempt() al cual le entregamos una matriz con el par de datos que ocuparemos como credenciales. Este par de datos puede ser cualquiera de la tabla users, por ejemplo podemos cambiar el e-mail por nick y solicitar ese campo en el formulario, de ese modo la validación se realizará con nick y la contraseña entregada.

En segundo lugar tenemos la clase Redirect lo que nos permite dirigir al usuario ya sea a una URL, a una acción de un controlador o una ruta definida.

# DEFINIENDO LAS RUTAS

Es hora de definir a que rutas responderá nuestra aplicación y el como lo hará. Deben editar el archivo routes.php ubicado en ‘app’ y agregar las siguientes rutas – deben borrar la ruta que viene pre-configurara -:

//Pagina principal donde está el formulario de identificación
Route::get('/', ['before' => 'guest', function(){
	return View::make('index');
}]);
//Página oculta donde sólo puede ingresar un usuario identificado
Route::get('/hidden', ['before' => 'auth', function(){
	return View::make('hidden');
}]);
//Procesa el formulario e identifica al usuario
Route::post('/login', ['uses' => 'AuthController@doLogin', 'before' => 'guest']);
//Desconecta al usuario
Route::get('/logout', ['uses' => 'AuthController@doLogout', 'before' => 'auth']);

Hemos definido cuatro rutas para nuestra aplicación:

+--------+-------------+------+-------------------------+----------------+---------------+
| Domain | URI         | Name | Action                  | Before Filters | After Filters |
+--------+-------------+------+-------------------------+----------------+---------------+
|        | GET /       |      | Closure                 | guest          |               |
|        | GET /hidden |      | Closure                 | auth           |               |
|        | POST /login |      | AuthController@doLogin  | guest          |               |
|        | GET /logout |      | AuthController@doLogout | guest          |               |
+--------+-------------+------+-------------------------+----------------+---------------+

La primera ruta raíz ‘/’ es del tipo GET y retorna la vista index – que crearemos más abajo -, la cual contiene el formulario de identificación. Luego tenemos la ruta ‘/hidden’ del tipo GET que retorna la vista oculta y que sólo pueden tener acceso los usuarios identificados. En tercer lugar se encuentra ‘/login’ del tipo POST es donde el formulario realiza la verificación de datos mediante el método doLogin(). Por último tenemos a ‘/logout’ del tipo GET que realiza la desconexión del usuario llamando al método doLogout().

# DEFINIENDO ALGUNOS FILTROS

Si se fijan adjunté unos filtros a cada una de las rutas, esto permite ejecutar ciertas validaciones o tareas antes de que efectivamente ésta se ejecute. En este caso estamos trabajando con auth y guest. La primera permite verificar si el usuario está identificado el sistema y la segunda por el contrario, verifica si se trata de una visita. Esto nos permite restringir el acceso a público la ruta ‘/hidden’  y ‘/logout’ – no tiene sentido desconectar a alguien que no lo está – y denegar acciones a usuarios que ya se encuentran identificados – con guest – como volver a identificarse o acceder al formulario.

Los filtros que vienen en Laravel son perfectos y sólo hay que realizar una pequeña modificación para que funcionen en nuestro escenario. Para ello vamos a abrir el archivo filters.php ubicado en ‘app’ y modificar el filtro auth por este:

Route::filter('auth', function()
{
	if (Auth::guest()) return Redirect::guest('/')->with('msg', 'Debes identificarte primero.');;
});

Sólo modificamos la ruta a la cual será redirigido el usuario y agregamos un mensaje de aviso. Eso es todo.

# CREANDO LAS VISTAS

Lo último que nos queda pendiente, es generar las vistas de nuestra aplicación. Contaremos con 3 vistas: el layout, el formulario de identificación y la página oculta. Ah, y por favor tengan en cuenta, las hice lo más rápido posible, no existe diseño alguno.

La primera vista que debemos crear es nuestro layout, para ello deben crear un archivo llamado layout.blade.php en la carpeta ‘app/views’ e insertar el siguiente contenido:

<!doctype html>
<html lang="es">
<head>
	<meta charset="UTF-8">
	<title>@yield('title') | Mi aplicación</title>
</head>
<body>
	<header>
		<h1>Mi aplicación</h1>
		<hr />
	</header>
	@yield('content')
</body>
</html>

Esta será nuestra estructura base. Podrán ver el comando @yield del sistema de plantillas de Laravel, el cual permite incrustar contenido proveniente de otra vista que extienda a layout. Por lo que esta vista permite incrustar un título – @yield(‘title’) – y un contenido principal – @yield(‘content’) -.

Ahora creemos el formulario de identificación, deben crear un archivo con el nombre de index.blade.php:

@extends('layout')

@section('title')
	Identificación
@stop

@section('content')
	<h2>Identificarse</h2>

	@if(Session::get('msg'))
		<p>{{ Session::get('msg') }}</p>
	@endif

	{{ Form::open(array('url' => '/login', 'method' => 'POST')) }}
		E-mail <input type="text" name="email" /> <br />
		Contraseña <input type="password" name="password" /> <br />
		<input type="submit" value="Ingresar" />
	{{ Form::close() }}
@stop

En la vista indicamos que ésta extiende de layout – @extends(‘layout)’ – por lo que debemos proveer los campos que se podían incrustar – no son obligatorios -, es así como utilizamos @section. ..@stop para indicar el contenido que incrustaremos en la vista padre. En este caso tenemos a @section(‘title’) enviando el contenido Identificación y luego tenemos @section(‘content’) con el formulario de identificación.

En esta vista ocupamos la clase Form que es un helper de HTML el cual nos permite crear formularios de manera más dinámica. En este caso – y la verdad por capricho propio – sólo lo he utilizado para abrir y cerrar el formulario, pero se puede utilizar para crear todo tipos de elementos de formulario. A Form::open le entrego dos valores, url y method, indicándole que debe procesar el formulario en la URL /login y que lo debe enviar vía POST.

También pueden ver que trabajamos con la clase Session, donde preguntamos si en la sesión se encuentra algún dato llamado msg y si es así, que lo muestre. Este dato se genera desde las respuestas de Redirect – en nuestro controlador y el filtro auth – cuando utilizamos el método with(key, valor)Esto almacena en la sesión ese valor pero sólo estará disponible para esa respuesta, al recargar la página o ir a otra el valor desaparece.

Nuestra última vista es la página oculta, y que sólo usuarios identificados pueden acceder. Creen un archivo llamado hidden.blade.php:

@extends('layout')

@section('title')
	Página oculta
@stop

@section('content')
	<h2>Hola {{ Auth::user()->nick; }} (<a href="{{ URL::to('/logout') }}">Salir</a>)</h2>
	<h2>Estás en una página sólo para personas importantes como tú :P</h2>
@stop

En esta última vista trabajamos nuevamente con  la clase Auth y su método user() el cual nos permite acceder a las propiedades del modelo del usuario identificado. Por último la clase URL es un helper para la creación de direcciones dentro de nuestra aplicación. En este caso simplemente generamos una URL válida hacia ‘/logout’.

Ya terminamos, pueden morir tranquilos.

# CONCLUSIONES

Para mi gusto la creación de un sistema de identificación en cualquier tipo de lenguaje es una muy buena forma de practicar en él y entender su funcionamiento. La creación de algo así implica involucrarse en varias áreas del lenguaje o framework en cuestión (base de datos, sesiones, controladores, modelos, vistas), lo que nos permite familiarizarnos con todas las herramientas y opciones que éste nos puede entregar.

Quizás el pequeño tutorial salió más largo de lo esperado, pero aún así es simple de realizar siguiendo el paso a paso. Intenté ser lo más detallado posible y explicar cada una de las cosas, ya que a mi parecer, hay que entender lo que uno está haciendo.