CRUD en Laravel 5.

4 Hoja de revisión

Versión Núm. Fecha Descripción de la revisión

PARTE I: CONFIGURACIÓN, Rev. 0

Rev. 1
09/Jun/2017

27/Jun/2017
Pedro. Propuesta de Plantilla e índice

Finalización del documento completo.

CONTROLADORES Y CRUD Rev. 2

Rev. 3
Desarrollado por Ing. Pedro García Guerrero
Rev. 4

Rev. 5

Rev. 6

 ITSLP
Av. Tecnológico • S/N
Soledad de Graciano Sánchez, SLP 78320
Teléfono 444 189 06 67 • Email pgarcia1000@itslp.edu.mx
 INTRODUCCIÓN
El presente documento intentar ser un tutorial muy conciso que aborda la preparación
Contenido de la base de datos en posgreSQL y luego toma la vía rápida para crear un CRUD sobre
INTRODUCCIÓN ................................................................................................................................. 2 una agenda.

RECOMENDACIONES INICIALES ..................................................................................................................... 2

Requerimientos mínimos para desarrollo ........................................................................................ 2
Recomendaciones iniciales
Equipo recomendado para producción ............................................................................................ 2 Para que los desarrolladores puedan trabajar apropiadamente en su computadora son
necesarios los requerimientos mínimos. Si su pc carece de alguno de estos elementos o
1 ESPECIFICACIÓN DE REQUISITOS ........................................... ERROR! BOOKMARK NOT DEFINED. características puede que no funcione correctamente o que tenga problemas de
2 ANÁLISIS ............................................................................... ERROR! BOOKMARK NOT DEFINED. rendimiento.
3 DISEÑO ...................................................................................................................................... 3
Requerimientos mínimos para desarrollo
4 HERRAMIENTAS DE DESARROLLO ............................................................................................. 3  Computadora con procesador Core i5 o i5 o AMD FX-8320 o superior
4.1 BITNAMI WAPP ..................................................................................................................... 3  10GB de espacio libre en HDD
 4GB de memoria ram
4.2 ATOM .................................................................................................................................... 4
 Ratón
4.3 LARAVEL ................................................................................................................................ 4  Windows, Linux o Unix de 64bits
5 DESARROLLO EN LARAVEL 5.1 LTS ............................................................................................. 5  Tarjeta de red
 Puertos USB.

Equipo recomendado para producción

Los requerimientos de producción están fuertemente ligados a la cantidad de usuarios
concurrentes y los recursos computacionales demandados por sus procesos. Se estima
que SII atenderá al total de la población del itslp, que se estima esta entre 5000 alumnos
y 200 trabajadores. Aunque no todos usaran el sistema al mismo tiempo debemos
considerar esa posibilidad.
 Computadora con procesador Intel Core i5 o AMD FX-8320
 8GB de memoria ram
 Ratón compatible con Windows
 Microsoft Windows 7 profesional edition, o cualquier otra que incluya IIS
1 Diseño 2.1 Bitnami WAPP
Diagrama de clase:
Bitnami WAMP ofrece un entorno completo, totalmente
integrado y listo para funcionar. Además de PHP, PostgreSQL y Apache, que incluye
Amigo
FastCGI, OpenSSL, phpMyAdmin, ModSecurity, SQLite, ImageMagick, XDebug, XCache,
amigo_id OpenLDAP, ModSecurity, Memcache, OAuth, pera, PECL, APC, GD, cURL y otros
nombre_tx componentes, opera con los siguientes frameworks: Zend Framework , Symfony ,
edad_n
CodeIgniter , CakePHP , Smarty , laravel .
sueldo_n
local_yn
Se puede descargar de:
alta() https://bitnami.com/stack/wamp
baja()
modificacacion()
busca()
todos()
Instalación.
Página de descarga

2 Herramientas de desarrollo
Para el desarrollo se requiere:
 Servidor de Base de Datos
 Servidor Web
 Editor de código
 Manejador de dependencia
 Framework
 Librería para el manejo de roles
