Desarrolla aplicaciones web desde cero con Laravel

Spanish (Español) translation by Steven (you can also view the original English article)

En esta miniserie de Tuts+, construiremos una aplicación web desde cero, mientras nos sumergimos en un nuevo framework de PHP que está cogiendo rápidamente vapor, llamado Laravel.

En esta lección, trabajaremos en una parte integral de cualquier aplicación web: los modelos. En el camino, aprenderemos sobre la increíble implementación de ORM de Laravel: Eloquent.

Revisión

¡Bienvenido de nuevo a nuestra serie de aplicaciones web desde cero con Laravel! En el primer tutorial de la serie, aprendimos mucho sobre Laravel y su filosofía:

Qué es Laravel
Lo que diferencia a Laravel de otros frameworks PHP
Dónde descargar Laravel
Cómo configurar Laravel
Cómo funciona el sistema de rutas de Laravel
Algunas otras características del sistema de rutas de Laravel
Cómo crear tu primer controlador en Laravel
Algunas características adicionales con los controladores de Laravel
Cómo crear tu primera Vista en Laravel
Cómo utilizar el motor de plantillas blade de Laravel

Si aún no lo has leído, deberías echar un vistazo al tutorial anterior y darle una lectura - esto hará que sea más fácil entender la filosofía detrás de Laravel y la mayor parte de lo que hablaremos en este tutorial.

En esta segunda parte de la serie Laravel, crearemos una parte crucial de nuestra aplicación web de prueba, Instapics, que es la implementación del modelo. ¡Sin más preámbulos, empecemos!

¿Qué son los "Modelos"?

Ya he hablado un poco sobre lo que son los modelos en uno de mis artículos anteriores, Zend Framework desde cero - Modelos e Integrando Doctrine ORM, así que para evitar repetirlo, escribiré la esencia de lo que escribí antes aquí. Siéntete libre de referirte al otro tutorial y leer más acerca de qué modelos están allí.

Resumen:

Los modelos son representaciones de la base de datos y deben estar donde reside toda la lógica de la empresa de una aplicación
Los controladores se comunican con los Modelos y les piden que obtengan la información que necesitan
Después, un controlador pasa esta información a la vista y se muestra
Es muy raro que un modelo interactúe directamente con una vista, pero a veces puede suceder cuando es necesario
Los modelos pueden hablar con otros modelos y no son autónomos. Tienen relaciones que se entrelazan entre sí
Estas relaciones hacen que sea más fácil y rápido para un Controlador obtener información, ya que no tiene que interactuar con diferentes Modelos - los Modelos pueden hacerlo entre ellos

Los modelos en Laravel, o en la mayoría de los frameworks, se desarrollan de la misma manera. La diferencia es que Laravel nos da una manera fácil de construir estos modelos, proporcionándonos métodos de uso general que la mayoría de los modelos necesitarían - el Eloquent de ORM.

El Eloquent de ORM

Un ORM es un mapeador relacional de objetos, ¡y Laravel tiene uno que te encantará! Se denomina "Eloquent", porque te permite trabajar con tus objetos de base de datos y las relaciones mediante una sintaxis elocuente y expresiva.

Eloquent ORM es la implementación ORM integrada de Laravel. En mi opinión, es una de las mejores implementaciones de ORM que he visto hasta ahora- rivalizando incluso con Doctrine ORM. Es increíblemente elegante, haciendo uso de las convenciones estándar de la industria para disminuir la configuración.

Convenciones

Por ejemplo, el uso de un modelo elocuente supone que la tabla que representa el modelo tiene un campo id. El id es la clave primaria para cualquier registro y lo utilizan la mayoría de los métodos de Eloquent.

Otra cosa que Eloquent asume correctamente es que el nombre de la tabla es la forma plural del modelo. Por ejemplo, el modelo User hará referencia a la tabla users. Como esto podría no ser siempre el estándar para algunos, Laravel proporciona una manera de invalidar esto: simplemente utiliza el indicador $table:

1	class User extends Eloquent {
2	public static $table = 'my_users';
3	}

Esto indicará a Laravel que no use la convención y, en su lugar, use una tabla especificada.

