Curso Básico de Laravel - Terminado Apuntes PDF

Tecnológico Nacional de México
Instituto Tecnológico Superior de Puruándiro
División de Ingeniería en Tecnológias de la

Información y Comunicaciones
Curso
Framework Laravel Básico
Introducción
Bienvenido al Curso Básico de Laravel, en esta ocasión explicaremos los fundamentos del
framework Laravel a partir de la versión 5.5 LTS, incluyendo el ORM Eloquent, su sistema
de migraciones, seeders y constructor de consultas, el sistema de plantillas Blade, rutas,
controladores y mucho más; estos fundamentos son compatibles con las versiones siguientes
del framework.
Para finalizar el curso crearemos un sencillo pero funcional módulo CRUD de usuarios que
podrás implementar en tus proyectos.
Curso: Framework Laravel Básico 2

Curso básico
Framework Laravel
Tabla de contenido
Primeros pasos con Laravel ............................................................................ 5
Instalación de Composer y Laravel .................................................................................... 5
Introducción a Laravel ....................................................................................................... 8
Rutas con Laravel ............................................................................................................. 10
Pruebas ............................................................................................................................. 12
Controladores en Laravel ................................................................................................. 15
Vistas ............................................................................................................... 18
Vistas en Laravel .............................................................................................................. 18
Blade, el Sistema de plantillas de Laravel........................................................................ 20
Layouts con Blade ............................................................................................................ 25
Manejo de Bases de datos con Laravel ........................................................ 29
Introducción a las bases de datos y migraciones con Laravel .......................................... 29
Modificar tablas ya existentes con las migraciones de Laravel ....................................... 35
Crear y asociar tablas usando las migraciones de Laravel (con claves foráneas) ............ 39
Inserción de datos con los seeders de Laravel.................................................................. 43
Constructor de consultas SQL de Laravel ........................................................................ 48
Introducción a Eloquent, el ORM del framework Laravel............................................... 53
Usando Eloquent ORM de forma interactiva con Tinker ................................................ 57
Manejo de atributos en Eloquent ORM (solución a MassAssignmentException) ........... 61
Manejo de relaciones con el ORM Eloquent ................................................................... 64
Generar registros usando Model Factories en Laravel ..................................................... 67
Módulo CRUD de usuarios: listado básico y detalles ................................. 72
Módulo de usuarios con Laravel ...................................................................................... 72
Listado dinámico de Usuarios con Laravel (Módulo CRUD).......................................... 72

Configuración y uso de base de datos en el entorno de pruebas automatizadas con Laravel
y PHPUnit ........................................................................................................................ 74
Detalles o Perfil de Usuario con Laravel (Módulo CRUD) ............................................. 76
Generar URLs en Laravel ................................................................................................ 77
Manejo de errores 404 en Laravel .................................................................................... 80
Enlace de modelos a rutas en Laravel .............................................................................. 81
Módulo CRUD de usuarios: creación .......................................................... 83
Rutas con POST y protección contra ataques de tipo CSRF en Laravel.......................... 83
Creación de usuarios con Laravel y TDD ........................................................................ 85
Creación de formulario para agregar usuarios con Laravel ............................................. 88
Validar datos de peticiones HTTP con Laravel (TDD).................................................... 90
Mostrar mensajes de errores de validación con Laravel .................................................. 92
Uso de múltiples reglas de validación en Laravel ............................................................ 95
Módulo CRUD de usuarios: actualización .................................................. 98
Formulario para la edición de usuarios en Laravel .......................................................... 98
Actualización de Usuarios con Laravel (TDD) ................................................................ 99
Reglas de validación para la actualización de usuarios con Laravel y TDD ................. 101
Campo opcional de contraseña en Laravel ..................................................................... 102
Validar que el e-mail sea único cuando se edita un usuario con Laravel....................... 103
Módulo CRUD de usuarios: eliminación ............................................................. 105
Eliminar registros con Laravel y TDD ........................................................................... 105
Agregando enlaces al módulo de usuarios ..................................................................... 107
Agregando estilos de Bootstrap 4 ............................................................... 109
Agregar estilos de Bootstrap 4 al listado de usuarios en Laravel................................... 109
Agregar estilos de Bootstrap 4 al formulario en Laravel ............................................... 110

Primeros pasos con Laravel
En la primer parte del curso se muestra la instalación del manejador de dependencias de PHP
llamado Composer y con ayuda de éste instalaremos el Framework Laravel. Además daremos
nuestros primeros pasos con Laravel, crearemos las primeras rutas y las probaremos en el
navegador y también de forma automatizada con un pequeño ejemplo en PHPUnit.
Instalación de Composer y Laravel

Para desarrollar aplicaciones de PHP con Laravel necesitamos primero instalar y configurar
un conjunto de herramientas que nos facilitan el trabajo de creación de nuevas aplicaciones.
Por un lado, requerimos tener un entorno de desarrollo en nuestro equipo que cumpla con los
requerimientos del framework y por otro, es recomendable configurar y conocer las formas
de acceder a una aplicación creada en dicho entorno. En esta primera lección te guiaremos
para que prepares tu equipo y así empieces a desarrollar con Laravel.
Preparación del entorno de desarrollo

Para desarrollar con Laravel puedes hacerlo desde Windows, Linux o MacOs siempre que
tengas un servidor web con PHP 7 o superior.
A esto nosotros le llamamos entorno de desarrollo y existe una gran variedad de ellos, cada
uno con un nivel de complejidad distinto al otro, desde el más básico instalando manualmente
Apache o Nginx, PHP, MySQL, etc., así como instalar herramientas como XAMPP, WAMP,
MAMP, etc., hasta otras más complicadas como Laravel Homestead
Sin embargo, recomendamos las siguientes opciones para quienes estén iniciando, por su
facilidad de instalación y uso:
• En Windows puedes usar: Laragon, un entorno de desarrollo para Laravel en Windows

• En Linux: Instalación de Laravel Valet en Linux
• En MacOs: Laravel Valet

Por otro lado, Laravel utiliza Composer para manejar sus dependencias. ¿Qué significa esto?
Pues el framework Laravel hace uso de una colección de paquetes o componentes propios y
de terceros para agregarle funcionalidades a las aplicaciones. Por tanto, necesitamos un
gestor de dependencias que se encargue automáticamente de crear proyectos, instalar,
actualizar o eliminar componentes y a su vez las dependencias de éstos. Esta herramienta es
Composer, el manejador de dependencias de PHP.
Instalarlo depende del sistema operativo que uses si es MacOs o Linux se tiene que descargar
el archivo composer.phar con las instrucciones del sitio oficial y luego mover dicho archivo
para que esté de forma global y así usar la herramienta desde cualquier directorio, siguiendo
las instrucciones oficiales de Composer.
Para Windows puedes descargar el instalador que ofrece Composer en su sitio web que se
encargará de instalarlo para que lo puedas usar en cualquier parte del sistema. Si has decidido
trabajar con Laragon no necesitas realizar esta instalación, puesto que viene incluido por
defecto en este entorno de desarrollo.
Puedes confirmar si tienes bien instalado Composer ejecutando en la consola desde cualquier
directorio: composer y en caso de estar instalado, te mostrará un listado de todos los
comandos disponibles.
Instalación de Laravel
Una vez listo el entorno de desarrollo, usaremos Composer para instalar Laravel de esta
manera:
composer create-project --prefer-dist laravel/laravel mi-proyecto
Lo que significa que estamos creando un nuevo proyecto llamado mi-proyecto con el
comando create-project de Composer a partir del paquete laravel/laravel, usando la
opción --prefer-dist para que Composer descargue los archivos del repositorio de
distribución.

Hay una alternativa para instalar Laravel y es con su instalador, que también es un paquete,
por tanto, también usaremos Composer para instalarlo de forma global con el comando:
composer global require "laravel/installer"
Luego, nos tenemos que asegurar que la variable de entorno PATH del sistema operativo
tenga incluido el directorio donde se alojan los paquetes instalados globalmente y así se
puedan ejecutar sin ningún problema, para ello debemos agregar su ruta:
• Para MacOs y Linux la variable PATH la podemos definir en: ~/.bashrc o ~/.bash_profile
donde la ruta a añadir al final de lo que tiene asignado la variable es:
:$HOME/.composer/vendor/bin
• Para Windows debes modificar la variable de entorno PATH para agregar la ruta
;C:\Users\tu-usuario\AppData\Roaming\Composer\vendor\bin
Bien, de esta manera ya tenemos disponible el instalador de Laravel, por tanto, podemos
ejecutar desde cualquier directorio:
laravel new nombre-proyecto
y se instalará tal y como se hizo con el comando composer create-project.
Abrir la aplicación creada

Para ver y navegar por la aplicación recién creada podemos ejecutar el comando dentro del
proyecto:
php artisan serve
Este comando ejecuta la aplicación en un servidor de desarrollo incluido por defecto en

Laravel. Por tanto debemos hacer clic en la URL que nos muestra para explorar la aplicación
en el navegador.

• En Linux y MacOs podemos acceder al proyecto mediante la URL: http://mi-proyecto.test
• En Windows podemos acceder al proyecto mediante la URL: http://127.0.0.1:8000
Para detener la ejecución presiona Ctrl + C
Nota:
Si estás usando el entorno de desarrollo Laravel Valet (tanto para Linux como para MacOs)
o Laragon, estás herramientas crean un virtualhost por defecto por cada proyecto según el
nombre de la carpeta. Así para nuestro proyecto creado podemos visitar en el navegador
http://mi-proyecto.dev y podrás ver la aplicación funcionando.
Introducción a Laravel
Laravel es un framework para el desarrollo de aplicaciones web con PHP que nos permite
construir aplicaciones modernas con una sintaxis elegante y expresiva. Éste fue creado por
Taylor Otwell en el 2011 y a la fecha de publicación de este curso va por la versión 5.5. Para
empezar a trabajar con Laravel necesitas preparar tu entorno de desarrollo, IDE o editor de
texto y otras herramientas como Composer que te ayudarán a instalar y desarrollar
aplicaciones web con este framework. En esta lección, daremos una breve introducción al
framework y aprenderás sobre el patrón de diseño Front Controller, el cual es usado por
Laravel para procesar todas las peticiones que se hacen a la aplicación.
Nota
Si la ruta del home / funciona pero ninguna otra y estás utilizando el Servidor Web Apache,
asegúrate de tener instalado y habilitada la extensión mod_rewrite.
Para instalar un nuevo proyecto de Laravel puedes hacerlo de 2 maneras: con el comando
create-project de Composer o con el instalador laravel new.
El instalador de Laravel solo nos permite instalar la versión actual del framework (opción
por defecto) y la versión en desarrollo con el comando laravel new mi-proyecto --dev