Seguir los pasos del asistente.
PostgreSQL es un sistema de gestión de bases de datos objeto-
relacional, distribuido bajo licencia BSD y con su código fuente disponible libremente. Es
el sistema de gestión de bases de datos de código abierto más potente del mercado y en
sus últimas versiones no tiene nada que envidiarle a otras bases de datos comerciales.
PostgreSQL utiliza un modelo cliente/servidor y usa multiprocesos en vez de multihilos
para garantizar la estabilidad del sistema. Un fallo en uno de los procesos no afectará el
resto y el sistema continuará funcionando.
El Proyecto Apache HTTP Server es un esfuerzo por desarrollar y
mantener un servidor HTTP de código abierto para sistemas operativos modernos,
incluyendo UNIX y Windows. El objetivo de este proyecto es proporcionar un servidor
seguro, eficiente y extensible que proporciona servicios HTTP en sincronización con los
estándares HTTP actuales.
2.2 Atom
Atom es un editor de texto que es moderno, accesible, sin embargo
resulta una herramienta que se puede personalizar para hacer cualquier cosa. También
se puede utilizar de manera productiva sin tener que tocar un archivo de configuración.
Es fácil de personalizar y Atom estilo. Se pueden ajustar la apariencia de la interfaz de
usuario con CSS / Menos y añadir características principales con HTML y JavaScript.
Se puede descargar de:
https://atom.io/
2.3 Composer
Composer es un manejador de dependencias, no un gestor de paquetes. Pero
es cierto que trata con paquetes y librerías, la instalación siempre es local para cualquier
proyecto, las librerías se instalan en un directorio por defecto (normalmente es
/vendor).
Composer es capaz de instalar las librerías que requiere tu proyecto con las versiones
que necesiten. ¿Y si mis librerías dependen de otras? También es capaz de resolver eso y
descargar todo lo necesario para que funcione y así quitarnos del dolor de cabeza de
hacer todo eso de forma manual.
¿Qué problemas resuelve Composer?
Tienes un proyecto que depende de ciertas librerías desarrolladas por terceros, y a su
vez, éstas librerías también dependen de otras (tú no tienes porqué conocer estas
librerías), lo que hace Composer en este caso es averiguar que librerías deben instalarse;
es decir, resuelve todas las dependencias indirectas y descarga automáticamente la
versión correcta de cada paquete.
Instalación.
Página de descarga
https://getcomposer.org/download/
  Blade, Motor de plantillas4 5
 Peticiones Fluent6
 Eloquent ORM7
 Basado en Composer8
 Soporte para el caché9
 Soporte para MVC10
 Usa componentes de Symfony11
 Adopta las especificacione PSR-212 y PSR-413 14

Laravel propone en el desarrollo usar 'Routes with Closures', en lugar de un MVC

tradicional con el objetivo de hacer el código más claro. Aun así permite el uso de MVC
tradicional.

3 Desarrollo en laravel 5.4

Preparación de la BD en postgreSQL
Verificamos que estén operando correctamente los servidores web y de base de datos:

2.4 Laravel
Laravel tiene como objetivo ser un framework que permita el uso de una
sintaxis elegante y expresiva para crear código de forma sencilla y permitiendo multitud
de funcionalidades. Intenta aprovechar lo mejor de otros frameworks y aprovechar las
características de las últimas versiones de PHP.

Gran parte de Laravel está formado por dependencias, especialmente de Symfony, esto
implica que el desarrollo de Laravel dependa también del desarrollo de sus
dependencias.

 Características[editar]
 Sistema de ruteo, también RESTful3
En un navegador le damos la siguiente dirección para iniciar un administrador de
posgresql
http://127.0.0.1:81/phppgadmin/

Usando el menú de Roles creamos el usuario pgarcia:

Usando el menú de Bases de datos creamos la base de datos bd_agenda, indicando que
pertenece al usuario pgarcia y que estará dentro del tablespace ts_agenda:

Usando el menú de Tablespaces creamos el espacio para tablas ts_agenda, en una

carpeta previamente creada c:\tablespace_agenda, indicando que pertenece al usuario
pgarcia:
 Crear proyecto. Si ve algo como la última pantalla es que se