Por último, Laravel también puede automatizar la creación y actualización de las marcas de tiempo para nosotros. Para ello, agrega una columna created_at y/o updated_at en la tabla y establece la marca $timestamp en el modelo:

1	class User extends Eloquent {
2	public static $timestamps = true;
3	}

Eloquent verá la marca y establecerá automáticamente el campo created_at en la creación y actualizará el campo updated_at cada vez que se actualice un registro. Bastante bueno, ¿no?

Recuperación rápida

Recuperar registros es muy fácil con los métodos de recuperación de Eloquent. Por ejemplo, ¿necesitas encontrar un registro de usuario específico? Sólo haz:

1	$user = User::find($user_id);

¡Esto devuelve un modelo User en el que puedes realizar operaciones! ¿Necesitas usar condicionales? Imaginemos que deseas obtener un usuario por su dirección de correo electrónico. Para llevar a cabo esta tarea, puedes hacer algo como:

1	$user = User::where('email', '=', $email)->first();

Alternativamente, podrías utilizar los métodos dinámicos de Laravel:

1	$user = User::where_email($email)->first();

Inserciones fáciles & Actualizaciones

La inserción y actualización de modelos mediante Eloquent se puede realizar en tres pasos.

Paso 1 - Obtener/Crear el modelo.

1	$user = new User();
2	//or get an existing user
3	$user = User::get($user_id);

Paso 2 - Establecer los datos

1	$user->email = 'nikko@instapics.com';
2	$user->password = 'test1234';

Paso 3 - Guardar
1

$user->save();
¡Listo!

Y finalmente, definir relaciones.

Eloquent hace que el proceso de definición de relaciones y recuperación de modelos relacionados sea simple e intuitivo.

¡Maldita sea! Eloquent admite tres tipos de relaciones:

Uno a uno
Uno a muchos
Muchos a muchos

Para definir una relación entre modelos, deberás crear un método en ambos modelos que "describa" sus relaciones. Por ejemplo, supongamos que User has_one User_Profile. Puedes hacerlo definiendo un método user_profile en el modelo User:

class User extends Eloquent {
    public function user_profile()
    {
        return $this->has_one('User_Profile');
    }
}

Dado que User es nuestro modelo "dominante" aquí (es decir, un usuario tiene un perfil, y no un perfil tiene un usuario), definimos que User_Profile belongs_to (pertenece a un usuario) User:

class User_Profile extends Eloquent {
    public function user()
    {
        return $this->belongs_to('User');
    }
}

Una vez que hayamos definido estas relaciones, entonces podemos hacer lo siguiente:

/*
  Get the User_Profile object of a User
  This executes two SQL queries:
  
  SELECT * FROM `users` WHERE `id` = $user_id
  SELECT * FROM `user_profiles` WHERE `user_id` = $user_id
*/
$user = User::find($user_id);
$user_profile = $user->user_profile;

/*
  We can also do it the other way around
*/
$user_profile = User_Profile::where('user_id', '=', $user_id)->first();
$user = $user_profile->user;

Una cosa que vale la pena señalar aquí es otra convención: Eloquent asume que la clave externa utilizada en User_Profile es el nombre +_id de la tabla a la que se hace referencia. Una vez más, si deseas cambiar este comportamiento, puedes anularlo:

class User extends Eloquent {
    public function user_profile()
    {
        return $this->has_one('User_Profile', 'user_profile_user_id');
    }
}

Supongamos que queremos definir la relación entre User y Photo (sus fotos subidas). Esta es una relación de uno a muchos One-to-Many, a diferencia de la relación User Profile a User que era uno a uno One-to-One. Sabemos que User has_many Photo, por lo cual:

class User extends Eloquent {
    public function photos()
    {
        return $this->has_many('Photo');
    }
}
...
...
...
class Photo extends Eloquent {
    public function user()
    {
        return $this->belongs_to('User');
    }
}

La principal diferencia aquí con has_one es que la función que usaremos para recuperar las fotos de un usuario ahora devolverá una matriz de objetos del modelo Photo. Por lo tanto, si quisiéramos traer todas las fotos de un usuario, podríamos hacer lo siguiente:

$photos = User::find($user_id)->photos;
foreach($photos as $photo) {
    ...
    ...
    ...
}