Así que si se quiere instalar Laravel en una versión que no sea la última versión, entonces se
debe usar el comando create-project que nos da la opción de poder especificar la versión
que queremos usar. De esta manera:
composer create-project laravel/laravel nombre-proyecto "5.5.*"
Por otro lado, algo clave para desarrollar eficientemente es tener un editor de texto o IDE
bien configurado que nos facilite el trabajo de escribir el código de nuestra aplicación. Hay
dos grandes grupos: IDE (Entorno de Desarrollo Integrado) y editores de texto. La diferencia
principal es que los primeros vienen por defecto con múltiples herramientas como:
autocompletado inteligente, resaltado de sintaxis, sistema de control de versiones, debugger,
entre otras herramientas configuradas y listas para empezar a trabajar. En cambio, los
editores de texto son más ligeros y no vienen con todas las herramientas u opciones listas por
defecto, sino que debes instalarlas y configurarlas por medio de plugins y extensiones.
Entre los IDEs para PHP tenemos a: PHPStorm, Zend Studio, Eclipse, NetBeans, Aptana
Studio, etc. Entre los editores de texto están: Sublime Text, Atom, Visual Studio Code,
NotePad++, etc.
El patrón de diseño Front Controller consiste en que un solo componente de la aplicación

es el responsable de manejar de todas las peticiones HTTP que ésta recibe. Es decir, hay un
solo punto de acceso para todas las peticiones.
En Laravel esta función la cumple el archivo index.php que se encuentra en el directorio

public. junto con el archivo .htaccess. Pues que -cuando usas el servidor web Apache-
este último archivo se encarga de redirigir todas las peticiones a index.php
El directorio public contiene además, las imágenes, archivos CSS y de Javascript que será
públicos para los usuarios y visitantes de la aplicación, el resto de archivos donde se
encuentra la lógica de la aplicación es inaccesible para ellos, es decir, son privados.

Rutas con Laravel
El sistema de Rutas de Laravel es bastante intuitivo y fácil de manejar, pero a la vez muy
potente, con éste podemos crear todo tipo de rutas en la aplicación: sencillas o complejas.
Las rutas son una capa muy importante en Laravel, es por ello que el Framework destina un
directorio en la carpeta raíz, llamado routes, para ubicar todas las rutas de la aplicación. Por
defecto, tiene 2 archivos de rutas web.php y api.php. Como sus nombres lo expresan en
web.php se definen las rutas para la web y en api.php las rutas para crear APIs para la
aplicación.
Podemos definir rutas de varias maneras, se puede implementar una función anónima, que
sigue el siguiente formato:
Se escribe la clase Route que llama al método relacionado con el verbo HTTP, en este caso,
get que acepta dos parámetros: el primero es la URL que se llamará desde el navegador y el
segundo es una función anónima que devuelve lo que queremos mostrar.
Para ver la ruta en funcionamiento debemos escribir en el navegador algo como:
http://tu-proyecto.test/esta-es-la-url
Esto dependiendo de VirtualHost que se haya creado para el proyecto. Si no lo tienes puedes
usar php artisan serve.

Rutas con parámetros
También con el sistema de rutas de Laravel puedes crear rutas más complejas que necesiten
de parámetros dinámicos. Se pueden definir de la siguiente forma:
En este caso Laravel se encarga de capturar el segmento de la ruta que es dinámico (lo
identifica porque está encerrado entre llaves). Por tanto, en la URL pasamos la identificación
del parámetro encerrado entre llaves y en la función anónima lo pasamos como argumento
para que pueda ser accedido y usado dentro de dicha función.
Se pueden usar tantos parámetros como sean necesarios, solo es importante que estén
encerrados entre llaves {} y los nombres pueden ser alfanuméricos pero no está permitido
usar el guión - pero sí el subrayado _. Además, es importante el orden de los parámetros que
se pasan a la función anónima, pero no los nombres que se les de. Por ejemplo:
Rutas con filtros o restricciones de expresiones regulares en los parámetros

Cuando un usuario hace una petición HTTP, Laravel busca en los archivos de rutas una
definición que coincida con el patrón de la URL según el método HTTP usado y en la primera
coincidencia le muestra el resultado al usuario. Por tanto el orden de precedencia de las
definiciones de rutas es muy importante.

Para solucionar los posibles conflictos con el parecido en la URL de distintas rutas puedes
hacerlo de 2 maneras:
• Usando el método where para agregar condiciones de expresiones regulares a la ruta.

• Ordenando las rutas de tal manera que las más específicas estén al principio y las más
generales al final del archivo de rutas.
Rutas con parámetros opcionales

Cuando el uso de un parámetro no es obligatorio, podemos usar el carácter ? después del
nombre del parámetro para indicar que es opcional. Sin embargo, debe añadirse un valor por
defecto al parámetro cuando lo colocamos en la función, por ejemplo:
Pruebas
Hasta el momento hemos aprendimos cómo escribir las primeras rutas de nuestra aplicación,
utilizamos el navegador para probar dichas rutas y URLs. El problema de estas pruebas en el
navegador es que no perduran en el tiempo ni pueden ejecutarse de forma rápida / automática.
Así que ahora veremos cómo se puede probar el código que desarrollemos de forma más
inteligente, utilizando el componente de pruebas automatizadas que viene incluido con
Laravel.

Directorio de pruebas
Laravel incluye en el directorio principal de tu proyecto un directorio llamado /tests. En
este directorio se escribe el código que se va a encargar de probar el código del resto de la
aplicación. Este directorio está separado en dos subdirectorios:
• El directorio Feature donde se escriben pruebas que emulan peticiones HTTP al servidor.
• El directorio Unit donde se escriben pruebas que se encargan de probar partes individuales
de la aplicación (como clases y métodos).
Escribiendo una prueba

En la siguiente prueba simularemos una petición HTTP GET a la URL del módulo de
usuarios. Con asserStatus comprobamos que la URL carga de forma correcta verificando
que el status HTTP sea 200. Con el método assertSee comprobamos que podemos ver el
texto «Usuarios»:

Para que PHPUnit ejecute el método como una prueba, debes colocar la anotación /** @test
*/ antes de la declaración del método o colocar el prefijo test_ en el nombre del método
como tal:
De lo contrario el método NO será ejecutado como una prueba, lo cual es útil porque nos
permite agregar métodos helpers dentro de nuestra clase de pruebas.
Notas
• El comando para generar nuevas pruebas es: php artisan make:test
NombreDeLaPruebaTest
• Puedes ejecutar las pruebas con vendor/bin/phpunit o crear un alias para la consola.
• Puedes leer sobre los métodos de aserciones disponibles en la documentación de Laravel.
Ejercicio
Crea una ruta, con su prueba correspondiente para editar usuarios (la URL debería tener el
formato /usuarios/{ID del usuario aquí}/edit).
Desafío adicional: La ID sólo debería aceptar enteros y deberías escribir una prueba para
comprobar que la URL /usuarios/texto/edit no es válida.

Controladores en Laravel
Los controladores son un mecanismo que nos permite agrupar la lógica de peticiones HTTP
relacionadas y de esta forma organizar mejor nuestro código. Ahora aprenderemos a hacer
uso de ellos y veremos además cómo las pruebas unitarias nos permiten verificar los cambios
que introducimos en nuestro código de forma fácil y rápida.
Generar un controlador
Generamos un nuevo controlador con el comando de Artisan make:controller pasándole
el nombre que queremos darle. En el ejemplo el nombre es UserController:
Hecho esto, en el directorio app/Http/Controllers tendremos nuestro controlador

UserController.
Métodos en el controlador
Un controlador no es más que un archivo .php con una clase que extiende de la clase
App\Http\Controllers\Controller:

Dentro de esta clase (en nuestro caso UserController) agregamos nuestros métodos públicos
(llamados acciones), que después podemos enlazar a una ruta:
Enlazar una ruta a un controlador

Para enlazar una ruta a un controlador pasamos como argumento el nombre del controlador
y del método que queremos enlazar, separados por un @. En este caso queremos enlazar la
ruta /usuarios al método index del controlador UserController:
Controlador de un solo método

Si se quiere tener un controlador que solo tenga una acción, se puede hacer llamando al
método __invoke, por ejemplo:

En nuestra ruta ahora podemos enlazar directamente al controlador:
Ejercicios
Mueve el código de la ruta para editar usuarios que creaste en el ejercicio de la lección pasada,
a una nueva acción edit dentro de UserController. Utiliza una prueba automatizada para
verificar que has hecho el cambio correctamente.
Desafío adicional: divide la ruta de saludo en 2 rutas diferentes que apunten a 2 acciones
diferentes, para de esta manera eliminar la necesidad de un condicional y el parámetro
opcional. Utiliza la prueba automatizada para verificar que has hecho el cambio
correctamente.

Vistas
En la segunda parte del curso aprenderemos a crear plantillas completas usando Laravel y su
motor de plantillas Blade. Veremos también la diferencia entre escribir plantillas con PHP
plano VS Blade, así como los temas de rendimiento y de seguridad para prevenir ataques
XSS.
Vistas en Laravel
Laravel también nos permite separar la lógica de presentación (es decir cómo vamos a
«presentar» el contenido al usuario) de la lógica de nuestra aplicación (por ejemplo cómo
vamos a obtener el contenido de la base de datos, validar datos de la petición, etc.) a través
de la capa de «vistas».
Crear una vista

Las vistas generalmente se encuentran en el directorio /resources/views de la carpeta
principal del proyecto. Crear una vista con Laravel es muy sencillo, simplemente necesitamos
crear un archivo .php (o .blade.php) en el directorio /views. Dentro de este archivo
escribimos el HTML de la vista.
Retornar una vista

Para retornar una vista retornamos el llamado a la función helper view pasando como
argumento el nombre de la vista. El nombre del archivo es relativo a la carpeta
resources/views y no es necesario indicar la extensión del archivo:

Pasar datos a la vista
Podemos pasar datos a la vista mediante un arreglo asociativo, donde las llaves son el nombre
de las variables que queremos pasar a la vista y el valor son los datos que queremos asociar:
También podemos usar el método with encadenándolo al llamado a la función view para
pasar datos a la vista en formato de array asociativo:
Con with también podemos pasar las variables de forma individual:

Si los datos que queremos pasar a la vista se encuentran dentro de variables locales podemos
utilizar la función compact, la cual acepta como argumentos los nombres de las variables y
las convierte en un array asociativo:
Escapar código HTML

Laravel nos ofrece un helper llamado e que nos permite escapar HTML que podría ser
insertado por los usuarios de nuestra aplicación, de manera de prevenir posibles ataques XSS:
Blade, el Sistema de plantillas de Laravel

Ahora comenzaremos a aprender sobre Blade, el sistema de plantillas de Laravel, el cual nos
provee de muchas características que deberíamos tener en un lenguaje de plantillas, como
por ejemplo la capacidad de escapar los datos de forma automática.
Nota:
Para utilizar el sistema de plantillas de Laravel debemos renombrar nuestras vistas para que
tengan la extensión .blade.php.

Imprimir variables
Si queremos imprimir una variable, podemos hacerlo utilizando la sintaxis de dobles llaves
{{ }}.
Ciclos y estructuras
Si queremos utilizar ciclos y estructuras condicionales, podemos utilizar directivas. Las
directivas de Blade van precedidas por un arroba (@) y luego el nombre de la directiva:
También podemos utilizar la directiva @if:

La directiva @if puede ser utilizada junto con un bloque else (utilizando @else):
Podemos utilizar la directiva @elseif, que como su nombre sugiere nos permite utilizar un
bloque else if:

Blade también tiene la directiva @unless, que funciona como un condicional inverso:
En el ejemplo anterior queremos mostrar el listado de usuarios a no ser que la lista esté vacia.
De lo contrario queremos mostrar el mensaje del bloque else.
También podemos utilizar la directiva @empty que es una forma más corta de escribir @if
(empty (...))
En este caso por supuesto invertimos los bloques dentro del condicional.