Crearemos el proyecto usando composer: generó correctamente el proyecto, creando la
siguiente estructura de directorios:
composer create-project laravel/laravel agenda 5.4.* --prefer-dist

(Nota: agregue php.exe al path set path=%path%;"c:\Bitnami\wappstack-

5.6.29-1\php\")
Importante! Verifique que su carpeta tenga permisos de escritura (Esto podría
provocarle el error 500 del servidor web).

Configurando el acceso al DBMS (postgreSQL)

Laravel tiene un enfoque consistente para manejar los ajustes de configuración, y se
pueden aplicar diferentes ajustes en diferentes entornos mediante el uso de un archivo
.env, que contiene opciones únicas para ese ambiente.

Configuramos el archivo de ambiente ubicado en

.\.env
Modificamos a:

DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=bd_agenda
DB_USERNAME=pgarcia
DB_PASSWORD=******

Configuramos el archivo de acceso a la base de datos ubicado en

config\database.php

Modificamos estas secciones:

Configurando el espacio de nombres (debemos estar en el directorio raíz del proyecto):
'default' => env('DB_CONNECTION', 'pgsql'),
php artisan app:name Agenda Y esta otra:

'pgsql' => [
'driver' => 'pgsql',
'host' => env('DB_HOST', '127.0.0.1'),
 'database' => env('DB_DATABASE', 'bd_agenda'), <?php
'username' => env('DB_USERNAME', 'pgarcia'),
'password' => env('DB_PASSWORD', '******'), use Illuminate\Support\Facades\Schema;
'charset' => 'utf8', use Illuminate\Database\Schema\Blueprint;
'prefix' => '', use Illuminate\Database\Migrations\Migration;
'schema' => 'public',
], class CreateAmigosTable extends Migration
{
/**
Crear los Modelos y sus respectivas tablas * Run the migrations.
*
Usamos el comando:
* @return void
*/
php artisan make:model Amigo –mc –resource
public function up()
{
Para generar en un solo paso el modelo, migración y controlador: Schema::create('amigos', function (Blueprint $table) {
 El modelo representa la clase mediante la cual se acceden a los datos $table->increments('id');
 La migración especifica el nombre y los campos de la tabla $table->timestamps();
});
 El controlador establece un método para cada acción posible con el modelo. }

/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('amigos');
Se generaron los archivos: }
}
Modelo: app\Amigo.php

<?php Controlador: app\Http\Controllers\AmigoController.php