No, referirse a photos como una propiedad no es un error tipográfico. Laravel nos da ese sabor dulce. También podríamos hacer:

1	$photos = User::find($user_id)->photos()->get();

Relaciones de muchos a muchos - Mant-to-Many

Este es un poco complicado, pero una vez implementado, hace que sea fácil manejar las relaciones de muchos a muchos entre los modelos. Imaginemos, por ejemplo, que, de nuevo, tienes un modelo User y cada uno de estos usuarios puede tener varios grupos y para eso usamos el modelo Group. Un grupo también puede tener varios usuarios. Usaremos tres tablas para representar estas relaciones particulares:

Users - tabla donde están todos nuestros usuarios
Groups - tabla donde están todos nuestros grupos
Group User - tabla que enumera todos los usuarios de un grupo

La convención de estructura de tabla que Eloquent buscará será algo como esto:

users
- id
- ... otras columnas
groups
- id
- ... otras columnas
group_user
- id
- user_id
- group_id
- ... otras columnas

Otra convención a tener en cuenta aquí es que la tabla intermedia, group_user, son los nombres singulares de las dos tablas que estás conectando, organizados alfabéticamente con un carácter de subrayado. Como siempre, somos libres de anular esto.

Así es como se verá el código dentro de cada uno de los modelos para estas tres tablas:

class User extends Eloquent {
    public function groups()
    {
        //if we wanted to override the default naming convention
        //for the intermediate table, we can do it like so:
        //return $this->has_many_and_belongs_to('Group', 'group_listings');
        
        return $this->has_many_and_belongs_to('Group');
    }
}
...
...
...
class Group extends Eloquent {
    public function users()
    {
        //if we wanted to override the default naming convention
        //for the intermediate table, we can do it like so:
        //return $this->has_many_and_belongs_to('User', 'group_listings');
        
        return $this->has_many_and_belongs_to('User');
    }
}
...
...
...
class Group_User extends Eloquent {
    public function group()
    {
        return $this->has_one('Group');
    }
    
    public function user()
    {
        return $this->has_one('User');
    }
}

Con esto en su lugar, podemos aprovechar las funciones de relación de Eloquent:

//Get a user's groups
$groups = User::find($user_id)->groups;

//Get all users in a group
$users = Group::find($group_id)->users;

Paso 1 - Creación de la base de datos Instapics

Continuando con nuestra aplicación web, Instapics, comencemos creando la base de datos de nuestra aplicación. Para ello, vamos a anotar las funcionalidades deseadas de la aplicación:

Los usuarios pueden iniciar sesión y registrarse para obtener una cuenta
Los usuarios pueden seguir a otros usuarios para ver las fotos que han subido
Los usuarios pueden subir su propia foto y aplicar un filtro a ella
Los usuarios pueden comentar y darle me gusta a otras fotos

Para esto, podemos deducir las tablas de base de datos que necesitaremos:

users
- id (uno a uno con user_profiles.user_id, muchos a muchos usando la misma tabla relationships.follower_id y followed_id, uno a muchos con photos.user_id y photo_comments.user_id)
- email
- password
- created_at
- updated_at
user_profiles
- id
- user_id (uno a uno con users.id)
- name
- profile_photo
relationships
- id
- follower_id (uno a uno con users.id)
- followed_id (uno a uno con users.id)
- created_at
- updated_at
photos
- id (uno a muchos con photo_comments.user_id)
- user_id (uno a uno con users.id)
- location
- description
- created_at
- updated_at
photo_comments
- id
- user_id (uno a uno con users.id)
- photo_id (uno a uno con photos.id)
- message
- created_at
- updated_at

Vamos a continuar y vamos crear estas tablas. Para este proyecto, usaré MySQL; no dudes en copiar y pegar estos comandos.

CREATE DATABASE `instapics`;
USE `instapics`;