Además de @foreach, también podemos utilizar @for:
Con la directiva @forelse podemos asignar una opción por defecto a un ciclo foreach sin
utilizar bloques anidados:
Vistas en caché
Laravel compila y guarda en caché nuestras vistas, por lo que usar el motor de plantillas
Blade no afecta el rendimiento de nuestra aplicación. Puedes ver estas vistas compiladas en
el directorio /storage/framework/views.
Utilizando el comando view:clear podemos eliminar desde la terminal la vistas en caché:
Ejercicio
En UserController asigna y crea vistas para las otras acciones y practica pasando datos a
la vista.

Layouts con Blade
A medida que nuestro proyecto crece nuestras plantillas se vuelven más complejas y es
inevitable encontrarnos con que estamos repitiendo etiquetas y estructuras que podríamos
compartir entre multiples vistas. Es por ello que se va a usar Laravel Blade; para que de esta
manera puedas sacarle provecho a las diferentes directivas que ofrece este motor de plantillas
y evitar así la repetición de código HTML, además de mantener tus vistas sencillas,
expresivas, elegantes y bien estructuradas.
Nota:
Cuando trabajas con Laravel puedes utilizar Bootstrap, Materialize, Bulma o cualquier
framework de CSS o diseño personalizado.
Directiva @include
Blade incluye una directiva llamada @include. Para usarla solamente tenemos que pasarle
el nombre del archivo que queremos incluir:
Helper asset()
El helper asset nos dará la ruta absoluta al archivo indicado:
Utilizando este helper se puede evitar que la ruta del archivo cambie dependiendo de la URL.

Layout principal
En lugar de separar nuestra plantilla en diferentes archivos, podemos crear una sola plantilla
que tendrá toda la estructura de nuestro diseño. Podemos llamar a esta plantilla
layout.blade.php, por ejemplo, y colocar todo el código de nuestro diseño allí.
Utilizando la directiva @yield dentro de esta plantilla podemos indicar secciones (pasando
como argumento el nombre de la sección) y luego en plantillas individuales podemos colocar
el contenido de dichas secciones:
Nota:
Puedes nombrar tu layout de cualquier forma, siempre y cuando coloques la extensión
.blade.php. En este ejemplo se llama layout.blade.php.
Se pueden agregar tantas directivas @yield como quieras a tu layout. Por ejemplo, puedes
agregar una directiva yield para personalizar el título de la página:
Extender de una plantilla

En cada una de nuestras plantillas individuales en lugar de incluir el header o footer le
indicamos a Laravel que la vista debe extender de layout.blade.php. No es necesario
colocar la extensión del archivo. Tampoco es necesario colocar la ruta completa, ya que
Laravel por defecto buscará el archivo dentro del directorio resources/views:

Hecho esto, debemos definir las secciones. Para ello utilizamos la directiva @section,
pasando como argumento el nombre de la sección:
Indicamos el final o cierre de la sección con la directiva @endsection.
Nota:
La directiva @section define una sección de contenido, mientras que la directiva @yield es
usada para mostrar el contenido de una sección específica.
Dado que el titulo es una sola línea, podemos pasar el contenido como el segundo argumento
de @section:
El código que se encuentra entre comillas es PHP y no Blade, por lo que en lugar de utilizar
la sintaxis de dobles llaves {{ $id }} utilizaremos {$id} o simplemente $id.

Ejercicio
Crea un archivo menu.blade.php e incluyelo en el header del layout principal. Dentro del
archivo menu, crea un menú con enlaces a las diferentes rutas de la aplicación. Asegúrate de
ejecutar las pruebas para verificar que todo siga funcionando correctamente.

Manejo de Bases de datos con Laravel
En la tercera parte veremos una introducción al manejo de base de datos con Laravel,
usaremos la consola interactiva de Laravel, llamada Tinker, para probar el constructor de
consultas del Framework y su ORM Eloquent, crearemos nuestras primeras tablas,
insertaremos datos, realizaremos consultas, veremos una introducción al manejo de
relaciones entre tablas y registros con el framework y más.
Introducción a las bases de datos y migraciones con Laravel

Las bases de datos son uno de los aspectos más importantes de un proyecto. Sin embargo el
proceso de tener que diseñar, crear y llevar el control de la misma puede resultar bastante
tedioso. Afortunadamente Laravel nos proporciona un mecanismo llamado Migraciones con
el cual podremos diseñar la estructura de nuestra base de datos y mantener su historial de
cambios a lo largo del desarrollo del proyecto.
Qué son las migraciones

Las migraciones son un mecanismo proporcionado por Laravel con el que podemos tener una
especie de control de versiones sobre los cambios en la estructura de nuestra base de datos.
Con las migraciones podemos diseñar esta estructura utilizando PHP y programación
orientada a objetos, sin necesidad de escribir código SQL.
Las migraciones son agnósticas al motor de base de datos que tu proyecto use. Al crear un
esquema, las migraciones crearán las tablas para el motor de base de datos que tengamos
configurado, pero estas mismas migraciones las podemos usar con otros motores de bases de
datos diferentes. Es decir, podemos usar el mismo esquema en múltiples motores de bases de
datos (siempre que el motor sea soportado por Laravel).
Por defecto las migraciones se encuentran en el directorio database/migrations. Cada

migración es un archivo .php que incluye en el nombre del archivo la fecha y la hora en que
fue creada la migración (en formato timestamp) y el nombre de la migración.

Nota:
Los motores de base de datos soportados por defecto son MySQL, PostgreSQL, SQLite y
SQL Server.
Migraciones por defecto

Al crear un nuevo proyecto, Laravel incluye por defecto dos migraciones:
• 2014_10_12_000000_create_users_table.php
• 2014_10_12_100000_create_password_resets_table.php
Una migración no es más que una clase de PHP que extiende de la clase Migration. El
nombre de la clase corresponde al nombre del archivo, en el caso de
2014_10_12_000000_create_users_table.php, encontramos, pero con formato «studly
case» (la primera letra de cada palabra en mayúscula, comenzando con mayúscula) en lugar
de separado por guiones:

Métodos de una migración
Dentro de la clase de la migración encontramos dos métodos, up() y down():
En el método up() se especifica lo qué queremos que haga la migración. Por decirlo de
alguna forma, en qué manera queremos que «evolucione» la base de datos cuando se ejecute
dicha migración. Típicamente agregaremos tablas a la base de datos, pero también podemos
agregar columnas a una tabla ya existente, o incluso podemos generar una migración para
eliminar una tabla o columna que ya no necesitemos.
Para crear una tabla llamamos al método create del Facade Schema, pasando como primer
argumento el nombre de la tabla que queremos crear (en este caso users) y como segundo
argumento una función anónima que recibe como argumento un objeto de la clase
Blueprint. Con los métodos que nos provee este objeto diseñaremos la estructura de la tabla:

Nota importante:
Es una buena practica que el nombre del archivo de la migración coincida con lo que estamos
haciendo dentro de la clase.
El método down() nos permite revertir o «devolver» la operación realizada en el método

up(). En el caso de CreateUsersTable, down() nos permitirá eliminar la tabla users
(utlizando el método dropIfExists del Facade Schema):
Constructor de Esquemas (Schema Builder)

La clase Blueprint nos permite construir tablas con una interfaz orientada a objetos, a través
de diferentes métodos, por ejemplo:

$table->string('nombre_de_la_columna') permite crear una columna de tipo VARCHAR
(cadena de texto).
$table->integer('nombre_de_la_columna') permite crear una columna de tipo

INTEGER (entero).
Podemos encadenar métodos para especificar características adicionales, por ejemplo:
$table->integer('nombre_de_la_columna')->unsigned()->default(0); crea una

columna de tipo entero sin signo y cuyo valor por defecto será 0.
Métodos Helpers
Una de las tantas ventajas de usar el constructor de esquemas de Laravel, es que este incluye
métodos helpers que facilitan tareas comunes y evitan la necesidad de duplicar código, por
ejemplo el método: $table->timestamps(); agregará 2 columnas: created_at y
updated_at de tipo timestamp (marca de tiempo) a la tabla en cuestión. Estas columnas son
bastante típicas para almacenar el momento en que un registro fue creado o actualizado.
Notas:
En programación un Helper no es más que una función de apoyo que permite resolver tareas
genéricas / comunes.

Configurar la base de datos
La configuración de la base de datos la hacemos en el archivo .env que está dentro del
directorio principal de nuestro proyecto:
En DB_DATABASE se coloca el nombre de la base de datos, en DB_USERNAME el usuario de la

base de datos y en DB_PASSWORD la contraseña de la base de datos.
Ejecutar las migraciones

Con el comando de Artisan migrate podemos ejecutar todas las migraciones:
Al hacer esto Laravel automáticamente creará nuestras tablas en la base de datos. Al ejecutar
nuestras migraciones por primera vez, Laravel creará una tabla llamada migrations donde va
a guardar la información de las migraciones que han sido ejecutadas.
Facades
Schema y Route son Facades. En Laravel los Facades son una manera de acceder a las clases
internas del framework con una interfaz estática y fácil de usar. Pero esto no quiere decir que
Laravel esté conformado sólo de clases estáticas, al contrario, Laravel utiliza muy buenas
practicas de la programación orientada a objetos como la inyección de dependencias,

mientras que además incluye Facades y funciones helpers para que sea sencillo interactuar
con las clases del framework.
Ejercicio
Crea una base de datos y configura el archivo .env para que puedas ejecutar las migraciones
con el comando php artisan migrate. Una vez que lo logres verifica que las tablas se
hayan creado con éxito utilizando cualquier administrador de bases de datos.
Modificar tablas ya existentes con las migraciones de Laravel

Ahora aprenderemos cómo se pueden modificar tablas ya existentes a través del sistema de
migraciones de Laravel de dos formas: modificando una migración ya existente o creando
una migración nueva. Para lograr esto utilizaremos varios comandos de Artisan como
migrate:refresh, migrate:reset y migrate:rollback y por supuesto crearemos la
nueva migración con el comando make:migration
Modificar una tabla

Para agregar una columna a una tabla, modificamos la migración ya existente. En nuestro
caso añadimos un campo profession con un limite de 100 caracteres a la tabla users:

Nota:
Encadenando nullable() indicamos que la columna puede contener valores nulos, es decir
que su valor es opcional.
Comando reset
El comando de Artisan migrate:reset va a hacer un retroceso (roll back) de las migraciones
ejecutadas previamente. En este ejemplo vamos a eliminar las tablas users y password_resets.
Luego de ejecutar este comando, podemos ejecutar el comando php artisan migrate para
volver a crear las tablas.
Modificar un campo ya existente

Para modificar un campo ya existente, por ejemplo el limite de caracteres del campo
profession, agregamos el nuevo valor en la migración:
Para que estos cambios tengan efecto debemos ejecutar el comando de Artisan
migrate:refresh.