namespace Agenda; <?php
namespace Agenda\Http\Controllers;
use Illuminate\Database\Eloquent\Model;
use Agenda\Amigo;
class Amigo extends Model use Illuminate\Http\Request;
{
} class AmigoController extends Controller
{
/**
Migración: * Display a listing of the resource.
*
database\migrations\2017_06_22_024304_create_amigos_table.php * @return \Illuminate\Http\Response
 */ *
public function index() * @param \Illuminate\Http\Request $request
{ * @param \Agenda\Amigo $amigo
} * @return \Illuminate\Http\Response
*/
/** public function update(Request $request, Amigo $amigo)
* Show the form for creating a new resource. {
* //
* @return \Illuminate\Http\Response }
*/
public function create() /**
{ * Remove the specified resource from storage.
} *
* @param \Agenda\Amigo $amigo
/** * @return \Illuminate\Http\Response
* Store a newly created resource in storage. */
* public function destroy(Amigo $amigo)
* @param \Illuminate\Http\Request $request {
* @return \Illuminate\Http\Response //
*/ }
public function store(Request $request) }
{
}
Modificamos este archivo en base a los requerimientos de relación con otros modelos,
/** como podría ser de uno a muchos. También especificamos los campos que podrán ser
* Display the specified resource. rellenados. En este caso no agregamos ningún tipo de relación, solo los campos
*
* @param \Agenda\Amigo $amigo rellenables:
* @return \Illuminate\Http\Response
*/ <?php
public function show(Amigo $amigo) namespace Agenda;
{ use Illuminate\Database\Eloquent\Model;
} class Amigo extends Model
{ // El valor de la llave primaria es id, si se cambia se debe
/** // indicar como sigue:
* Show the form for editing the specified resource. protected $primaryKey = 'amigo_id';
*
* @param \Agenda\Amigo $amigo //Se especifican los campos que serán editables
* @return \Illuminate\Http\Response protected $fillable = ['nombre_tx', 'edad_n', 'sueldo_n',
*/ 'local_yn'];
public function edit(Amigo $amigo) }
{
}
Ahora editamos el archivo
/** database\migrations\2017_06_22_024304_create_amigos_table.php para
* Update the specified resource in storage.
agregar los campos y relaciones necesarias:
 : database\seeds\TablaAmigosSeeder.php
:
public function up() En este archivo agregamos los registros con los cuales poblaremos la tabla, nos debe
{
quedar:
Schema::create('amigos', function (Blueprint $table) {
$table->increments('amigo_id'); <?php
$table->string('nombre_tx')->nullable();
$table->integer('edad_n')->nullable(); use Illuminate\Database\Seeder;
$table->decimal('sueldo_n',5,2)->nullable();
$table->boolean('local_yn')->nullable(); class TablaPersonasSeeder extends Seeder
{
/**
$table->timestamps(); * Run the database seeds.
}); *
} * @return void
*/
public function run()
Ahora generamos las tablas: {
//En esta sección elegimos que registros itroduciremos
DB::table('amigos')->insert([
php artisan migrate --database=pgsql ['amigo_id' => 1, 'nombre_tx' => "Hugo", 'edad_n'=>30,
'sueldo_n'=>120.50, 'local_yn'=>'true' ],
['amigo_id' => 2, 'nombre_tx' => "Memo", 'edad_n'=>46,
'sueldo_n'=>220.00, 'local_yn'=>'false'],
['amigo_id' => 3, 'nombre_tx' => "Toño", 'edad_n'=>45,
'sueldo_n'=>570.60, 'local_yn'=>'true' ],
['amigo_id' => 4, 'nombre_tx' => "Carlos", 'edad_n'=>53,
'sueldo_n'=>220.70, 'local_yn'=>'false'],
['amigo_id' => 5, 'nombre_tx' => "Lalo", 'edad_n'=>38,
'sueldo_n'=>490.81, 'local_yn'=>'true' ],
]);
}
}

Editamos el archivo:
database\seeds\DatabaseSeeder.php

Agregando la línea $this->call(’TablaAmigosSeeder’); quedando el archivo como se

muestra a continuación:
<?php
Poblar Tablas <?php

Poblar Tabla amigos use Illuminate\Database\Seeder;

Crearemos un método para insertar algunos registros en la tabla amigos. class DatabaseSeeder extends Seeder
{
php artisan make:seeder TablaAmigosSeeder /**
* Run the database seeds.
*
Este comando nos genera el archivo:
 * @return void
*/ Poblar Tablas con Datos Falso (librería Faker)
public function run()
{
Una parte tediosa es generar los suficientes registros para probar nuestro sistema,
// $this->call(UsersTableSeeder::class); podemos requerir decenas, cientos o miles de registros. La librería Faker nos ayudar en
$this->call('TablaAmigosSeeder');
} la generación automática de datos para insertarla en nuestras tablas.
}

Poblar la Base de Datos Modificamos el archivo database\seeds\TablaAmigosSeeder.php para indicarle

Ahora usamos el siguiente comando para poblar la tabla: cuantos registros queremos generar:

php artisan db:seed <?php

use Illuminate\Database\Seeder;
use Agenda\Amigo;

class TablaAmigosSeeder extends Seeder

{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
// En esta sección elegimos que registros itroduciremos
/*
DB::table('amigos')->insert([
['amigo_id' => 1, 'nombre_tx' => "Hugo", 'edad_n'=>30,
Ahora nuestro Modelo Amigo está asociado a la tabla amigos y ya tiene datos!. 'sueldo_n'=>120.50, 'local_yn'=>'true' ],
['amigo_id' => 2, 'nombre_tx' => "Memo", 'edad_n'=>46,
'sueldo_n'=>220.00, 'local_yn'=>'false'],
['amigo_id' => 3, 'nombre_tx' => "Toño", 'edad_n'=>45,
'sueldo_n'=>570.60, 'local_yn'=>'true' ],
['amigo_id' => 4, 'nombre_tx' => "Carlos", 'edad_n'=>53,
'sueldo_n'=>220.70, 'local_yn'=>'false'],
['amigo_id' => 5, 'nombre_tx' => "Lalo", 'edad_n'=>38,
'sueldo_n'=>490.81, 'local_yn'=>'true' ],
]);
*/

// Esta comando es para la generación automática de registros

factory(Amigo::class,100)->create();
}
}