CREATE TABLE `instapics`.`users` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `email` VARCHAR(100) NOT NULL,
  `password` VARCHAR(100) NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_email`(`email`)
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`user_profiles` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `name` TEXT NOT NULL,
  `profile_photo` TEXT NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_user_id`(`user_id`),
  CONSTRAINT `FK_user_profiles_user_id` FOREIGN KEY `FK_user_profiles_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`relationships` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `follower_id` INTEGER UNSIGNED NOT NULL,
  `followed_id` INTEGER UNSIGNED NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_follower_id_followed_id`(`follower_id`, `followed_id`),
  CONSTRAINT `FK_relationships_follower_id` FOREIGN KEY `FK_relationships_follower_id` (`follower_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `FK_relationships_followed_id` FOREIGN KEY `FK_relationships_followed_id` (`followed_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`photos` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `location` TEXT NOT NULL,
  `description` TEXT NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_photos_user_id` FOREIGN KEY `FK_photos_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`photo_comments` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `photo_id` INTEGER UNSIGNED NOT NULL,
  `message` TEXT NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_photo_comments_user_id` FOREIGN KEY `FK_photo_comments_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `FK_photo_comments_photo_id` FOREIGN KEY `FK_photo_comments_photo_id` (`photo_id`)
    REFERENCES `photos` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

Alternativamente, podrías usar las migraciones, pero las revisaremos en una lección futura.

Paso 2 - Configurar la base de datos de Laravel

Antes de hacer nada con los modelos Laravel, necesitamos configurar la base de datos de nuestra instalación de Laravel. Abre application/config/database.php, para encontrar algunos de estos ajustes:

profile - establecer esto en true registrará todas las horas de las consultas en SQL en los registros de Laravel. Deja esto como true por ahora.
fetch - el tipo de datos devueltos de PDO. El valor predeterminado es PDO::FETCH_CLASS y debe dejarse así.
default - este es el nombre de la configuración de conexión utilizada por la aplicación. El nombre hace referencia al índice de la matriz $connections justo debajo
connections: una matriz asociativa de las posibles conexiones para la aplicación.
- driver: el tipo de servidor de base de datos. Puede ser pgsql, sqlite, mysql o sqlsrv
- host - el nombre de host del servidor de tu base de datos
- database - el nombre de la base de datos
- username - nombre de usuario para usar en el servidor de la base de datos
- password - contraseña para usar en el servidor de la base de datos
- charset - El tipo de charset para usar en el servidor de la base de datos
- prefix - prefijo de tabla en la base de datos, si hay
redis: si planeas utilizar la biblioteca Redis de Laravel, puedes configurar la información del servidor aquí.

Para los fines de este tutorial, usaremos MySQL. Tu archivo database.php debería tener un aspecto similar al siguiente (eliminé los comentarios, pero deberías dejarlos):

return array(
	'profile' => true,
	'fetch' => PDO::FETCH_CLASS,
	'default' => 'mysql',
	'connections' => array(
		'mysql' => array(
			'driver'   => 'mysql',
			'host'     => 'localhost',
			'database' => 'instapics',
			'username' => 'root',
			'password' => '(yourpassword)',
			'charset'  => 'utf8',
			'prefix'   => '',
		),
	),
	'redis' => array(
		'default' => array(
			'host'     => '127.0.0.1',
			'port'     => 6379,
			'database' => 0
		),
	)
);

Paso 3 - Creación de tu primer modelo en laravel

Comienza creando un modelo de Laravel dentro de la carpeta application/models. Crea user.php dentro y añade el siguiente código:

1	class User extends Eloquent {
2
3	}

Ahora, sobre la base de nuestra revisión de cuáles son las relaciones de User, necesitamos codificar los métodos de las relaciones para todas ellas:

class User extends Eloquent {
    
    //setting $timestamp to true so Eloquent
    //will automatically set the created_at
    //and updated_at values
    public static $timestamps = true;
    
    public function user_profile()
    {
        return $this->has_one('User_Profile');
    }
    
    public function followers()
    {
        return $this->has_many_and_belongs_to('User', 'relationships', 'followed_id', 'follower_id');
    }
    
    public function following()
    {
        return $this->has_many_and_belongs_to('User', 'relationships', 'follower_id', 'followed_id');
    }
    
    public function photos()
    {
        return $this->has_many('Photo');
    }
    
    public function photo_comment()
    {
        return $this->has_many('Photo_Comment');
    }
}

Notablemente, hacemos uso de algunas funciones avanzadas de muchos a muchos aquí, debido a la estructura de la tabla de nuestro modelo 'follower' (es decir, la tabla users hace referencia a la tabla relationships, la cual hace referencia a la tabla users de nuevo). La función has_many_and_belongs_to tiene la siguiente firma de método:

/**
 * Get the query for a many-to-many relationship.
 *
 * @param  string        $model
 * @param  string        $table
 * @param  string        $foreign
 * @param  string        $other
 * @return Relationship
*/
public function has_many_and_belongs_to($model, $table = null, $foreign = null, $other = null)

Esto realmente nos permite crear un modelo que tiene una relación de muchos a muchos con sí mismo (es decir, los usuarios siguen a otros usuarios). Utilizamos followers y following como los nombres de los métodos en el modelo User para permitirnos obtener seguidores de un usuario u obtener todos los usuarios que un solo usuario está siguiendo, respectivamente.

Siguiendo el ejemplo del modelo User, crea los otros modelos. Cuando termines, debes tener:

application/models/photo.php
application/models/photo_comment.php
application/models/relationship.php
application/models/user.php
application/models/user_profile.php

Estos archivos estarán en el repositorio Git del tutorial, por lo que si prefieres descargarlos, puedes encontrarlos aquí: https://github.com/nikkobautista/laravel-tutorial

Paso 4 - Crear las funciones del usuario para Instapics

Comencemos a usar nuestros modelos creando algunas de las funciones de usuario que necesitaremos en la aplicación. En primer lugar: registro de usuarios. Desde el tutorial anterior, ya hemos creado un formulario de registro/inicio de sesión en la página de inicio. En este momento, esto no está haciendo nada, pero vamos a conectarlo a un controlador de User, para que se pueda autenticar mediante la acción authenticate. Crea un archivo en application/controllers/user.php con el siguiente código:

class User_Controller extends Base_Controller
{    
    public function action_authenticate()
    {
        
    }
}

Abre application/views/home/index.blade.php y busca el formulario de inicio de sesión. Actualiza el formulario de la línea 18 para enviarlo al método action_authenticate():

1	<form class="well" method="POST" action="user/authenticate">

Volviendo al controlador User_Controller, agreguemos un poco de código en action_authenticate():

class User_Controller extends Base_Controller
{    
    public function action_authenticate()
    {
        $email = Input::get('email');
        $password = Input::get('password');
        $new_user = Input::get('new_user', 'off');
        
        if( $new_user == 'on' ) {
            try {
                $user = new User();
                $user->email = $email;
                $user->password = Hash::make($password);
                $user->save();
                Auth::login($user);
            
                return Redirect::to('dashboard/index');
            }  catch( Exception $e ) {
                echo "Faield to create new user!";
            }
        } else {
            $credentials = array(
                'username' => $email,
                'password' => $password
            );
            if( Auth::attempt($credentials)) {
                return Redirect::to('dashboard/index');
            } else {
                echo "Failed to login!";
            }
        }
    }
}

Vamos a desglosar lo que hemos hecho aquí hasta ahora:

Usamos la librería Input para obtener los datos del formulario enviado
Si se ha marcado el indicador $new_user, creamos un nuevo usuario, utilizando la biblioteca Hash para generar una contraseña cifrada.
Inicia sesión en el nuevo usuario con la librería Auth
Si el indicador $new_user estaba desmarcado, creamos una matriz $credentials y la usamos con la librería Auth.
Si Auth::attempt es verdadero, significa que las credenciales eran correctas y hemos iniciado sesión
De lo contrario, significa que las credenciales estaban equivocadas.
En ambos escenarios, redirigimos al controlador Dashboard, a la acción index cuando se realice correctamente. Y mostraremos un mensaje de error en caso contrario.

La librería Input

La función básica de la librería Input es habilitar la obtención de los datos del formulario. Por ejemplo, en el controlador del usuario, usamos Input::get('email'); para obtener el valor del correo electrónico del formulario. Es importante tener en cuenta que el método get se utiliza para todos los tipos de solicitudes y no solo para la matriz $_GET.

Puedes leer más sobre la librería Input aquí: http://laravel.com/docs/input#input

La librería Auth

Laravel viene con su propio mecanismo de autenticación, la biblioteca Auth. Puede hacer las siguientes características con respecto a la autenticación de usuario.

Crea una contraseña encriptada

Podemos hacer uso de la librería Hash de la siguiente manera:

1	$password = Hash::make($plaintext_password);

Este método crea una contraseña encriptada y segura para un usuario, utilizando la clave de cifrado que establecemos en el archivo de configuración. Para comprobar si un hash es correcto, puedes utilizar:

1	if( Hash::check($plaintext_password, $hashed_password) == true ) {
2	echo 'Password is correct.';
3	}

Iniciar sesión en un usuario

Para ello, usamos el método attempt de la librería Auth. Antes de eso, sin embargo, construimos una matriz $credentials, que es una matriz asociativa con los índices username y password:

$credentials = array(
    'username' => 'yourname@youremail.com',
    'password' => 'yourpassword'
);
if( Auth::attempt($credentials) == true ) {
    echo 'User is logged in';
} else {
    echo 'Credentials failed';
}

Es importante tener en cuenta que una vez que un intento es "exitoso", el usuario inicia sesión automáticamente.

Hacer que un usuario inicie/cierre sesión

A veces, tendremos que iniciar sesión en un usuario sin usar el método attempt (por ejemplo, al iniciar sesión en un usuario desde un enlace dentro de un correo electrónico o después del registro). Podemos hacerlo con el método Auth::login:

1	Auth::login($user); //where $user is a User object
2	Auth::login(42); //where 42 is the User's ID

Por otro lado, también tenemos un método Auth::logout para cerrar la sesión de los usuarios:

1	Auth::logout();

Esto terminará la sesión del usuario.

Recuperar los datos del usuario que ha iniciado sesión

El método Auth::user nos permite recuperar el objeto de usuario que ha iniciado sesión, así como cualquier información adjunta a él:

1	$email = Auth::user()->email;
2	$created_at = Auth::user()->created_at;

Configuración de la librería `Auth`

La librería Auth debe configurarse antes de usarla (aunque los valores predeterminados funcionarán con la mayoría de los proyectos, como este). Las variables de configuración son:

driver - esto puede ser Eloquent o Fluent. Los desarrolladores pueden escribir sus propios controladores extendiendo la clase Driver en laravel/auth/drivers.
username: este es el nombre de la columna de lo que representa el "nombre de usuario" de tu usuario en la tabla de la base de datos.
model - cuando se utiliza Eloquent, esta es la clase de modelo que utiliza la librería Auth
table - cuando se utiliza el controlador de autenticación Fluent, se determina la tabla de base de datos para los usuarios de la aplicación

Nuestro proyecto, Instapics, utiliza los valores predeterminados en el archivo de configuración auth.php, por lo que no necesitamos cambiar nada en él.

Volviendo al proyecto, ¡prueba las características de inicio de sesión/registro de Instapics! Bastante ingenioso, ¿no? Sin embargo, notarás que aún no tenemos nada en el controlador Dashboard, así que vamos a trabajar en él a continuación.

Paso 5 - Crear el panel de Instapics

Lo primero que tenemos que hacer es crear el controlador Dashboard, con la acción index. Crea el archivo application/controllers/dashboard.php y coloca el siguiente código:

class Dashboard_Controller extends Base_Controller
{
    public function action_index()
    {
        $photos = Auth::user()->photos()->order_by('created_at', 'desc')->order_by('id', 'desc')->get();
        return View::make('dashboard.index', array('photos' => $photos));
    }
}

Ahora necesitamos crear la página index.blade.php del panel. Crea application/views/dashboard/index.blade.php y añade lo siguiente:

@layout('layouts/main')

@section('navigation')
@parent
<li><a href="user/logout">Logout</a></li>
@endsection

@section('content')
<div class="row">
    <div class="span3">
        <div class="well sidebar-nav">
            <ul class="nav nav-list">
                <li class="nav-header">Followers</li>
            </ul>
            <div style="margin-left: 10px">
                @forelse (Auth::user()->followers as $follower)
                    <div style="float: left; width: 30px; margin: 0px 3px 3px 5px;">
                        <img src="http://nettuts.s3.amazonaws.com/2069_laravel_2/http://gravatar.com/avatar/{{ md5(strtolower(trim($follower->email))) }}?s=25&d=retro" alt="Follower" title="{{ $follower->email }}" />
                    </div>
                @empty
                    <div>You have no followers.</div>
                @endforelse
                <div style="clear: both"></div>
            </div>
            
            <ul class="nav nav-list">
                <li class="nav-header">Following</li>
            </ul>
            <div style="margin-left: 10px">
                @forelse (Auth::user()->following as $following)
                    <div style="float: left; width: 30px; margin: 0px 3px 3px 5px;">
                        <img src="http://nettuts.s3.amazonaws.com/2069_laravel_2/http://gravatar.com/avatar/{{ md5(strtolower(trim($following->email))) }}?s=25&d=retro" alt="Following" title="{{ $following->email }}" />
                    </div>
                @empty
                    <div>You are not following anybody.</div>
                @endforelse
                <div style="clear: both"></div>
            </div>
        </div>
    </div>
    <div class="span9">
        <h1>Your Photos</h1>
        @forelse ($photos as $photo)
        <div class="well" style="text-align: center">
            <img src="http://nettuts.s3.amazonaws.com/2069_laravel_2/{{ $photo->location }}" alt="{{ $photo->description }}" title="{{ $photo->description }}" />
            <p>{{ $photo->description }}</p>
        </div>
        @empty
        <div class="alert alert-info">
            <h4 class="alert-heading">Awww!</h4>
            <p>Seems like you don't have any photos yet. <a href="#">Upload a new one?</a></p>
        </div>
        @endforelse
    </div>
</div>
@endsection

Actualiza la página del panel, deberías ver esto:

¿Luce un poco vacío? Agrega esto al controlador Dashboard y ejecútalo accediendo a dashboard/insert_test_data en tu navegador:

public function action_insert_test_data()
{
    $logged_in_user = Auth::user();
    
    for( $x = 0; $x < 10; $x++ ) {
        $email = rand().'@gmail.com';
        $user = new User();
        $user->email = $email;
        $user->password = Hash::make($email);
        $user->save();
        
        $logged_in_user->followers()->attach($user->id);
        if( $x > 5 ) {
            $logged_in_user->following()->attach($user->id);
        }
    }
    
    $photos = array(
        array(
            'user_id' => $logged_in_user->id,
            'location' => 'http://farm6.staticflickr.com/5044/5319042359_68fb1f91b4.jpg',
            'description' => 'Dusty Memories, The Girl in the Black Beret (http://www.flickr.com/photos/cloudy-day/)'
        ),
        array(
            'user_id' => $logged_in_user->id,
            'location' => 'http://farm3.staticflickr.com/2354/2180198946_a7889e3d5c.jpg',
            'description' => 'Rascals, Tannenberg (http://www.flickr.com/photos/tannenberg/)'
        ),
        array(
            'user_id' => $logged_in_user->id,
            'location' => 'http://farm7.staticflickr.com/6139/5922361568_85628771cd.jpg',
            'description' => 'Sunset, Funset, Nikko Bautista (http://www.flickr.com/photos/nikkobautista/)'
        )
    );
    $logged_in_user->photos()->save($photos);
}

Cuando actualices la página, verás cómo se ve con los datos de ejemplo insertados:

Conclusión

En la segunda parte de nuestra serie Laravel, aprendimos:

Algunos antecedentes sobre lo que son los "Modelos"
Qué es el Eloquent ORM
Cómo configurar la base de datos de Laravel
Cómo crear tu primer Modelo en Laravel
Las funciones básicas de las librerías Auth y Input
Hacer uso de Eloquent ORM en una vista

Eloquent realmente es una implementación ORM impresionante - es rápido y tiene un montón de características que hacen que las interacciones con la base de datos en cualquier aplicación sean tan simple como sea posible.

A continuación, en nuestra serie Aplicaciones web desde cero con Laravel, aprenderemos más sobre el uso de los filtros de Laravel, la librería Validation de Laravel, ¡y cómo trabajar con archivos en Laravel!

¿Qué opinas de Eloquent ORM de Laravel? ¿Es algo que te parece útil? ¡Avísame en los comentarios! Y, si eres miembro de Tuts+ Premium, ¡mantente atento a nuestro próximo curso de Laravel Essentials!

Desarrolla aplicaciones web desde cero con Laravel - Eloquent ORM