Comando migrate:refresh
El comando migrate:refresh primero va a ejecutar un reset de todas las migraciones
(llamando al método down()) y luego volverá a ejecutar las migraciones (llamando al método
up()):
Modificar migraciones
Al realizar una modificación en la migración original tenemos el problema de que los
comandos reset y refresh eliminaran el contenido de las tablas en la base de datos. Para
evitar esto podemos (utilizando el comando make:migration) crear una nueva migración y
agregar desde ahí las modificaciones que necesitamos:
Nota importante:
Es una buena practica que el nombre de la migración sea descriptivo y haga referencia a lo
que vamos a hacer. En este caso add_profession_to_users indica que queremos agregar
el campo profession a la tabla users.
Dentro del método up() de la migración en lugar de usar el método create del facade
Schema utilizaremos table y pasaremos como primer argumento el nombre de la tabla que
queremos modificar:

Dentro de la función indicamos el campo que queremos agregar.
En el método down() especificamos la acción inversa, en este caso eliminar la columna que
agregamos en el método up():
Con el método dropColumn eliminamos de la tabla la columna especificada como argumento.

Indicar la posición de una columna
Al modificar una migración utilizando Schema::table y agregar una columna, esta se va
añadir al final de la tabla. Podemos lograr que la columna se cree en la posición que
indiquemos utilizando el método after:
En este caso indicamos que queremos agregar la columna profession después del campo
password.
Comando rollback
Utilizando el camando de Artisan migrate:rollback Laravel regresará el último lote de
migraciones ejecutado:
Crear y asociar tablas usando las migraciones de Laravel (con claves

foráneas)
Ahora veremos cómo crear nuevas tablas y cómo crear asociaciones entre una tabla y otra
utilizando claves foráneas. También se revisará un poco más sobre las convenciones que se
pueden utilizar al momento de generar nuevas migraciones y sobre otros métodos para definir
campos.

Convenciones al ejecutar migraciones
Al generar una migración con el comando php artisan make:migration si utilizamos el
siguiente formato para el nombre: create_NOMBRE DE LA TABLA_table, Laravel
automáticamente generará el código requerido para crear dicha tabla:
Producirá el siguiente código boilerplate:
Ahora sólo tenemos que definir las columnas.
También podemos pasar la opción --create en caso de que no queramos usar la convención:
A la opción create pasamos como valor el nombre de la tabla.

Restricción de clave foránea
Podemos añadir una restricción de clave foranea a nuestro campo utilizando el método
foreign():
En este caso indicamos que el campo profession_id va a hacer referencia al campo id en

la tabla professions.
Aquí es importante que el tipo del campo profession_id coincida con el campo id en la tabla
professions. Es decir el campo profession_id debe ser definido como un entero positivo, para
ello usamos el método:
$table->unsignedInteger('nombre_del_campo_aqui'); o
$table->integer('nombre_del_campo')->unsigned();
Claves primarias
Cuando diseñamos una base de datos, suele ser importante tener un campo (o combinación
de campos) que pueda identificar de manera única a cada fila. Así como tienes un número de
pasaporte que es único, cada usuario o profesión va a tener un identificador (id) único. En
esta base de datos usaremos identificadores de tipo auto-incremento, es decir la primera fila
obtendrá el identificador 1, la segunda 2, y así sucesivamente. Estos identificadores serán
generados por el motor de la base de datos.

Claves Foráneas
Para asociar una tabla con otra, vamos a utilizar una clave foránea. Por ejemplo en la tabla
de usuarios, utilizaremos el campo profession_id, cuyo valor va a ser un identificador (id)
válido de uno de los registros de la tabla de profesiones. De esta manera asociaremos un
registro (fila) la tabla usuarios con un registro (fila) de la tabla de profesiones. En este tipo
de relaciones solemos decir que un Usuario pertenece a una Profesión. También podemos
decir que una Profesión tiene muchos Usuarios. Puesto que pueden existir 100 usuarios que
sean desarrolladores back-end o 50 usuarios que sean desarrolladores front-end, cada
profesión va a tener asignada muchos usuarios. Por otro lado cada usuario solo puede tener
asignada una profesión (aunque en la vida real hay personas que tienen más de una profesión,
en nuestro sistema esto no es relevante).
¿Crear migraciones o modificar las ya existentes?

Para evitar que el número de migraciones crezca sin control, puedes modificar las
migraciones ya existentes. Ten en cuenta que esto suele ser posible en etapas tempranas del
desarrollo donde la base de datos no existe en producción y todos los datos son de prueba (no
importa destruir y reconstruir la base de datos cada vez). Si luego de 3 meses de lanzar tu
proyecto debes agregar un campo a la tabla de usuarios, en este caso te recomendaría crear
una migración nueva. Porque así no solo podrás modificar la tabla de usuarios (sin eliminarla
y recrearla) sino que además mantendrás un historial de los cambios que se han producido en
diferentes versiones de tu aplicación.
Cambié una migración y ya nada funciona…

En casos donde ejecutar php artisan migrate:refresh y comandos similares, siempre produzca
un error, puedes solucionarlo borrando todas las tablas de tu base de datos o ejecutando php
artisan migrate:fresh.
Nota importante:
Ten en cuenta que ejecutar php artisan migrate:fresh va a eliminar todas las tablas.
Hazlo solamente si no te importa perder los datos (porque solo son de prueba, etc).

Inserción de datos con los seeders de Laravel
Anterior cargamos datos de prueba utilizando un administrador de base de datos, sin embargo
esto trae como consecuencia que cada vez que ejecutemos migrate:refresh o
migrate:fresh perdamos dichos datos. Ahora veremos una mejor forma de cargar datos de
prueba utilizando los Seeders de Laravel.
Generar un seeder
Para generar un seeder utilizamos el comando de Artisan make:seeder seguido del nombre
del seeder:
Al ejecutar este comando se generará un archivo ProfessionSeeder.php dentro del

directorio database/seeds.
Código del seeder

Dentro del método run() del archivo ProfessionSeeder.php escribimos el código de
nuestro seeder:

Para insertar datos, utilizaremos el constructor de consultas SQL de Laravel. Que incluye una
interfaz fluida para construir y ejecutar consultas a la base de datos. Para ello llamaremos al
método table del Facade DB pasando como argumento el nombre de la tabla con la que
queremos interactuar. El método insert acepta un array asociativo que representará las
columnas y valores que queremos guardar en la tabla.
Nota:
Para utilizar el facade DB:: debemos importar \Illuminate\Support\Facades\DB al
principio del archivo:
Registrar seeder
Los seeders son registrados en la clase DatabaseSeeder dentro de
database/seeds/DatabaseSeeder.php. Dentro del método run llamamos al método call
pasando como argumento el nombre de la clase de nuestro seeder:

En este caso ProfessionSeeder::class devolverá el nombre de la clase. En lugar de
utilizar ::class también podemos pasar el nombre de la clase como una cadena de texto
'ProfessionalSeeder'.
Eliminar registros
Es posible que antes de ejecutar un seeder necesitemos eliminar el contenido existente. Para
realizar esto podemos utilizar el método truncate, que se encarga de vaciar la table:
Ejecutar un seeder
Para ejecutar los seeders utilizamos el comando db:seed desde la terminal:
En caso de que tengas múltiples seeders, puedes pasar la opción --class que te permite
ejecutar solamente el seeder pasado como argumento:

También puedes ejecutar el comando migrate:fresh o migrate:refresh junto con los
seeders pasando la opción --seed:
Desactivar revisión de claves foráneas

Si una tabla tiene una referencia de clave foránea, necesitarás desactivar la revisión de claves
foráneas utilizando un sentencia antes de vaciar dicha tabla (por ejemplo usando el método
truncate).
Esto podemos lograrlo con la sentencia SQL SET FOREIGN_KEY_CHECKS=[0|1]. En Laravel

podemos ejecutar dicha sentencia usando el método DB::statement de esta manera:
Utilizando la misma sentencia pero con el valor 1 reactivamos la revisión de claves foráneas
luego de ejecutar nuestro seeder.

En caso de que quieras vaciar varias tablas a la vez, puedes utilizar el siguiente código dentro
de la clase DatabaseSeeder:
Ahora podrás llamar al método truncateTables pasando un arreglo con los nombres de las
tablas que quieras vaciar.

Contraseñas dentro de un seeder
En caso de que quieras insertar usuarios de esta manera, recuerda encriptar las contraseñas
utilizando el helper bcrypt:
Constructor de consultas SQL de Laravel

Ahora analizaremos más a detalle cómo funciona el constructor de SQL de Laravel y
aprovecharemos la ocasión para mostrar cómo se pueden ejecutar consultas SQL de forma
manual utilizando el framework y cómo se pueden protegerter del ataque de inyección SQL
cuando utilizas Laravel.
Método insert
Con el método DB::insert podemos escribir consultas SQL de forma manual para insertar
contenido dentro de nuestra base de datos. Por ejemplo, el código del seeder
ProfessionSeeder.php que utiliza el método DB::table:

Puede ser re-escrito utilizando el método DB::insert, directamente con código SQL:
Nota
Aunque DB::insert nos da el mismo resultado que DB::table, cuando realizamos
consultas de este tipo y recibimos datos ingresados por un usuario debemos tener mucho
cuidado, ya que nos exponemos a ataques de inyección de SQL.
Inyección de SQL
Nuestro código es vulnerable a inyecciones de SQL cuando insertamos variables dentro de
una solicitud de SQL. Por ejemplo, si se tuviera una consulta donde se selecciona una serie
de articulos dependiendo de un autor:
Esta consulta trae todos los artículos escritos por un determinado autor. Sin embargo, dentro
de esta consulta estamos insertando contenido de forma directa al colocar la variable $id.
Hay que suponer que si ingresamos a los artículos del autor desde una URL, pasando como
argumento el id del autor (?id=1 o articulos/{id}), en este caso retornaríamos todos
los artículos escritos por el autor cuyo id sea igual a 1. Sin embargo, como el código es
vulnerable, un usuario malintencionado podría cambiar la URL por ?id=1 UNION SELECT
password FROM users. La consulta realmente se estaría realizando de esta forma:

Esta consulta selecciona todos los artículos y luego selecciona todas las contraseñas
almacenadas en la tabla users.
Nota:
Al almacenar contraseñas en una base de datos asegurate de siempre encriptarlas.
Parametros dinámicos
Para evitar ataques de inyección de SQL podemos utilizar parámetros dinámicos. Laravel
utiliza internamente el componente PDO de PHP y debido a esto podemos colocar
marcadores en nuestra consulta. Laravel nos permite pasar sus valores en un array como
segundo argumento del método:
Otra forma de pasar los parametros es usando como marcador un parámetro de sustitución
con nombre y como segundo argumento pasamos un array asociativo de los respectivos
parámetros con sus valores:
Al hacer esto estaremos protegidos de ataques de inyección de SQL puesto que los
parámetros dinámicos serán escapados de forma automática y segura.

Método select
Utilizando el método DB::select podemos construir una consulta SELECT de SQL de forma
manual:
Por otro lado, utilizando el constructor de consultas podemos realizar una consulta SQL de
tipo SELECT, de la siguiente forma:
El resultado de esta consulta es un objeto de la clase Illuminate\Support\Collection

que encapsula el array de datos y esto trae algunas ventajas extras: una interfaz orientada a
objetos con la cual trabajar y muchas funciones extras. Por ejemplo, podemos utilizar el
método first para obtener el primer resultado de la consulta (en el caso de este ejemplo, la
primera profesión):