Modificamos el archivo database\factories\ModelFactory.php para especificar los tipos

de datos y rango de los datos que se van a generar aleatoriamente. Quedándonos:
<?php En laravel 5.4 tenemos que hacer una configuración extra en el archivo
/* app\Providers\AppServiceProvider.php para especificar la longitud máxima de una
|--------------------------------------------------------------------------
| Model Factories cadena de texto. Procedemos a efectuar las modificaciones:
|--------------------------------------------------------------------------
| <?php
| Here you may define all of your model factories. Model factories give
| you a convenient way to create models for testing and seeding your namespace Agenda\Providers;
| database. Just tell the factory how a default model should look.
| use Illuminate\Support\ServiceProvider;
*/ use Illuminate\Support\Facades\Schema;

/** @var \Illuminate\Database\Eloquent\Factory $factory */ class AppServiceProvider extends ServiceProvider

$factory->define(Agenda\User::class, function (Faker\Generator $faker) { {
static $password; /**
* Bootstrap any application services.
return [ *
'name' => $faker->name, * @return void
'email' => $faker->unique()->safeEmail, */
'password' => $password ?: $password = bcrypt('secret'), public function boot()
'remember_token' => str_random(10), {
]; //
}); Schema::defaultStringLength(191);
}
$factory->define(Agenda\Amigo::class, function (Faker\Generator $faker) {
return [ /**
'nombre_tx' => $faker->name, * Register any application services.
'edad_n' => $faker->numberBetween(18,70), *
'sueldo_n' => $faker->randomFloat(2,10,999), * @return void
'local_yn' => $faker->boolean, */
]; public function register()
}); {
//
}
Tenga la precaución de verificar que los campos a rellenar sean los mismos especificados }

en el Modelo Amigo. Mostramos el modelo para verificar esto:

<?php Ahora procedemos a repoblar la tabla amigos mediante el siguiente comando:
namespace Agenda;

use Illuminate\Database\Eloquent\Model;

class Amigo extends Model

{ // El valor de la llave primaria es id, si se cambia se debe
// indicar como sigue:
protected $primaryKey = 'amigo_id';

//Se especifican los campos que serán editables

protected $fillable = ['nombre_tx', 'edad_n', 'sueldo_n', 'local_yn'];
}
 Controlador

Así, nuestra tabla ya tiene 100 registros! Modelo

Vista

Archivos para el modelo MVC.

Veamos la estructura del proyecto que se generó: En esta estructura están contenidos los archivos correspondientes al MVC (Modelo Vista
Controlador) y aún más herramientas. Por ahora destacamos las correspondientes al
MVC.
 *
Creando el controlador * @return \Illuminate\Http\Response
*/
El controlador responde a eventos (usualmente acciones del usuario) e invoca peticiones public function index()
{
al 'modelo' cuando se hace alguna solicitud sobre la información (por ejemplo, editar un //
documento o un registro en una base de datos). También puede enviar comandos a su }
'vista' asociada si se solicita un cambio en la forma en que se presenta el 'modelo'. Por
/**
tanto, se podría decir que el 'controlador' hace de intermediario entre la 'vista' y el * Show the form for creating a new resource.
'modelo' (véase Middleware). *
* @return \Illuminate\Http\Response
*/
Revisamos el archivo controlador que generamos previamente, public function create()
app\Http\Controllers\AmigoController.php : {
//
}
Si todo sale bien, se genera el controlador y además todos los métodos que necesitamos
utilizar. Intuitivamente, cada método nos dice por su nombre qué debemos hacer: /**
* Store a newly created resource in storage.
 index: Lo utilizaremos para mostrar la página inicial. *
 create: Lo utilizaremos para mostrar el formulario de registro. * @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
 store: Este método es importante, lo usaremos para recuperar los datos escritos */
