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

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

Anuncios

39 comments

  1. Saludos, nikoskip
    muy buena enzeñanza, veo que vas de frente con laravel, eso me gusta, quiza pudieras hablarnos un poco sobre la proteccion de CSRF en laravel 4, a nivel basico seria muy bueno para todos los que comienzan con este framework, pero en realidad creo que el punto fuerte seria el uso de esta proteccion cuando usamos llamadas a AJAX.

    te felicito por el tuto, muy bien explicado, eres muy buen profesor!!!!! :)

    Me gusta

    1. Hola Hernán, gracias por tu comentario. La protección CSRF viene integrada en Laravel, y si te fijas al utilizar el helper Form::open() automáticamente agrega un input del tipo hidden bajo el tag . Para poder empezar a utilizarlo basta usar el filtro ‘csrf’ antes de manejar la ruta. Si lo haces por AJAX debería bastar enviando el token vía POST. Aún así tocaré el tema en un tiempo más, explicando con algo más de detalle.

      Me gusta

  2. He estado siguiendo estos tutos y estan excelentes! Una buena guia para los que estamos iniciando con este framework espero que sigas publicando mas y si pudieras enseñarnos temas como CRUD, motor de plantillas y relaciones de tablas con eloquent. Saludos.

    Me gusta

  3. Hola Antonio, efectivamente voy a tratar lo que más pueda sobre Laravel, desde cosas muy básicas y simples hasta cosas más complejas. Gracias por tu comentario.

    Me gusta

    1. Muchas gracias!, espero enseñar varias cosas sobre Laravel y temas de desarrollo web. Por tema de tiempo no puedo escribir muy seguido, pero no dudes en darte unas vueltas seguidas por el blog.

      Saludos.

      Me gusta

  4. Muy bueno el tutorial, gracias.
    Tengo un problema espero que me puedas ayudar, cuando he iniciado sesión y estoy en /hidden luego cierro sesión, luego me envía al formulario de autentificación y luego le doy atrás al navegador web puedo ver la página protegida /hidden seguramente por la cache, pero debería ir al formulario autentificación, como puedo solucionar este problema.

    Me gusta

  5. Acabo de hacer la prueba y efectivamente es un tema del caché. Habría que enviar un header para indicar que no haga guarde el documento y siempre lo requiera (como no-cache). De todas formas, si tienes un sistema más complejo, si bien tendrá la vista de un usuario, no podrá realizar ninguna acción porque la sesión ya fue eliminada.

    Me gusta

    1. Después de muchas vueltas, encontré una solución para que el navegador no lo guarde en la cache
      Route::get(‘/hidden’, [‘before’ => ‘auth’, function(){
      $contents = View::make(‘hidden’);
      $response = Response::make($contents, 200);
      $response->header(‘Expires’, ‘Tue, 1 Jan 1980 00:00:00 GMT’);
      $response->header(‘Cache-Control’, ‘no-store, no-cache, must-revalidate, post-check=0, pre-check=0’);
      $response->header(‘Pragma’, ‘no-cache’);
      return $response;
      }]);

      Me gusta

        1. Dejé un link al repositorio en GitHub, puedes descargar el proyecto por completo y ver donde va cada cosa. Ahora, ten en cuenta que esto fue hecho hace más de un año con Laravel versión 4, ahora van en la 4.2 y las cosas han cambiado un poco.

          Me gusta

  6. hola, soy nuevo en laravel y tengo el mismo problema que he tenido con otros tutoriales: las rutas. para este caso puedo ver lo del index, pero cuando ya ingreso el usuario y la clave la siguiente pantalla es un not found:

    Not Found
    The requested URL /laravel-wamp/public/login was not found on this server.

    tiene que ver el /public de la ruta que uso? si sí, cómo configuro para quitar /public de mis rutas en routes.php ?

    Me gusta

    1. Ese es un error que ta da Apache, por lo cual el problema de seguro está con tu .htaccess. Laravel viene con un .htaccess, fíjate que efectivamente esté dentro del directorio /public del framework. También puedes probar con esta otra configuración de Apache en el caso que no funcione ese .htaccess:

      Options +FollowSymLinks
      RewriteEngine On

      RewriteCond %{REQUEST_FILENAME} !-d
      RewriteCond %{REQUEST_FILENAME} !-f
      RewriteRule ^ index.php [L]

      De igual forma, te recomiendo visitar http://www.laraveles.com y de seguro allá mucho más gente que yo te podrá asistir.

      Saludos.

      Me gusta

  7. Hola, solamente una duda, es necesario crear las migraciones en la BD para crear el login?
    por que realice un login improvisado pero sin usar las migraciones y no me ha resultado, no me valida los datos que ingreso del usuario

    Me gusta

    1. No son necesarias mientras tu hayas replicado las mismas tablas de forma “manual” por así decirlo en tu DB, ya sea por PHPMyAdmin o SQL directo.

      Me gusta

  8. Buenas, buenas, amigo si por casualidad tengo un formulario de comentarios y quiero que sean usuarios logueados los que envien el formulario pero un usuario guest envia y lo en redirige al formulario de login, ¿como se hace para que guarde todos los datos del formulario enviado ? yo tengo en el filtro que si el usuario es guest lo redirija al login pero ¿como mantengo las variables enviadas a traves del formulario antes de loguearse para que envie el formulario de una vez luego de loguearse?

    Me gusta

  9. Buenas.
    Julmer, en el caso que planteas yo lo resolví cambiando la etiqueta “open” del formulario por “model”, a la vez que le paso el objeto con los datos del formulario. En el formulario sería algo como:

    Form::model($user, …

    Luego, en la cabecera de la página debes modificar el método y ruta que tendrá el formulario, dependiendo si es la primera vez que el usuario lo cumplimenta o cuando quieres que mantenga los datos ya introducidos, sería algo como:

    @section(‘head’)
    exists):
    $form_data = array(‘route’ => array(‘users.update’, $user->id), ‘method’ => ‘PATCH’);
    else:
    $form_data = array(‘route’ => ‘users.store’, ‘method’ => ‘POST’);
    endif;
    ?>
    @stop

    Espero que te sirva.
    Saludos.

    Me gusta

  10. Por favor, ayudame con este inconveniente.

    En el Modelo:

    public function scopeDropdown()
    {
    return $this->lists('apellidos', 'id');
    }
    

    Necesito concantenar a ‘apellidos’ . ‘Nombres’

    Gracias

    Me gusta

Deja un comentario (puedes utilizar Markdown)

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s