Consultas con condicionales (WHERE)
El constructor de consultas también nos permite realizar consultas condicionales utilizando
where:
El operador = dentro del método where es opcional. Pasando el nombre de la columna junto
con el valor, Laravel asumirá que quieres usar el operador de comparación de igualdad (=):
El método where también acepta un array asociativo, donde indicamos el nombre de la

columna y el valor que esperamos encontrar:
Métodos dinámicos
También podemos utilizar métodos dinámicos:

En este caso whereTitle es lo equivalente a escribir:
where('title', '=', 'Desarrollador back-end').
Omitir el método select de DB::table

Omitiendo el método select al utilizar DB::table podemos retornar todas las columnas:
Ejercicios
• Para esta lección inserta un usuario usando SQL de forma manual con DB::insert.
• Mueve la columna profession_id para que esté luego de la columna id.
• Utilizando el método DB::delete elimina una profesión.
Introducción a Eloquent, el ORM del framework Laravel

Para trabajar con bases de datos en Laravel no necesitamos escribir SQL de forma manual,
ni siquiera utilizar el constructor de consultas. Laravel nos permite interactuar con la base de
datos a un nivel mucho más alto a través del ORM Eloquent. Utilizando Eloquent podemos
trabajar con modelos, que son clases que representan nuestras tablas en la base de datos y
nos proveen de métodos con los que podemos interactuar en una interfaz más «elocuente» y
orientada a objetos.

Generar un modelo
Los modelos los podemos generar desde la consola utilizando el comando make:model de
Artisan:
La convención es nombrar al modelo con su primera letra en mayúsculas y escribirlo en

singular (por ejemplo: «Profession» en vez de «professions»). Si queremos agregar dos
palabras en el nombre, la convención es colocar la primera letra de cada palabra en
mayúscula:
Este formato es conocido como «Studly Caps».
Por defecto modelos serán generados en el directorio app de nuestra aplicación, con su
nombre más la extensión .php. En nuestra caso Profession.php o
ProfessionCategory.php. También podemos generar el modelo dentro de otro directorio,
especificando el nombre del directorio antes del modelo:
En este caso el modelo Profession.php se encontrará en app/Models/. De no existir el

directorio especificado, Laravel lo va a crear por nosotros.

Especificar la tabla relacionada al modelo manualmente
Al utilizar un modelo no es obligatorio especificar el nombre de la tabla si seguimos las
convenciones de Eloquent. Por ejemplo si utilizamos como nombre de modelo Profession
Laravel hará las consultas a la tabla professions. Si utilizamos User Laravel hará las
consultas a la tabla users. Por último si nuestro modelo fuera ProfessionCategory la tabla
por defecto sería profession_categories.
En caso de que el nombre de la tabla no sea igual al nombre del modelo, debemos
especificarlo en el modelo definiendo la propiedad $table:
Insertar datos utilizando un modelo

Podemos insertar datos llamando al método create del modelo:
Importando el modelo al principio del archivo, evitamos tener que hacer referencia a
\App\Profession cada vez que trabajemos con el modelo:

Luego de importar el modelo, podemos hacerle referencia directamente:
Eliminar campos timestamps

Al insertar datos utilizando un modelo, Eloquent se encargará de cargar los valores de los
campos created_at y updated_at de la tabla. Si no queremos utilizar estos campos, dentro
de nuestro modelo debemos agregar la propiedad pública $timestamps y darle el valor de
false:
Realizar consultas
Podemos utilizar los modelos para hacer consultas a la base de datos. Utilizando el método
all() obtenemos todo el contenido de la tabla:
También podemos encadenar métodos del constructor de consultas para obtener resultados
más específicos:

Podemos retonar un resultado dependiendo de su id mediante el método find():
Usando Eloquent ORM de forma interactiva con Tinker

Ahora vamos a interactuar desde la terminal con nuestra aplicación utilizando la consola
dinámica Tinker. También analizaremos nuevos métodos de Eloquent para interactuar con
nuestros modelos y se verá cómo crear nuestros propios métodos dentro de los modelos.
Acceder a Tinker
Podemos acceder al entorno con el comando de Artisan tinker:
Desde el entorno interactivo podemos ejecutar expresiones de PHP y también vamos a tener
disponible las clases de nuestro proyecto y del framework.
Retornar todos los registros con el método all()

Utilizando el método all() retornamos todos los registros asociados a un modelo:

Los métodos all() y get() en Eloquent retornan colecciones (objetos de la clase
Illuminate\Database\Eloquent\Collection) las cuales «envuelven» el array de
resultados y nos proveen de funciones y métodos adicionales, por ejemplo:
Podemos obtener el primer resultado utilizando el método first() y el último utilizando el
método last(). También podemos obtener un resultado aleatorio utilizando el método
random():
Estos métodos de la clase Collection no generan nuevas consultas SQL sino que operan sobre
los resultados ya encontrados.
Seleccionar un campo con el método pluck()

Utilizando el método pluck() podemos retornar una nueva colección que contenga un
listado de un solo campo en vez de un listado de objetos. Por ejemplo, podemos obtener solo
el campo title de la siguiente forma:

Devuelve:
Crear una colección de forma manual

Con el helper collect podemos crear una colección de forma manual:
Sin embargo éste será un objeto de la clase Illuminate\Support\Collection que

representa la colección «base» en vez de Illuminate\Database\Eloquent\Collection.
Nota:
Las colecciones de Eloquent extienden de la colección base pero proveen algunos métodos
extra asociados al ORM.
Declarar métodos en el modelo

Podemos declarar métodos dentro de un modelo y utilizarlos cuando interactuemos con los
objetos de estos modelos:

Declarando métodos no estáticos:
Asociamos un método para ser utilizado sobre un objeto (que representa un registro de la
base de datos):
En este caso isAdmin() devuelve true si el email del usuario es igual al valor con el que está
siendo comparado:
Declarando métodos estáticos:

Asociamos un método a la clase del modelo como tal, la cual representa el acceso a una tabla
de la base de datos. Estos métodos son usados típicamente para consultas:
Luego podrás usar User::findbyEmail('email@aqui.com') para buscar a un usuario por

el campo email y obtener un objeto User como resultado (o null si no se encuentra ningún
registro).

Manejo de atributos en Eloquent ORM (solución a
MassAssignmentException)
Ahora nalizaremos un poco más sobre cómo trabajar con los atributos de Eloquent, es decir
cómo podemos leer y asignar atributos a un modelo. La asignación de atributos la haremos
utilizando asignación masiva e individual, y veremos de qué se trata el error
MassAssignmentException, cómo solucionarlo y cual es la protección que nos ofrece
Laravel para evitar la inyección de atributos no deseados cuando cargamos datos
provenientes de la petición de un usuario (por ejemplo a través de un formulario o API).
Además se verá cómo se pueden convertir atributos de un tipo a otro mediante la propiedad
$casts de Eloquent. Todos estos conceptos te acercarán más a lo que necesitas saber para
comenzar a crear módulos CRUD con este genial framework.
Leer y asignar atributos

Cuando trabajamos con Eloquent, todos los atributos de un modelo (o columnas de un
registro) son tratados como si de propiedades públicas de la clase se tratasen. Por ejemplo si
quieres obtener el nombre de un usuario almacenado en la variable $user, puedes escribir:
$user->name; // obtiene el nombre del usuario
Para re-asignar otro nombre puedes escribir $user->name = 'Salvador';
Estos cambios no serán guardados automáticamente en la tabla de usuarios en la base de

datos, sino que necesitas ejecutar el método save para hacer esto:
$user->save(); //inserta o actualiza el usuario en la base de datos
Eloquent es lo suficientemente inteligente para saber si debe ejecutar un INSERT o un UPDATE

dependiendo si el usuario existe o no, respectivamente.

Nota:
La propiedad exists de Eloquent, nos permite averiguar si un modelo existe o no, ejemplo:
$user->exists //devuelve TRUE si el usuario ya existe en la base de datos, FALSE de lo
contrario.
Evitar fallos de seguridad por asignación masiva de datos

La excepción MassAssignmentException es una forma en la que el ORM nos protege. Una
vulnerabilidad de asignación masiva ocurre cuando un usuario envía un parametro
inesperado mediante una solicitud y dicho parametro realiza un cambio en la base de datos
que no esperabas. Por ejemplo, un usuario podría, utilizando Chrome Developer Tools o
herramientas similares, agregar un campo oculto llamado is_admin con el valor de 1 y enviar
la solicitud de registro de esta manera. Si no tienes cuidado con esto entonces cualquier
usuario podría convertirse en administrador de tu aplicación, con consecuencias nefastas para
tu sistema.
Para evitar esto, dentro del modelo agregamos la propiedad $fillable y asignamos como
valor un array con las columnas que queremos permitir que puedan ser cargadas de forma
masiva:
También tenemos disponible la propiedad $guarded. Al igual que $fillable, esta

propiedad tendrá como valor un array, pero en este caso las columnas que indicamos son las
que no queremos que puedan ser cargadas de forma masiva:

Asignar un campo no fillable
Para asignar un valor a un campo que no está dentro de $fillable, podemos asignar una
nueva instancia de un modelo en una variable y luego asignar el campo de forma manual:
Nota que new User($datos) solo crea un nuevo modelo sin persistirlo en la base de datos
VS User::create($datos) que crea un nuevo modelo y lo inserta en la base de datos en
un solo paso.
Convertir atributos
La propiedad $casts nos permite convertir atributos a diferentes tipos de datos dentro de un
modelo. $casts recibe como valor un array donde la llave es el nombre del atributo que será
convertido y el valor el tipo al que lo queremos convertir:
En este caso convertimos la propiedad is_admin a boolean.

Manejo de relaciones con el ORM Eloquent
Las tablas de una base de datos a menudo están relacionadas unas con otras. Por ejemplo, un
usuario puede estar asociado a una profesión y una profesión puede tener muchos usuarios
asociados. Utilizando el ORM Eloquent podemos hacer que este proceso sea mucho más
fácil, trabajando con las relaciones directamente dentro de nuestros modelos (usando
Programación Orientada a Objetos) y creando métodos personalizados que nos evitarán tener
que construir consultas de forma manual.
Relaciones «Pertenece a»
El método belongsTo nos permite trabajar con relaciones donde un registro pertenece a otro
registro. Este método acepta como primer argumento el nombre de la clase que queremos
vincular. Eloquent determina el nombre de la llave foránea a partir del nombre del método
(en este caso profession) y agregando el sufijo _id a este:
Si en la base de datos el nombre de la llave foránea no sigue esta convención puedes pasar el
nombre de la columna como segundo argumento:

Por otro lado, si el modelo padre no usa una columna id como su llave primaria o quieres
relacionar el modelo a una columna diferente, puedes pasar un tercer argumento
especificando el nombre de la columna que actuaría como llave del modelo padre:
En este caso Eloquent buscará la relación entre la columna profession_name del modelo
Users y la columna name del modelo Profession.
Hecho esto, utilizando cualquiera de las formas anteriores, podemos obtener la profesión del
usuario:
Relaciones uno a muchos con hasMany