en el formulario y lo guardaremos en nuestra base de datos. public function store(Request $request)
{
 show. Despliega un amigo en particular.
//
 edit: Con este método mostraremos el formulario de edición. }
 update: Con este método editaremos el registro.
/**
 destroy: Lo utilizaremos para eliminar a un amigo. * Display the specified resource.
*
* @param int $id
Identificamos los puntos anteriores en el archivo:
* @return \Illuminate\Http\Response
*/
app\Http\Controllers\AmigoController.php
public function show($id)
<?php {
//
namespace Agenda\Http\Controllers; }

use Illuminate\Http\Request; /**

* Show the form for editing the specified resource.
class AmigoController extends Controller *
{ * @param int $id
/** * @return \Illuminate\Http\Response
* Display a listing of the resource. */
 public function edit($id)
{ 1.2 CRUD.
// Efectuaremos cada uno controladores
}

/** Listado de amigos (método index).

* Update the specified resource in storage. Para listar a los amigos, tenemos que llamar al modelo desde nuestro controlador, y
*
* @param \Illuminate\Http\Request $request luego utilizar un poco de la magia de eloquent.
* @param int $id
* @return \Illuminate\Http\Response Modelo: será la representación de nuestra tabla, Laravel nos permite manejar la tabla
*/
public function update(Request $request, $id) como un objeto.
{
//
Editamos el archivo AmigoController.php, agregando el Modelo Agenda\Amigo y
}
reescribiendo el método index():
/**
* Remove the specified resource from storage. <?php
*
* @param int $id namespace Agenda\Http\Controllers;
* @return \Illuminate\Http\Response
*/ use Agenda\Amigo;
public function destroy($id) use Illuminate\Http\Request;
{ use Exception;
//
} class AmigoController extends Controller
} {
/**
* Display a listing of the resource.
1.1 Planeación de las rutas: *
* @return \Illuminate\Http\Response
*/
Las rutas se encargan de analizar las URLs y asignarlas a un método o función, así
public function index()
asociaremos una ruta a cada acción del controlador: {
$amigos = Amigo::all();
Verbo Ruta Acción Nombre de Ruta return view('index', compact('amigos'));
GET /amigo index amigo.index }
GET /amigo/create create amigo.create :
POST /amigo amigo.store :
store
GET /amigo/{id} show amigo.show
GET /amigo/{id}/edit edit amigo.edit En el paso anterior mandamos a todos los usuarios a la vista, pero ahora nos falta
PUT/PATCH /amigo/{id} update amigo.update manipular esta información en la vista y mostrarlas. ¡Veremos trabajar a Blade! Desde
DELETE /amigo/{id} destroy amigo.destroy nuestro controlador, enviamos una variable llamada data a la vista index.blade.php.
Tenemos que recoger esa variable y decirle lo siguiente:
  Si la variable $data tiene contenido pinta la tabla. /*
|-----------------------------------------------------------------
 Una vez dentro de la condición, hacemos un recorrido @foreach ---------
 Este recorrido comenzará a mostrar fila x fila los usuarios registrados de la tabla. | Web Routes
|-----------------------------------------------------------------
---------
Procedemos a crear el archivo: |
| Here is where you can register web routes for your application.
resources\views\index.blade.php These
| routes are loaded by the RouteServiceProvider within a group
<h1>Lista de Amigos</h1> which
<h4><a href="{{route('amigos.create')}}">Registrar nuevo | contains the "web" middleware group. Now create something great!
amigo</a></h4> |
@if($amigos) */
<table border>
<thead> Route::get('/', function () {
<td>Nombre</td> return view('welcome');
<td>Edad</td> });
<td>Sueldo</td>
<td>local</td> Route::resource('amigos', 'AmigoController@index');
</thead>
<tbody>
@foreach ($amigos as $amigo)
<tr>
<td>{{$amigo->nombre_tx}}</td> Una vez realizado estos pasos, puedes abrir tu proyecto en el explorador con la URL:
<td>{{$amigo->edad_n}}</td> http://localhost/agenda/public/amigos
<td>${{$amigo->sueldo_n}}</td>
<td>{{$amigo->local_yn}}</td>
<td> <a href="{{ route('amigos.edit',$amigo- Dándonos la siguiente página:
>amigo_id)}}"> Editar </a></td>
<td> <a href="{{ route('amigos.destroy',$amigo-
>amigo_id)}}"> Borrar </a></td>
</tr>
@endforeach
</tbody>
</table>
@endif

