Laravel 5

Instalación
Debemos tener instalado los siguientes componentes para poder empezar a desarrollar
proyectos en Laravel 5:
- Xampp  https://www.apachefriends.org/es/index.html
- Editor  https://www.jetbrains.com/phpstorm/
- Composer  https://getcomposer.org/download/
- Git  https://git-scm.com/
NOTA: Se recomienda descargar MAMP, es un gestor de descarga para Laravel

También se puede guiar de la misma documentación de Laravel para instalar lo

necesario para ejecutarlo, https://laravel.com/docs/5.6
Una vez terminada esta instalación previa, ya podremos ubicarnos en la carpeta destino
donde se va a crear nuestro proyecto de Laravel 5 y ejecutaremos el comando
composer create-project laravel/laravel Proyecto para crearlo. (Para crear una
versión específica solo debemos agregar el “5.#.0” al final del comando)

Crear un Proyecto
Se creará mediante Git Bash, dando click derecho en la carpeta principal y en la opción
Git Bash Here.
Una vez en el Git pondremos la siguiente consulta composer create-project --prefer-
dist laravel/laravel NombreProyecto "5.6.*"
Iniciar el servidor del proyecto
Para iniciar el proyecto y confirmar que la instalación de laravel se completó
correctamente, debemos ir a nuestra terminal, ubicándonos dentro de la carpeta del
proyecto, y ejecutar el comando php artisan serve, luego nos mostrará el link donde
se está ejecutando, lo copiaremos y pegaremos en nuestro navegador.

Configuración
Nombre de la aplicación
Por defecto el nombre de la aplicación es App, para poder cambiarlo a nuestra
preferencia, debemos abrir nuestra terminal y ejecutar el comando
php artisan app:name NombreAplicación, lo cual cambiará el nombre en todas sus
referencias.
Zona horaria
Para cambiar la zona horaria e indicarle en la cual nos encontramos debemos saber
primero cual es nuestra zona horaria, para ello podemos ir al siguiente link
http://php.net/manual/es/timezones.php

Una vez encontrada la copiaremos y nos ubicaremos en el archivo config / app.php y

buscaremos la declaración timezone, allí pegaremos y estará configurado.

Lenguaje de mensajes
Para cambiar el lenguaje, primero debemos crear la carpeta donde estarán ubicados
todos los mensajes que mostrará, para ello iremos al siguiente repositorio
https://github.com/caouecs/Laravel-lang/tree/master/src , aquí elegiremos la
abreviatura del lenguaje que deseemos instalar, luego en el proyecto nos ubicaremos
en Resources / Assets / Lang y tendremos que insertar allí la carpeta (descargada o
copiada del repositorio) para que quede del siguiente modo.

Y como podemos ver en la segunda imagen, el último paso es ubicarse en el archivo

config /app.php y cambiar el valor del locale al nombre del idioma descargado.
Verbos Http
Los verbos http son los modos en que se pueden realizar las transferencias de
información mediante el http, entre estos modos tenemos:
 GET: Sirve para recibir un recurso especificado.
 POST: Sirve para enviar información y que sea procesada.
 PUT / PATCH: Sirve para modificar una información existente.
 DELETE: Sirve para borrar alguna información existente.

Rutas
Las rutas están ubicadas en la carpeta routes, hay 4 tipos de archivos de rutas, en este
caso especificaremos el web.php, las rutas pueden usar los verbos http para indicar la
funcionalidad de la ruta.
Una ruta usualmente devuelve una vista, en el primer parámetro que se le da se indica
el link con el que se accederá a la ruta y en el segundo que retornará (En este caso es
la vista principal, y retornará la vista Welcome)

También puede devolver como segundo parámetro un simple String

.
Parámetros
Se puede indicar que una ruta recibirá un parámetro, esto se hace agregando una
variable entre llaves, cuando se declara un parámetro es necesario indicarle a la
función de retorno que recibirá ese mismo parámetro para que pueda ejecutar sus
funcionalidades.
Si queremos indicar que un parámetro es opcional, le agregaremos un signo de
interrogación al final de su declaración entre llaves, y en la función debemos indicar
que será de null inicialmente.
Restricciones
Podemos controlar que caracteres recibirá nuestra ruta (números o letras), poniendo al
final de cada ruta el siguiente código.

Controlador
Para crear un controlador de forma rápida y sencilla, abriremos nuestra terminal y
ejecutaremos el comando php artisan make:controller NombreControlador para
crearlo automáticamente.

Una vez creado solo debemos agregar una referencia al

archivo controlador principal para que esté listo para
usarse, en este caso crearemos una función simple que
retorna un String.

Para poder decirle a una ruta que usará una función definida en un controlador, solo
debemos enviarle como segundo parámetro el nombre del controlador seguido del
nombre de la función y listo, tal como se muestra en la imagen.

Ahora si queremos enviarle parámetros a las funciones dentro del controlador, primero
debemos agregar el parámetro en la ruta, como ya se explicó anteriormente, y luego en
la función del controlador indicarle que recibirá un parámetro.
Controlador Resource
Un controlador resource tiene las funcionalidades de un CRUD (Crear, Leer, Actualizar,
y Borrar), nos facilita una interfaz en el controlador para poder desarrollar estas lógicas,
para crearlo debemos abrir nuestra terminal y ejecutar el comando php artisan
make:controller –resource

Para poder enlazarlo a una ruta, debemos definir esta de modo resource también, y
aquí solo llamaremos al controlador, no a una función específica.

En la documentación de Laravel
https://laravel.com/docs/5.6/controllers nos muestra
cómo utilizar los métodos estándar definidos en el
controlador resource, como por ejemplo la función
Index se ejecuta al ingresar al controlador.

Vistas
Creando una vista
Para crear una vista solo debemos ubicarnos en la carpeta Resources / Views, darle
a nuevo archivo, darle un nombre a la vista y terminar con la extensión .blade.php, una
vez creado podemos insertar todo el código HTML que deseemos.
Podemos ayudarnos de Bootstrap (https://getbootstrap.com/docs/4.1/getting-
started/introduction/ ) para poder diseñar un formulario adecuado, para instalarlo solo
debemos referenciar su link y scripts según dice su documentación.
@yield y @section
La propiedad yield y section se usan cuando queremos cambiar contenido de otras
vistas, como son algunos casos en las vistas de cabecera y pie de página.
El yield se define en la vista destino y se define una variable cuyo valor será definido
por otra vista que lo use, el section se usa el vista origen y define qué valor tendrá
una variable yield de una vista destino, esto va acompañado de un extends que indica
cual es la página destino.
Cabecera – Vista Destino (Contiene solo un título para la página)

Entrenador – Vista Origen

Funciones
Función If
Se puede implementar la función If en las vistas Blade anteponiendo el @ antes del If
y del end, después de esto ya se puede trabajar como si fuera PHP normal, indicando
cual será la condición a cumplirse.
Función For
Se puede implementar la función For del mismo modo que la función If, solo que aquí
se debe inicializar la variable control y especificar su interacción.

Función Foreach
La función Foreach se usa para recorrer un arreglo y mostrar todos sus objetos, se
nombra del mismo modo que la función If, solo que aquí se trae la variable que contiene
el arreglo y se le indica cual es el nombre de la variable que almacenará los objetos de
forma individual.

Función While
Para utilizar la función While se debe indicar una variable control y el límite de está
para indicar el final de la función (si no se hace será infinita), y establecer dentro del
código el aumento de la variable para alcanzar el límite.

Agregar una vista dentro de otra

@include
Para llamar el contenido de un Blade e insertarlo dentro de otro solo debemos escribir
@include de la manera en que se muestra en la imagen, indicando la ubicación de la
otra vista. En la segunda parte del código podemos enviar información y almacenarlas
en variables que puedan ser utilizadas en la otra vista.

Nota: Podemos llamar a otra vista las veces que queramos

@extends
El extends se usa para traer las visas de cabecera y pie
de página, primero se debe definir en dichas vistas las
secciones que dividirán y definirán el contenido.
Y luego en la vista que usará este contenido, podemos usar la propiedad @parent para
poder mantener el contenido intacto y así poder agregarle más cosas si deseamos.

@yield
El atributo yield se usa poder definir una variable y que otra vista que heredará esta le
pueda definir su valor, así se vuelve de forma más dinámica una misma cabecera
cuando va cambiando entre vistas.
- Vista 1

- Vista 2

Dando una ruta para la vista

Para enlazar la vista con una ruta tendremos que definir una para ella en el archivo de
rutas que elija (web.php), si el controlador a utilizar es de tipo resource entonces ya no
será necesario referenciar cada vista (solo si la vista tiene como fin un procedimiento
CRUD no se referencia) y utilizaremos la ruta definida según la documentación en
Laravel.
Request
Los http request nos permiten enviar información desde nuestras vistas HTML hacia
nuestros controladores, como ya mencionamos antes en el caso de los controladores
resource, estos cuentan con unas rutas ya definidas que ahora utilizaremos.

Hay rutas que son semejantes, Laravel las puede diferenciar gracias al verbo http que
se le indica, en la siguiente imagen vemos que englobamos nuestro ejemplo de
formulario en una sola etiqueta form, en esa etiqueta especificamos que tendrá un
método de POST y que ejecutará la función, que según el cuadro anterior, es store.

Si nos ubicamos en nuestro

controlador, en la función store,
veremos que esta recibe un request,
este request almacena toda la
información que será enviada a esta
función (en este caso el formulario), pero especificamos que solo queremos la
información enviada por el input de nombre “Nombre”.
MySQL
Configuración
Usaremos MySQL en este caso, pero si deseas usar otro gestor de base de datos
entonces deberás ir al archivo config / Database.php y allí podrás cambiarlo indicando
cuál será la conexión por defecto, Laravel acepta 4 gestores que son MySQL, sqLite,
pgSQL, sqlSRV.

Adicionalmente debemos ubicarnos en la carpeta

App / Providers / AppServiceProvider.php y agregar las siguientes líneas de código
para evitar conflictos con versiones antiguas de gestores de base de datos a la hora de
hacer migraciones.

Conectar a la base de datos

Usaremos Navicat como editor de base de datos (o use
el de su preferencia que sea compatible con MySQL), en
él crearemos una base de datos con la cuál
conectaremos al proyecto (En este caso se llama
entrenador). Luego en el proyecto, nos ubicaremos en el
archivo .env y allí realizaremos la configuración necesaria
para la conexión con la base de datos.
Donde, DB_CONNECTION es el tipo de conexión, DB_HOST es la dirección IP o host
donde estará nuestro gestor de base de datos, DB_PORT es el puerto que se usará
para conectarse a la BD (de Xampp es 3306 y de Wamp es 8889; no olvidar
levantarlos), DB_DATABASE es el nombre de la base de datos, y USERNAME y
PASSWORD son los mismos que los establecidos en el gestor de base de datos para
poder acceder a ella.
Modelos y Migraciones
Los modelos nos permiten indicar a Laravel como es la estructura de nuestra base de
datos definiendo cada tabla en un modelo, las migraciones indican los atributos que
tiene cada modelo (tabla) para que pueda ser exportado a la base de datos desde
Laravel, estos 2 van de la mano, así que para crearlos rápidamente ejecutaremos el
siguiente en nuestra terminal comando
php artisan make:model –migration.

NOTA: La ubicación de los modelos están en la carpeta App,

y las migraciones en Database / migrations.

Lógica de las migraciones

El archivo de migraciones contiene 2 funciones
preestablecidas, la función up que se encarga de
crear la tabla y levantarla, y la función down que se
encarga de eliminarla. Dentro de la función up
indicaremos todos los atributos que nuestra tabla va
a tener, como se puede ver en la imagen
especificando cada tipo de dato. Una vez terminado
esto podremos ejecutar el comando php artisan
migrate y Laravel insertará todas las migraciones en
la base de datos ya configurada. Laravel migra 3
tablas por defecto, 1 para el registro de las
migraciones realizadas, y las otras 2 para la autentificación de usuarios que más
adelante veremos. (En este punto ya se puede insertar datos)
Lógica de guardar
El controlador, específicamente en la función Store (o en la que se decida aplicar la
lógica de guardar), recibirá una variable Request que almacenará toda la información
del objeto a guardar, lo primero que hay que hacer es crear una variable que almacene
el modelo, luego a esa variable le indicaremos específicamente que parte del Request
recibirá cada atributo del modelo, por último solo debemos darle un método save para
indicar que guarde los cambios.

Listado
Crearemos una vista donde se muestre el listado de todos objetos de nuestra tabla
(entrenadores), para ello en la función Index del controlador (porque esta función está
definida para listar según el resource) definiremos una variable que extraiga todos los
objetos mediante el método All (Después de los “ :: ” son métodos para trabajar con
tablas / modelos) y la enviaremos a una nueva vista junto con esta variable mediante
un compact.

Para diseñar la vista de entrenadores nos apoyaremos de Bootstrap, utilizando los

NavBar y los Cards, los Cards se implementarán en la vista de listar para que cada
objeto se pueda mostrar en una carta utilizando la función foreach también, y el NavBar
en nuestro layout o cabecera ya que estará visible en toda la aplicación.
Cards NavBar
Guardar archivos (imágenes)
Primero, en nuestra vista de crear un nuevo objeto, le agregaremos un input de tipo
file con el cuál podamos subir el archivo necesario (especificando un atributo name
para poder llamarlo), debemos agregar a nuestro formulario una especificación enctype
de form-data para que se pueda enviar el archivo como tal junto a los datos del
formulario.

NOTA: Agregar en la tabla de la base de datos un atributo que almacene la imagen / archivo
(En este caso es Avatar)

Luego, en nuestro respectivo controlador

debemos verificar si lo que se recibe en el
input file (mediante su nombre) es un
archivo, si lo es almacenaremos ese
archivo en una variable, definiremos su
nombre de archivo, moveremos ese archivo
a la carpeta que deseemos (ubicada en la
carpeta Public), e insertaremos el nombre
que le asignamos a la imagen en la base de
datos para que pueda ser llamada después.
Por último, ahora que la imagen ya se puede registrar en la base de datos debemos
mostrarla en nuestra lista de objetos, para ello creamos una etiqueta imagen y le
indicaremos la ruta respectiva donde están guardadas las imágenes.
En este punto del proyecto ejemplo, vamos a darle un poco más de diseño a nuestra
vista de listado de objetos, puede realizarlo a su gusto, en este caso utilizamos los
siguientes estilos y clases.

NOTA: No es buena práctica usar Style dentro de las mismas etiquetas, lo correcto sería
definir los Style por clase en una sección aparte

Vistas Detalle
Primero, en la vista del listado de los objetos, crearemos un botón que al presionarlo
nos re dirija a una vista donde se muestre el ID del objeto seleccionado, los
controladores resource definen que cuando se envía una ruta del objeto con su ID
entonces quieren mostrar sus detalles, por lo cual la función que ejecutan es la función
show.

La función show recibe un ID como ya explicamos, entonces con este ID usando

Laravel Eloquent (Interacciones con la BD) podremos buscar el objeto mediante su ID
y retornaremos a una nueva vista que pueda mostrar el detalle del objeto.
Por último creamos la vista en la que
se mostrará los detalles y
especificaremos que los muestre
mediante el objeto enviado (en caso
de la descripción se está haciendo
estática solo por este ejemplo)

Slugs
Los Slugs vienen a ser de forma resumida un atributo de una tabla que se usa para
mostrarse en las rutas de las vistas de detalle cuando se ingresa a una, evitando así
que los usuarios puedan entender la lógica y puedan malograr de alguna forma el
sistema. Estos Slugs pueden ser combinaciones de lo que se graba en otros atributos
para generar de ese modo un código único.
Por ejemplo crearemos un Slug que sea la concatenación del nombre del entrenador
con su número de ID, generando así un nuevo código, claro que el Slug debería ser
más complejo y de preferencia no incluir el ID porque habría problemas a la hora de
crear el Slug durante el registro de un dato.

NOTA: Debemos crear previamente un atributo Slug para la tabla.

Editar
Para editar un objeto primero debemos traer sus datos para que puedan ser
modificados, para ello en la vista de detalles le agregaremos un botón que nos enlace
a otra vista donde nos pueda traer los datos correspondientes del objeto.

NOTA: El edit en la ruta esta por defecto cuando se usa un controlador resource

Por defecto la función que se usará en el controlador es la edit, allí indicamos que nos
re direccionará a la vista donde podremos visualizar los datos (enviándole el objeto a
modificar)

Crearemos la vista siguiendo el siguiente formato, donde especificamos que usará un

método PUT especialmente (ya que HTML no soporta otros métodos aparte del POST
y GET), indicamos que la acción del formulario caerá en la ruta con Slug (que indica
que irá a la función update del controlador) y que cada input recibirá el valor
correspondiente desde el objeto traído.

Luego en el modelo del objeto debemos indicar cuales son los

campos que se van a poder modificar, la modificación se realizará
mediante un método fill en el controlador, por lo cual en el modelo
especificamos que se habilitará ese método para los atributos.
Por último ya con la información recolectada, en la
nueva vista podremos modificar la que deseemos y
enviarla a la función, en la cual usaremos el método
fill para actualizar los datos, este método compara
los names de los inputs en el HTML con los nombres
de los atributos de la BD para insertar cada uno
donde corresponda, también actualizaremos el Slug
y el atributo nombre.

Request y Validaciones
Los Request van a almacenar todas nuestras validaciones en un archivo dedicado a
eso, es mala práctica tener la lógica de almacenamiento (guardar, editar, etc.) junto a
las lógicas de validación.
Para crear uno abriremos nuestra consola y ejecutaremos el comando
php artisan make:request NombreRequest, lo cual nos creará el request y lo
guardará en App / Http / Request

La primera función nos indica si las funciones que usarán este request tendrán acceso
a sus validaciones, siempre hay que indicar que si (true), y la segunda función retorna
un arreglo de validaciones, aquí colocaremos las que deseemos implementar, podemos
guiarnos de la documentación de Laravel para saber todas las validaciones disponibles
https://laravel.com/docs/5.7/validation
Laravel también nos provee una forma de mostrar
mensajes de error cuando las validaciones no se
cumplen, solo debemos escribir el siguiente código
(que es por defecto) en el HTML de la vista que
usará las validaciones para que se muestren los
errores respectivos.

Eliminar
Primero debemos crear un formulario en la vista detalle que posea un método DELETE
y reciba como acción la vista del objeto con su identificador (en este caso es el Slug),
en él solo debemos crear un botón que ejecute esta acción.

Este formulario por defecto nos enviará a la

función destroy del controlador resource, allí
le indicaremos que busque el objeto mediante
el Slug, luego elimine la imagen, que al ser un
archivo tiene que crearse una variable que
almacene su ruta y pueda ser eliminado
mediante el Eloquent de File, y por último
usamos la propiedad delete para eliminar al
objeto encontrado de la base de datos.

Re direccionar
Usualmente cuando la acción de una
función se completa la aplicación debería
re direccionarnos a otra vista, como es
el caso de cuando se crea un objeto
debería retornar al listado de los mismos,
para ello solo debemos utilizar las
propiedades redirect y route seguido del
nombre de la ruta a la cual se enviará.
En el caso de los controladores resource, para saber el nombre de su ruta nos iremos
a la terminal y ejecutaremos el comando php artisan route:list, con el cual podremos
ver las rutas correspondientes .
Si queremos indicar que la vista a re direccionar recibirá un parámetro debemos hacerlo
de la siguiente forma
Notificar acción
Para notificar una acción usaremos el método with en el return de nuestra función,
este método envía información (variables) a la visa destino que se especifica, para
funcione debemos indicarle primero el nombre de la variable y luego la información que
va a contener.

Por último, en la vista destino, debemos indicar como se

mostrará esa variable, en este ejemplo solo utilizaremos
un div que se mostrará solo cuando dicha variable que
proviene del método with exista.

Common
Podemos crear una carpeta Common en App / Views, en ella podremos agregar todas
las vistas que podrán ser utilizadas por muchas otras vistas o controladores, como por
ejemplo son los casos de error y notificación de acción descritas anteriormente, solo
debemos cortar dichos códigos y pegarlos en las nuevas vistas dentro del Common, e
incluirlos en las vistas donde estaban o se utilizarán.

NOTA: Se debe declarar en los controladores respectivos la variable que recibirá los archivos
en la carpeta Common (ejemplo la variable Estatus)
Autentificación
Creación y Personalización
Laravel ya nos provee poder un comando para poder crear las vistas, controladores, y
modelos de la autentificación de usuarios (login) de forma automática, para crearlos
debemos ejecutar el comando php artisan make:auth.

Roles de Usuario
Muchas veces es necesario especificar los roles de un usuario, esto se hace para definir
las características y permisos que puede tener cada usuario, primero tenemos que
crear los modelos necesarios que son 2 (Roles y la intermedia entre Roles y Usuarios),
luego en cada uno debemos agregar los atributos que se agregarán a las tablas.

NOTA: Estos atributos para roles son básicos.

NOTA: Esta tabla es una intermedia, por lo cual almacena los ID de las otras 2

Luego ejecutamos el comando php artisan migrate para que se almacene en la base
de datos.
Después para unir las tablas mediante Laravel escribiremos el siguiente código en los
modelos respectivos de Roles y Usuarios, indicando que cada uno estará enlazado con
el otro mediante una relación de uno a muchos.

Seeder
Los Seeder vienen a ser funcionalidades de Laravel que se utilizan para generar datos
de prueba o almacenar datos al inicio de las tablas respectivas.
Para crear uno ejecutaremos el comando php artisan make:seeder NombreSeeder,
se ubicarán en App / Database / Seeds, para la autentificación debemos crear uno para
roles y otro para usuarios.

NOTA: Los Seeder se pueden utilizar en tablas a las cuáles no se les realizará mantenimiento

Una vez creados, primero nos ubicaremos en el Seeder de

los roles, allí le indicaremos que creará y guardará 2 datos
(administrador y usuario).

Luego en el Seeder de Usuario, crearemos 2

variables donde almacenemos cada rol creado
anteriormente (buscado por su nombre), luego
guardaremos 2 nuevos usuarios, uno
administrador y otro usuario, donde la
contraseña (query) es encriptada por el método
bcrypt, y se le asigna el rol mediante el attach.
Luego, en la misma carpeta Seeds, se encuentra por defecto el DatabaseSeeder.php,
este archivo es quien llama a los Seeder creados para poder ejecutarlos.

NOTA: Aquí el orden sí importa pues los ejecutará en el mismo orden que se indica, en este
caso los roles deben ir primero ya que el Seeder de usuario utiliza al de roles.

Y por último ejecutaremos el comando php artisan migrate:refresh --seed para que
la información declarada en los Seeder pueda ser trasladada a la base de datos.

Lógica de Validación de Roles

Para validar si un usuario tiene un rol crearemos 3 funciones en el modelo del usuario,
la primera será la principal y se encargará de recibir como parámetro un rol, usando el
$this podremos indicar a la función
que estamos utilizando el usuario
conectado, entonces diremos que ese
usuario comprobará si en su relación
con el modelo Roles tiene alguno que
sea igual al parámetro dado, de ser así
indica que el usuario si posee un rol y
retornamos true.
La segunda función recibe como parámetro un
arreglo de todos los roles existentes para buscar
si el usuario posee alguno, primero se verifica si
el parámetro enviado es un arreglo, si lo es
utilizamos un foreach para recorrer todo el
arreglo y probar uno por uno si el usuario posee
alguno de estos roles (apoyándonos de la
función anterior), y si no es un arreglo entonces
es un solo rol, por lo cual se utiliza de frente la
otra función.

La última función sirve para identificar si el usuario está autorizado verificando que este
posea un rol, para ello solamente llamará a la función anterior y si esta no puede
verificarlo entonces abortará todos los procesos y le indicará que no tiene permisos.

Por último para implementar esta lógica en nuestro controlador, nos iremos a la función
que muestra nuestro listado de objetos, y allí utilizaremos una variable request (ya que
esta almacena los datos del usuario) para que esta se ejecute con la función de
autentificación y lo valide.