Una relación uno a muchos es utilizada cuando un modelo puede tener muchos otros modelos
relacionados. Por ejemplo, una profesión puede tener un número indeterminado de usuarios
asociados a ésta. Dentro del modelo Profession podemos decir que una profesión tiene
muchos usuarios:

Ahora podemos obtener todos los usuarios de una profesión:
Los métodos que nos permiten relacionar un modelo con muchos otros siempre van a retornar
una colección, así esté vacía y los métodos que nos permiten relacionar un modelo con otro
van a retornar el modelo o null.
Construir consultas
Podemos construir una consulta llamando al método de una relación. Por ejemplo,
encadenando el método where() a users() podemos obtener todos los usuarios asociados a
una profesión pero que tengan la columna is_admin como true:

Generar registros usando Model Factories en Laravel
Los Model Factories nos permiten crear registros de prueba, ya sea para cargar nuestra base
de datos con «información falsa» o «información de prueba» o para crear las condiciones
necesarias para ejecutar pruebas automatizadas. En esta ocasión practicaremos con la
creación de modelos desde Tinker y desde nuestros seeders utilizando Model Factories.
Además te enseñaré cómo generar tus Model Factories personalizados, adaptarlos al modelo
correspondiente y también se verá una pequeña introducción al uso del componente Faker.
Generar un Model Factory

Para poder utilizar un Model Factory necesitamos generarlo primero con el comando
make:factory. El Model Factory será generado en el directorio database/factories.
Dentro de nuestro Model Factory especificamos el atributo o los atributos que queremos
generar de forma aleatoria:
Además es importante que indiquemos el nombre del modelo que queremos enlazar a dicho
Model Factory (en este caso \App\Profession::class).

Para no tener que agregar el nombre del modelo de forma manual podemos pasar la opción
--model al comando make:factory:
Al generar un modelo con el comando make:model también podemos generar un Model

Factory y/o una migración pasando las opciones -f y/o -m por ejemplo:
Utilizando el componente de PHP Faker indicamos que el valor de title será una oración
aleatoria:
Pasando un número como primer argumento a sentence podemos indicar el número de

palabras que queremos que contenga la oración: $faker->sentence(3). Esto devolverá
oraciones con 2, 3 o 4 palabras, o si queremos estrictamente que sean 3 palabras podemos
llamar al método de esta forma: $faker->sentence(3, false)

Componente Faker
El componente Faker es una librería de PHP que genera datos de prueba por nosotros. Por
ejemplo, podemos generar un nombre:
O un texto aleatorio:
Incluso números de teléfono:
Utilizar un Model Factory

Para utilizar un Model Factory debemos llamar al helper factory, especificando el nombre
del modelo como argumento y finalmente encadenando el llamado al método create.

Esto va a crear un usuario en la base de datos y va a retornar el modelo en cuestión, en este
caso un objeto de la clase User:
Cada vez que ejecutamos el método create() creamos un nuevo registro aleatorio. Si
pasamos un array asociativo al método create() podemos sobrescribir o asignar
propiedades extras:
Para cargar un determinado número de registros pasamos como segundo argumento la

cantidad que queremos crear:

También podemos lograrlo utilizando el método times():

Módulo CRUD de usuarios: listado básico y detalles
En la cuarta parte comenzaremos el desarrollo práctico de un módulo CRUD de usuarios con
Laravel, para ello nos apoyaremos en el navegador pero también en el desarrollo con pruebas
automatizadas.
Módulo de usuarios con Laravel

Ahora vamos a utilizar los conocimientos que hemos adquirido sobre el ORM Eloquent y
manejo de base de datos con Laravel para convertir el listado estático de usuarios en un
listado dinámico.
Se recomienda ver y repasar los temas donde se explica cómo crear rutas, controladores,
vistas y además cómo crear y trabajar con bases de datos en Laravel.
Listado dinámico de Usuarios con Laravel (Módulo CRUD)

A partir de este tema vamos a comenzar el desarrollo del módulo CRUD de usuarios
reemplazando el listado estático de usuarios con los registros que se encuentran en la base de
datos. Para ello utilizaremos el constructor de consultas de Laravel y el ORM Eloquent.
Obtener registros desde la base de datos

Reemplazamos el listado estático con un listado dinámico que vamos a cargar desde la base
de datos. Utilizando get() obtenemos todos los registros que se encuentran en la tabla pasada
como argumento al método table:

Necesitamos importar el facade DB al principio del archivo:
La variable $user dentro del ciclo @forelse ya no contiene una cadena de texto sino un
objeto. No podemos imprimir estos objetos como si se trataran de una cadena, pero sí
podemos imprimir las propiedades de cada objeto:
Obtener registros con Eloquent

Podemos utilizar Eloquent para obtener los datos que se encuentran en la base de datos.
Utilizando all() podemos obtener todos los registros que se encuentran en la tabla:
Debemos importar el modelo al principio del archivo:

Al imprimir directamente $user dentro de la directiva @forelse sin llamar a ninguna
propiedad, se imprime una representación en JSON de cada usuario. Esto es debido a que al
utilizar Eloquent obtenemos una colección de objetos donde cada objeto representa una
instancia de la clase User (un modelo de Eloquent), los cuales incluyen esta funcionalidad.
Configuración y uso de base de datos en el entorno de pruebas

automatizadas con Laravel y PHPUnit
Ahora vamos a aprender a configurar y ejecutar operaciones de bases de datos en el entorno
de pruebas automatizadas (PHPUnit). Para ello seguiremos una serie de pasos: crearemos
una base de datos adicional para el entorno de pruebas automatizadas, veremos cómo ejecutar
automáticamente las migraciones de base de datos desde nuestras pruebas y cómo ejecutar
las pruebas en un entorno aislado para obtener los resultados esperados.
Base de datos para pruebas automatizadas

Nota:
Hay que asegurarnos de estar utilizando el motor InnoDB en la base de datos MySQL para
que las pruebas se puedan ejecutar dentro de transacciones de base de datos.
Podemos tener dos bases de datos, una para interactuar con nuestra aplicación en el
navegador y otra para las pruebas que vayamos a ejecutar. De esta forma la ejecución de las
pruebas automatizadas no afectará nuestra interacción con la aplicación en local y viceversa.
Pasos para configurar la base de datos para pruebas automatizadas:

1.- Configura las variables de entorno en phpunit
En el archivo phpunit.xml, vamos sobrescribir la variable que utiliza Laravel para leer el
nombre de la base de datos por defecto. Esto lo hacemos agregando una variable de entorno.
En la propiedad name indicamos el nombre de la variable de entorno (DB_DATABASE) y en la
propiedad value indicamos el nombre de la base de datos que queremos utilizar para las
pruebas (en nuestro ejemplo es curso_styde_tests):

Crea la nueva base de datos
Por supuesto se necesitará crear la base de datos (por ejemplo, curso_styde_tests). Para
ello puedes hacerlo desde la consola o con el administrador de base de datos que prefieras
(PHPMyAdmin, Sequel Pro, entre otros).
Usa el trait RefreshDatabase

Incluye el trait RefreshDatabase en cada una de las pruebas que vaya a interactuar con la
base de datos. De esta manera, Laravel ejecutará las migraciones de la base de datos antes de
ejecutar las pruebas. Además ejecutará cada prueba dentro de una transacción de la base de
datos que será revertida después de ejecutar cada método de prueba. De esta forma evitamos
tener que migrar manualmente la base de datos y preocuparnos por datos que podrían
«contaminar» el estado de cada una de nuestras pruebas:
Para poder usarlo, debemos importar el trait al principio del archivo:

Utilizando RefreshDatabase las pruebas se ejecutan en transacciones de la base de datos,
es decir, cada vez que se ejecuta una prueba la base de datos vuelve a su estado original al
finalizar la prueba. Debido a esto, en nuestro ejemplo ambas pruebas van a pasar, a pesar de
que en it_shows_users_list() estamos creando dos usuarios y luego en la siguiente
prueba comprobamos que no existan usuarios en la base de datos:
Detalles o Perfil de Usuario con Laravel (Módulo CRUD)

Ahora vamos a hacer el proceso inverso, en lugar de escribir el código y luego la prueba,
primero escribiremos la prueba y luego el código para que la prueba pase, que es a lo que se
refiere el «Desarrollo guiado por pruebas automatizadas» o TDD. Esto nos permitirá poder
guiarnos mientras construimos las diferentes partes de nuestra aplicación.

Método find() de Eloquent
Utilizando el método find() podemos retornar un registro en particular desde la base de
datos. En este caso find() devolverá el usuario con un id igual a 1:
El método find() también acepta un array de claves primarias. Pasando este array, find()
devolverá una colección con los registros encontrados:
Actividades
Mejora el diseño del perfil utilizando Bootstrap o CSS y presume de ella compartiendo una
captura en los comentarios.
Generar URLs en Laravel

Una de las ventajas de una página web es la posibilidad de poder navegar mediante enlaces.
En esta lección aprenderemos cómo crear enlaces en Laravel utilizando los diferentes helpers
que tenemos disponibles, como lo son url(), action() y route().
Creando enlaces con el helper url()

El helper url() nos permite crear un enlace en nuestra vista:

También podemos utilizar comillas dobles. De esta forma en lugar de concatenar podemos
colocar directamente la propiedad $user->id:
Al llamar al helper url() sin pasar ningún argumento, Laravel retornará una instancia del
objeto Illuminate\Routing\UrlGenerator, con el que podemos tener acceso a diferentes
métodos. Por ejemplo, el método previous() que nos devuelve la URL anterior:
Otros métodos disponibles son current() y full() con los que podemos tener acceso a la
URL actual y la URL actual con la cadena de consulta (Query String):
También podemos utilizar el alias y facade URL para acceder a estos métodos:
Dentro de una clase con nombre de espacio necesitarías importar el Facade:

Illuminate\Support\Facades\URL

Creando enlaces con el helper action()
Con el helper action() también podemos crear URLs, pasando como argumento el nombre
del controlador al cual queremos enlazar seguido de un arroba y el nombre de la acción dentro
del controlador:
La ruta del controlador, por defecto, es relativa al nombre de espacio

App\Http\Controllers.
También podemos utilizar el helper action() cuando necesitamos pasar un argumento a la

URL. Esto lo logramos pasando como segundo argumento al helper un array asociativo con
los parámetros que necesitamos pasar a la URL:
Rutas con nombre

Podemos asignar un nombre a una ruta, encadenando el método name() a la declaración de
la ruta. En este caso la primera ruta tendrá el nombre de users y la segunda users.show:

Al hacer esto, ahora dentro de las vistas podremos hacer referencia al nombre de las rutas
utilizando el helper route(), pasando como primer argumento el nombre de la ruta y como
segundo argumento los parámetros de la ruta, tal como con la función action:
Si estás pasando como argumento una llave primaria de un modelo de Eloquent, puedes pasar
el modelo directamente a route(). El helper extraerá automáticamente dicha llave primaria:
Manejo de errores 404 en Laravel

Muchas veces cuando realizamos una consulta utilizando SQL o una API, es posible que no
se obtenga el resultado esperado debido a que el contenido que el usuario intenta ver no
existe. Nosotros debemos de tener en cuenta situaciones como esa en nuestra aplicación, es
por ello que veremos la manera de retornar de forma manual errores 404 y también como
hacerlo de forma automática cuando un modelo no es encontrado.
Retornar una vista con status 404