Para nuestro ejemplo de CRUD usaremos una ruta resource. Procedemos a modificar el
archivo:

routes\web.php

<?php
 @if($amigo)
<h1>Amigo: {{$amigo->nombre_tx}} </h1>

<table border>
<thead>
<td>Edad</td>
<td>Sueldo</td>
<td>local</td>
</thead>
<tbody>
<tr>
<td>{{$amigo->edad_n}}</td>
<td>${{$amigo->sueldo_n}}</td>
<td>{{$amigo->local_yn}}</td>
<td> <a href="{{ route('amigos.edit',$amigo-
>amigo_id)}}"> Editar </a></td>
<td> <a href="{{ route('amigos.destroy',$amigo-
>amigo_id)}}"> Borrar </a></td>
</tr>
</tbody>
</table>
@endif

Una vez realizado estos pasos, puedes abrir tu proyecto en el explorador con la URL,
donde el 25 puede ser cualquier id válido:
Mostrar un solo amigo (método show).
Para mostrar a un amigos editamos el archivo AmigoController.php reescribiendo el http://localhost/agenda/public/amigo/25
método show():
Dándonos la siguiente página:
:
:
public function show($id)
{
$amigo = Amigo::find($id);
return view('show', compact('amigo'));
}
:
:

Ahora debemos construir la vista que mostrará los datos recuperados del amigo al que
pertenece el id. Procedemos a crear el archivo:

resources\views\show.blade.php
Registro de amigos (método create). El formulario resultante es:
Para registrar a los amigos dividiremos la explicación en dos, la primera parte de como
mostrar un formulario en una vista, y la segunda parte de como guardar los datos
escritos desde el formulario en la tabla amigos.

Formulario de la tabla amigos

Editamos el archivo AmigoController.php reescribiendo el método create():
:
:
public function create()
{
//
return view('create');
}
:
:

Ahora debemos construir el formulario. Procedemos a crear el archivo:

resources\views\create.blade.php

<h1>Registro de Amigos</h1> Registrando en la tabla amigos

<form action="/agenda/public/amigos" method="post">
<input type="hidden" name="_token" value="{{ csrf_token()
}}">
<label >Nombre</label>
<input type="text" name="nombre" placeholder="Nombre" />
Tenemos que recoger los valores del formulario e ingresarlos a la tabla amigos. Como
verás en el método store, uso un try - catch para controlar la acción del guardar. Esto no
es del todo necesario, pero siempre es importante controlar los errores por si algo llega
a romperse. En la parte superior he agregado use Exception; Si todo registró
correctamente lo re direccionó a la lista de usuarios.

<label >Edad</label> Editamos el archivo AmigoController.php reescribiendo el método store():

<input type="text" name="edad" placeholder="Edad" />
:
<label >Sueldo</label> :
<input type="text" name="sueldo" placeholder="Sueldo" /> public function store(Request $request)
{
<label >Vive en la ciudad?</label> //
<input type="text" name="local" placeholder="0 o 1" /> try {
$amigo= new Amigo();
<button type="submit">Registrar</button> $amigo->nombre_tx=$request->nombre;
</form> $amigo->edad_n=$request->edad;
$amigo->sueldo_n=$request->sueldo;
$amigo->local_yn=$request->local;
 $amigo->save(); :
return redirect->route(amigos.index); public function edit($id)
} catch (Exception $e) { {
return "Error fatal: ".$e.getMessage(); $amigo=Amigo::findOrFail($id);
} return view('edit',compact('amigo'));
}
}
: /**
: * Update the specified resource in storage.
*
* @param \Illuminate\Http\Request $request
Al dar click en el botón agregar, efectúa la acción de insertar el registro en la base de * @param int $id
* @return \Illuminate\Http\Response
datos y retorna a la página de index donde nos muestra al final el registro insertado: */
public function update(Request $request, $id)
{
$amigo= Amigo::findOrFail($id);
$amigo->nombre_tx=$request->nombre;
$amigo->edad_n=$request->edad;
$amigo->sueldo_n=$request->sueldo;
$amigo->local_yn=$request->local;
$amigo->save();
return redirect()->route('amigos.index');

}
:
:

Formulario de edición para un registro de la tabla amigos

Ahora debemos construir el formulario. Procedemos a crear el archivo:

resources\views\edit.blade.php

<h1>Edición de un Amigo</h1>
Editar un registro (método edit).
Para editar a un amigo primero recuperamos la información del amigo a editar según su <form method="post" action="/agenda/public/amigos/{{$amigo-
id, y despúes guardamos los cambios escritos desde el formulario en la tabla amigos. >amigo_id}}" >

<input type="hidden" name="_method" value="PUT">

Escribir en el controlador el código para editar y actualizar
Editamos el archivo AmigoController.php reescribiendo el método edit($id) y el método <input type="hidden" name="_token" value="{{ csrf_token()
}}">
update(REquest $request, $id):
: <label >Nombre</label>
 <input type="text" name="nombre" placeholder="Nombre"
value="{{$amigo->nombre_tx}}" /> <br/>

<label >Edad</label>
<input type="text" name="edad" placeholder="Edad"
value="{{$amigo->edad_n}}"/> <br/>

<label >Sueldo</label>
<input type="text" name="sueldo" placeholder="Sueldo"
value="{{$amigo->sueldo_n}}"/> <br/>

<label >Vive en la ciudad?</label>

<input type="text" name="local" placeholder="0 o 1"
value="{{$amigo->local_yn}}"/> <br/>

<button type="submit">Actualizar</button>
</form>

Para ver el formulario resultante cargamos la página de index luego seleccionamos un

registro dándole click en el link Editar:

Ahora procedemos a editar los campos que queramos:

Después de actualizar nos redirige a la página index, donde podemos apreciar que se ha $amigo->delete();
return redirect()->route('amigos.index');
llevado a cabo la actualización del registro: } catch (Exception $e) {
return "Error fatal: ".$e.getMessage();
}

}
:
:

Editamos el archivo index.blade.php para cambiar el link de borrar por el botón de

borrar. Esto es necesario para poderle manda r el verbo DELETE y el controlador pueda
redirigirlo correctamente al método destroy :
:
:
@foreach ($amigos as $amigo)
<tr>
<td>{{$amigo->nombre_tx}}</td>
<td>{{$amigo->edad_n}}</td>
<td>${{$amigo->sueldo_n}}</td>
<td>{{$amigo->local_yn}}</td>
<td> <a href="{{ route('amigos.edit' , $amigo-
Eliminar un registro de la tabla amigos >amigo_id)}}"> Editar </a></td>
Para eliminar un registro, solo damos click en el botón Borrar correspondiente al <td>
<form action="{{ route('amigos.destroy', $amigo-
registro que pretendemos eliminar. >amigo_id)}}" method="post">
<input name="_method" type="hidden" value="DELETE">
Escribir en el controlador el código para eliminar <input name="_token" type="hidden" value="{{
Editamos el archivo AmigoController.php reescribiendo el método destroy($id) : csrf_token() }}">
<button type="submit"> Borrar </a>
: </form>
: </td>
/** </tr>
* Remove the specified resource from storage. @endforeach
* :
* @param int $id :
* @return \Illuminate\Http\Response
*/
public function destroy($id)
{
try {
$amigo=Amigo::findOrFail($id);
echo "Registro eliminado: ".$id;
Le damos click al primer registro y vemos como desaparece y se redirige a la página index: En el siguiente manual nos dedicaremos a darle un formato más vistoso con el uso de la librería
de bootstrap.