Cuando retornamos el llamado al helper view() desde una acción, Laravel va a retornar el
contenido de la vista con el status HTTP 200 (OK). Nosotros podemos retornar una vista con
status 404 (no encontrado) utilizando el helper response y luego encadenando el llamado al
método view. Al método view pasamos como primer argumento el nombre de la vista, como
segundo argumento los datos y como tercer argumento el status HTTP:

Uso de findOrFail
El método findOrFail intentará encontrar el registro correspondiente a la llave primaria
pasada como argumento, y si este no es encontrado devolverá una excepción de tipo
ModelNotFoundException:
También podemos utilizar el método firstOrFail, que devuelve el primer resultado de la

consulta y si ningún registro es encontrado retorna una excepción
ModelNotFoundException:
Actividades
Recuerda mejorar el diseño de las pantallas que hemos creado hasta ahora, agregar más
detalles para cada usuario y compartir tus capturas.
Enlace de modelos a rutas en Laravel

Laravel nos permite obtener modelos directamente en los parámetros de nuestras acciones,
sin necesidad del llamado explícito a métodos de Eloquent como find or findOrFail, ahora
veremos el uso de esta característica conocida como Route Model Binding.

En lugar de obtener el usuario utilizando los métodos find o findOrFail podemos obtenerlo
directamente como parámetro de la acción:
Para que esto funcione, nota que el nombre del parámetro en la declaración de la ruta debe
coincidir con el nombre del parámetro en la declaración del método:
Además el tipo del parámetro debe ser, por supuesto, un modelo de Eloquent (en nuestro
ejemplo es App\User).

Módulo CRUD de usuarios: creación
En la quinta parte trabajaremos en la C de CRUD, es decir en la creación de usuarios, para
ello aprenderemos a escribir y manejar rutas de tipo POST y cómo validar peticiones del
usuario para garantizar que nuestro sistema se mantenga seguro y con datos más reales.
Rutas con POST y protección contra ataques de tipo CSRF en Laravel

Ahora vamos a crear rutas de tipo POST, las cuales harán referencias a acciones que
típicamente alterarán el estado de nuestra aplicación (por ejemplo para la creación de
registros). También veremos cómo evitar ataques de tipo CSRF utilizando una protección
que ya viene incluida en el framework Laravel.
Rutas con el método POST

Declaramos una ruta de tipo POST utilizando el facade Route y llamando al método post():
Podemos tener dos rutas que utilicen la misma URL pero con diferentes métodos:

Para ver todas las rutas que tienes en tu aplicación puedes ejecutar en la consola el comando
route:list de Artisan:
Token (CSRF)
El middleware VerifyCsrfToken nos permite evitar que terceros puedan enviar peticiones
de tipo POST a nuestra aplicación y realizar ataques de tipo cross-site request forgery. Para
agregar un campo con el token dentro de nuestro formulario, que le va a permitir a Laravel
reconocer peticiones de formulario que sean válidas, debemos llamar al método
csrf_field():
El método csrf_field() agregará un campo oculto llamado _token con el valor del token
al código HTML del formulario.

Podemos desactivar la protección CSRF comentando la línea 36 del archivo Kernel.php
aunque esto es altamente desaconsejado:
Creación de usuarios con Laravel y TDD

Verificar de forma manual que nuestros formularios funcionen correctamente puede llegar a
ser complicado, más aún si nuestra aplicación crece y acabamos teniendo diferentes
formularios con multiples campos en cada uno, además ¿Qué sucede si estamos trabajando
en una API y nuestra aplicación de Laravel no tiene ningún formulario? A pesar de que
existen apps y plugins como Postman, que nos permiten probar peticiones de tipo POST,
ahora veremos la manera de verificar el funcionamiento de rutas de tipo POST utilizando
pruebas automatizadas.
Utilizando $this->post() podemos simular peticiones POST desde una prueba

automatizada. En este caso, agregamos una nueva prueba para comprobar que podemos
acceder a la ruta para crear usuarios y que también podemos crear nuevos usuarios:

Como primer argumento pasamos la URL (en este caso /usuarios) y como segundo
argumento los datos de la petición. Con assertRedirect() comprobamos que el usuario
sea redirigido a la URL dada.
Al método assertRedirect() podemos pasar como argumento el helper route para utilizar
el nombre de una ruta en lugar de una URL:
Para comprobar que se ha creado un usuario con los datos que hemos pasado en la petición
POST, utilizaremos el método assertDatabaseHas. Como primer argumento pasamos el
nombre de la tabla y como segundo argumento los datos que esperamos encontrar:
En este caso esperamos encontrar dentro de la tabla users, un registro con un campo name
igual a Salvador y un campo email igual a duarte@mail.com.

También podemos utilizar el método assertCredentials(), que nos permite comprobar la
presencia de la contraseña correcta. Como primer argumento pasamos un array con los datos
que esperamos encontrar. A este método no hace falta pasarle el nombre de la tabla, siempre
y cuando estemos utilizando la tabla de usuarios por defecto (users):
Para recibir los datos de la petición dentro del controlador podemos utilizar el método
request():

Utilizando redirect() podemos redirigir a otra parte de la aplicación desde el controlador:
Creación de formulario para agregar usuarios con Laravel

Vamos a crear el formulario para el registro de nuevos usuarios en la aplicación, utilizando
como base la prueba y el código que escribimos anteriormente.
Nota:
Recuerda agregar el llamado a la función csrf_field() dentro de tu formulario para generar
el campo oculto que contiene el token para pasar la protección contra ataques de tipo CSRF
que provee Laravel por defecto.
Para generar el token debes llamar al helper dentro del formulario:
Es importante que los valores de los atributos name de los campos en el formulario HTML
coincidan con los atributos que estás obteniendo del objeto Request dentro del controlador
de Laravel:

Obtener datos del objeto Request
Laravel ofrece diversas maneras de obtener los datos provenientes de formularios con el
objeto Request, en el ejemplo debajo te enseño 3 de ellas, todas usando el helper request():
Actividades
Usa el código de Bootstrap (o cualquier otro framework de CSS de tu preferencia) para
mejorar los estilos del formulario.

Validar datos de peticiones HTTP con Laravel (TDD)
Ahora aprenderemos cómo validar datos provenientes de una petición HTTP (por ejemplo
datos enviados a través de un formulario), utilizando el componente de validación que
incluye el framework Laravel, además guiaremos el desarrollo a través el uso de pruebas
automatizadas.
Dentro de la prueba comprobamos que la sesión contiene un error para el campo name
utilizando assertSessionHasErrors:
El método assertSessionHasErrors espera que exista un campo name en el listado de

errores de la sesión, independientemente del contenido o mensaje de este error. Sin embargo
podemos indicar cual esperamos que sea el contenido o mensaje pasando un array de pares
clave-valor en lugar de únicamente el nombre del campo:

Con assertDatabaseMissing verificamos que el registro no se esté guardando en la base
de datos, al finalizar la petición ejecutada durante el método de prueba:
Además podemos utilizar el método assertEquals en lugar de assertDatabaseMissing

para comprobar que el usuario no está siendo guardado en la base de datos. A este método le
pasamos el valor esperado como primer argumento y como segundo argumento pasamos el
número de usuarios en la base de datos, utilizando el método count que provee Eloquent:
En este caso el número de usuarios en la base de datos retornado por User::count() debería
ser cero ya que dentro de la prueba estamos utilizando el trait RefreshDatabase.
Pasar errores a la sesión

Desde el controlador, utilizando el método withErrors podemos pasar un array de errores
al realizar una redirección. Dichos errores serán almacenados en la sesión:

Validación automática con validate()
Podemos llamar al método validate() en el objeto request pasando como valor un array
asociativo donde cada llave será el nombre de cada campo esperado y el valor una cadena
con las reglas de validación:
Pasando otro array como segundo argumento podemos especificar los mensajes de los
errores. Al nombre del campo debemos anexar el nombre de la regla de validación (en este
caso required y nota que «name» y «required» están separados por un punto):
Mostrar mensajes de errores de validación con Laravel

Ahora veremos cómo podemos mostrar mensajes de validación en nuestras vistas, utilizando
la variable $errors y los diferentes métodos que Laravel nos proporciona. También veremos
cómo podemos conservar el valor de un campo en caso de que ocurran errores de validación.
Mostrar mensajes de validación

Para trabajar con mensajes de validación en las vistas utilizamos la variable $errors. Esta
variable es pasada automáticamente por Laravel a la vista, exista o no algún error registrado

en la sesión. Esta variable contiene una instancia de Illuminate\Support\MessageBag y
esta clase tiene diferentes métodos que podemos utilizar para obtener y mostrar los mensajes
de error al usuario.
Uno de estos métodos es $errors->any(), con el que podemos comprobar si existe o no

algún error. Este método devolverá verdadero si hay algún error y falso si no hay ninguno:
Otro método es $errors->all(). LLamando a este método dentro de un foreach()

podemos iterar através de todos los mensajes:

También podemos obtener todos los mensajes de validación de un campo en específico. En
este caso utilizamos el método get() pasando como argumento el nombre del campo:
Si queremos obtener solo el primer mensaje de validación de un campo en específico

utilizamos el método first(), pasando como argumento el nombre del campo:
Para determinar si existen mensajes de validación para un campo utilizamos el método

has():
Observa como utilizamos el método first() junto con el método has().

Conservar el valor de un campo
Para conservar el valor de un campo, en caso de que ocurran errores de validación y el usuario
sea enviado de vuelta al formulario, podemos utilizar la función helper old() pasando como
primer argumento el nombre del campo, para asignar así el valor del atributo value de la
etiqueta input:
Uso de múltiples reglas de validación en Laravel

Ahoa agregaremos reglas de validación a nuestro formulario de registro, esta vez guiándonos
mediante las pruebas automatizadas. También veremos cómo podemos utilizar múltiples
reglas como email o unique para validar un mismo campo.
Retornar todos los campos desde validate()

Si queremos ejecutar la validación pero también retornar los campos que no estemos
validando necesitamos agregar estos últimos al array. El método validate() va a retornar
todos los campos dentro del array, tengan o no reglas de validación siempre que estén
presentes:

Multiples reglas de validación
Podemos especificar multiples reglas de validación, si las dividimos con un caracter de barra
vertical: |. En el siguiente ejemplo no solo queremos que el campo correo_electronico
sea obligatorio sino que también contenga una dirección valida, para ello utilizamos la regla
de validación email:
En lugar de separar las reglas con una barra vertical, podemos pasar un array donde cada
valor será el nombre de una regla diferente:
En el caso de algunas reglas de validación, como unique, debemos pasar diferentes

parámetros:

En este caso especificamos que el campo email debe ser único con respecto al campo email
de la tabla users, para evitar que un usuario sea creado con un correo electrónico que
pertenezca ya a otro usuario.
Nota como los parámetros se especifican con : seguido de cada parámetro separado por
comas.
Personalizar mensajes de validación

Podemos pasar mensajes personalizados para cada una de las reglas:
Ejercicio
Agrega una regla de validación para comprobar que el campo password contenga más de 6
caracteres.

Módulo CRUD de usuarios: actualización
En la sexta parte trabajaremos en la U de CRUD, es decir en la actualización (Update) de
usuarios, nuevamente usaremos reglas de validación y nos apoyaremos en pruebas tanto
automatizadas con PHPUnit como manuales en el navegador para garantizar que nuestro
módulo está funcionando con éxito en los escenarios principales.
Formulario para la edición de usuarios en Laravel

Vamos a comenzar a trabajar en el feature para editar usuarios, empezando por crear el
formulario y obtener los registros desde la base de datos. Por supuesto nos guiaremos
mediante el uso de pruebas automatizadas y además aprenderemos a usar algunos métodos
que no hemos visto anteriormente, como assertViewIs.
Uso de assertViewIs y assertViewHas

Con assertViewIs podemos comprobar que la vista retornada desde el controlador es la que
esperamos. En este caso esperamos que la vista sea users.edit:
Con assertViewHas podemos comprobar que la vista contiene la variable pasada como
argumento:

Este método también acepta un valor (que puede ser una función anónima) como segundo
argumento, en caso de que necesitemos o queramos ser más explícitos en la comparación:
Mostrar los datos del usuario en el formulario

Para mostrar los datos del usuario en el formulario de edición pasamos como segundo
argumento a la función old() los datos que estamos retornando desde la base de datos:
En este caso old() intentará cargar los datos referentes al campo name que se encuentren en
la sesión y si no los consigue cargará el valor de $user->name.
Actividad
Acomodar y agregar más estilos al formulario y a los mensajes de error.
Actualización de Usuarios con Laravel (TDD)

Ahora veremos cómo actualizar registros utilizando Laravel y el ORM Eloquent, mientras
trabajamos en el módulo de usuarios. Para ello, una vez más, nos apoyaremos en las pruebas
automatizadas y en la metodología TDD.

Utilizando el método put()
Debemos enviar la petición para editar usuarios utilizando el método put() en lugar de
post():
La URL es similar a la URL para mostrar un usuario (/usuarios/{$user->id}), lo que

varía en cada una es el nombre del método:
El método GET utilizando $this->get() muestra la página de detalles.

El método PUT utilizando $this->put() ejecuta la acción para actualizar.
En web.php debemos definir la ruta utilizando el método Route::put():
Recuerden que se deben encriptar la contraseña utilizando bcrypt antes de pasar los datos al
método update():

Reglas de validación para la actualización de usuarios con Laravel y TDD
Continuaremos con la creación de la funcionalidad para editar usuarios, para ello
agregaremos las reglas de validación a la acción del controlador y mostraremos los errores
de validación en el formulario para editar usuarios. También veremos cómo podemos enviar
peticiones de tipo PUT desde un formulario utilizando el helper method_field de Laravel.
Recuerden que debemos colocar el método from() con la URL del formulario antes del
método put() para poder probar que la redirección se ha efectuado correctamente:
Recibir los datos de la petición

Con request()->validate() recibimos los datos de la petición y comprobamos que
cumplan con las reglas de validación especificadas en el arreglo asociativo:

Indicar el método PUT en el formulario
Los formularios por defecto solo soportan los métodos GET o POST. En Laravel podemos
utilizar el helper method_field() para generar un campo oculto donde podemos indicar el
tipo de petición. Como argumento a method_field() pasamos el nombre del método HTTP:
Campo opcional de contraseña en Laravel

Seguiremos con la construcción de la acción para editar usuarios y veremos cómo podemos
hacer que el campo para la contraseña sea opcional.
Recuerden que pueden traducir los mensajes de error pasando un array asociativo como
segundo argumento al método validate():

Con assertCredentials podemos verificar las credenciales del usuario en la base de datos.
Este método acepta un arreglo con las credenciales como primer argumento:
Dentro del controlador, verificamos si la contraseña no es null y si no lo es la encriptamos,

en caso contrario utilizamos unset() para eliminar el índice password de $data. (Laravel
automáticamente convierte los campos de formularios vacíos en null)
Validar que el e-mail sea único cuando se edita un usuario con Laravel
Ahora aprenderemos cómo pueden anexar la regla de validación para que el campo del correo
electrónico del usuario pueda ser único de forma correcta en la acción para editar usuarios.
Podemos excluir un usuario de la lista de usuarios donde vamos a hacer la validación. En

este caso queremos verificar que el valor sea único en la tabla de usuarios en la columna
email pero excluyendo el usuario que pasamos con $user->id como tercer parametro de la
regla unique:

También podemos usar la interfaz orientada a objetos que nos provee Laravel con la clase
Rule:
Si la tabla no utiliza una columna llamada id como clave primaria, necesitas especificar el
nombre de la columna al llamar al método ignore, por ejemplo:

Módulo CRUD de usuarios: eliminación
En la séptima parte trabajaremos en la D de CRUD: Delete, es decir aprenderemos a eliminar
usuarios, también nos tomaremos un momento para agregar enlaces que nos permitan
navegar a través del módulo de usuarios en el navegador.
Eliminar registros con Laravel y TDD

Ahora seguiremos con la creación del modulo de usuarios, esta vez vamos a trabajar en la
acción para eliminar usuarios de la base de datos utilizando desarrollo guiado por pruebas
automatizadas (TDD).
Nota:
Si tratamos de acceder a una URL que existe pero utilizando un método diferente recibiremos
una excepción de tipo MethodNotAllowed.
En el archivo de rutas utilizamos el método delete:
Dentro de la prueba también utilizamos el método delete llamando a $this->delete:

Con assertDatabaseMissing comprobamos que el registro ya no existe en la base de datos.
Como primer argumento pasamos el nombre de la tabla y como segundo el array de atributos
que no esperamos encontrar. En este caso no esperamos encontrar el registro con el id
pasado:
También podemos utilizar assertSame, pasamos como primer argumento el valor esperado
y como segundo argumento la cantidad de usuarios actual:
Esperaríamos cero usuarios puesto que eliminamos el único usuario creado.
Si estamos cargando el modelo con Route Model Binding podemos llamar al método
delete para eliminar el registro directamente:

De lo contrario tendríamos que escribir algo como:
Recuerda que en lugar de escribir la URL puedes usar el nombre de la ruta para redirigir:
Agregando enlaces al módulo de usuarios

Continuaremos con la creación deL módulo de usuarios, esta vez vamos a trabajar en agregar
los enlaces HTML faltantes al módulo, incluyendo el botón para disparar la acción para
eliminar usuarios que se crearon anteriormente.
Dentro de un enlace podemos pasar directamente el modelo de Eloquent en lugar de $user-

>id:

También podemos pasar directamente el modelo de Eloquent sin el arreglo:
Esto hace que nuestros enlaces queden más limpios:
Enviar peticiones PUT o DELETE

Para poder enviar una petición de tipo POST, PATCH, PUT o DELETE necesitamos usar un
formulario. Al utilizar el formulario para solicitudes PATCH, PUT o DELETE el atributo
method del campo form debe ser igual a POST y le indicamos a Laravel que la solicitud es
PATCH, PUT o DELETE agregando un campo oculto con method_field():

Agregando estilos de Bootstrap 4
En la octava y última parte del curso vamos a agregar estilos de Bootstrap para que el módulo
de usuarios, desarrollado en las partes anteriores del curso, luzca mucho mejor.
Agregar estilos de Bootstrap 4 al listado de usuarios en Laravel

Ahora veremos cómo podemos agregar estilos de Bootstrap 4 a nuestra aplicación y cómo
podemos usarlos para personalizar el listado de usuarios. De esta manera le daremos un mejor
look&feel al módulo CRUD de usuarios que hemos desarrollado hasta ahora.
Notas:
• Para utilizar Laravel no es obligatorio usar Bootstrap. Puedes usar tus propios estilos
personalizados o cualquier otro framework de CSS como Materialize o Foundation.
• Puedes encontrar los enlaces al CDN de Bootstrap en la documentación oficial.
Puedes verificar si una colección no está vacía utilizando el método isNotEmpty():

Para mostrar un ícono de Iconic puedes utilizar las etiqueta <span> pasando el nombre del
ícono como valor de la propiedad class:
Agregar estilos de Bootstrap 4 al formulario en Laravel

Agregaremos estilos de Bootstrap a nuestra aplicación, esta vez al formulario para crear
nuevos usuarios.
Actividad
Mejora los estilos del formulario para editar y de la página de detalle del usuario.

Curso Básico de Laravel - Terminado Apuntes PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso Básico de Laravel - Terminado Apuntes PDF

Cargado por

Copyright:

Formatos disponibles

Tecnológico Nacional de México

Instituto Tecnológico Superior de Puruándiro

División de Ingeniería en Tecnológias de la

Curso: Framework Laravel Básico 2

Curso: Framework Laravel Básico 3

Curso: Framework Laravel Básico 4

Instalación de Composer y Laravel

Preparación del entorno de desarrollo

• En Windows puedes usar: Laragon, un entorno de desarrollo para Laravel en Windows

Curso: Framework Laravel Básico 5

composer create-project --prefer-dist laravel/laravel mi-proyecto

Curso: Framework Laravel Básico 6

composer global require "laravel/installer"

laravel new nombre-proyecto

y se instalará tal y como se hizo con el comando composer create-project.

Abrir la aplicación creada

php artisan serve

Este comando ejecuta la aplicación en un servidor de desarrollo incluido por defecto en

Curso: Framework Laravel Básico 7

Para detener la ejecución presiona Ctrl + C

Curso: Framework Laravel Básico 8

composer create-project laravel/laravel nombre-proyecto "5.5.*"

El patrón de diseño Front Controller consiste en que un solo componente de la aplicación

En Laravel esta función la cumple el archivo index.php que se encuentra en el directorio

Curso: Framework Laravel Básico 9

Para ver la ruta en funcionamiento debemos escribir en el navegador algo como:

Curso: Framework Laravel Básico 10

Rutas con filtros o restricciones de expresiones regulares en los parámetros

Curso: Framework Laravel Básico 11

• Usando el método where para agregar condiciones de expresiones regulares a la ruta.

Rutas con parámetros opcionales

Curso: Framework Laravel Básico 12

Escribiendo una prueba

Curso: Framework Laravel Básico 13

Curso: Framework Laravel Básico 14

Hecho esto, en el directorio app/Http/Controllers tendremos nuestro controlador

Curso: Framework Laravel Básico 15

Enlazar una ruta a un controlador

Controlador de un solo método

Curso: Framework Laravel Básico 16

Curso: Framework Laravel Básico 17

Crear una vista

Retornar una vista

Curso: Framework Laravel Básico 18

Con with también podemos pasar las variables de forma individual:

Curso: Framework Laravel Básico 19

Escapar código HTML

Blade, el Sistema de plantillas de Laravel

Curso: Framework Laravel Básico 20

También podemos utilizar la directiva @if:

Curso: Framework Laravel Básico 21

Curso: Framework Laravel Básico 22

Curso: Framework Laravel Básico 23

Utilizando el comando view:clear podemos eliminar desde la terminal la vistas en caché:

Curso: Framework Laravel Básico 24

Curso: Framework Laravel Básico 25

Extender de una plantilla

Curso: Framework Laravel Básico 26

Indicamos el final o cierre de la sección con la directiva @endsection.

Curso: Framework Laravel Básico 27

Curso: Framework Laravel Básico 28

Introducción a las bases de datos y migraciones con Laravel

Qué son las migraciones