Apuntes Laravel

CURSO LARAVEL 8
Apuntes del curso en CodersFree
Descripción breve
Este es un curso tomado del canal “CodersFree” de Youtube.
Se puede buscar como “Curso Laravel desde cero”
Curso de YouTube.
https://www.youtube.com/playlist?list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF
Tabla de contenido
CAMBIAR ENTRE VERSIONES DE PHP (XAMPP)................................................................9
01 CREAR UN NUEVO PROYECTO EN LARAVEL...............................................................10
Método 1................................................................................................................................10
Método 2................................................................................................................................10
02. INSTALACIÓN DE EXTENSIONES...............................................................................10
Laravel Blade Formatter..........................................................................................................10
Php Inteliphese.......................................................................................................................11
Laravel Blade Snippets............................................................................................................11
Laravel Snippets......................................................................................................................11
Laravel goto view....................................................................................................................11
Spanish Languaje Pack for Visual Studio..................................................................................11
Tailwind CSS IntelliSense.........................................................................................................11
Alpine.js IntelliSense...............................................................................................................12
GitHub Copilot........................................................................................................................12
JSON Formatter.......................................................................................................................12
03.- Rutas en Laravel ¿Qué son y para que sirven?........................................................13
Definir una ruta.......................................................................................................................13
Definir una segunda ruta (URL )..............................................................................................14
Usar variables en las rutas.......................................................................................................14
Definir más de una variable en la ruta.....................................................................................15
04.- CONTROLADORES EN LARAVEL QUE SON Y PARA QUE SIRVEN...............................15
Crear el controlador................................................................................................................15
Asignar el control de una ruta a un controlador......................................................................16
Llamar controladores versión 8 Laravel....................................................................................................17
Definiendo controlador para la ruta raíz (página principal del proyecto)...........................................17
Definiendo controlador para rutas diferentes a la raíz del proyecto..................................................17
Llamar controladores versión 7 Laravel....................................................................................................19
05.- GRUPO DE RUTAS DE CONTROLADORES.................................................................20

06.- VISTAS EN LARAVEL................................................................................................21
Creación de vistas...................................................................................................................21
Método View pasando parámetro ruta raíz............................................................................22
Método view pasando parámetro ruta diferente a raíz...........................................................22
Método View pasando parámetro ruta con variable...............................................................22
Abreviatura para pasar una variable como parámetro al método View compact()................................23
Uso de plantillas en Vistas (Blade)...........................................................................................23
Usando blade para sustituir echo php dentro de HTML por {{}}..............................................................24
07.- Introducción al manejo de base de datos con Laravel.............................................25

08.-Introducción a las migraciones................................................................................26
¿Que son las migraciones?......................................................................................................26
Estructura de un archivo.........................................................................................................26
Crear una tabla (método “create()”).......................................................................................26
Crear tabla y columnas.............................................................................................................................26
Eliminar una tabla (método “dropIfExists()”)..........................................................................28
Eliminar todas las tables de la base de datos y volverlas a crear en línea de comando...........28
Eliminar todas las tablas (sin volver a crearlas).......................................................................29
Ejecutar una migración (ejecución del método “up()”)............................................................29
Revertir migraciones (ejecución del método “down()”)..........................................................29
Lotes de migración..................................................................................................................29
¿Que es un lote?.......................................................................................................................................30
09.- Como crear migraciones en Laravel........................................................................31

10.- Como modificar tablas con migraciones.................................................................32
Agregar una nueva columna....................................................................................................33
Modificar las propiedades de una columna.............................................................................34
Renombrar una columna.........................................................................................................35
11.- Inserción de registros en la base de datos (introducción a eloquent)......................36
Creación de modelos...............................................................................................................36
Crear modelos y otro tipo de clases simultáneamente............................................................................37
Valores predeterminados (propiedades) al crear un modelo..................................................................38
Tinker para insertar registros en línea de comandos forma1...................................................38
Inserción de registros en la tabla..............................................................................................................39
Revisar el contenido a guardar en la tabla de base de datos...................................................................40
Guardar la información en la tabla de la base de datos...........................................................................41
Actualizar un registro ya existente en la tabla de base de datos.............................................................42
Tinker para insertar registros en línea de comandos forma2...................................................43
Guardar un segundo registro o más en la tabla de la base de datos.......................................................44
12.-Creacion de datos de “prueba” en las tablas...........................................................44

Seeders...................................................................................................................................44
Codificar seed para que tenga la información a ingresar en la base de datos.........................................44
Ejecutar Seed (guardar los registros en la db)..........................................................................................45
Otras maneras de ejecutar el comando Seed......................................................................................46
Crear un archivo Seed para cada tabla de la base de datos.....................................................................46
Invocar otros archivos Seed desde el archivo “DatabaseSeeder.php”................................................47
13.- Ingresar varios registros de prueba a la base de datos sin usar “seeders” (factory).
.....................................................................................................................................48
Crear un archivo Factory.........................................................................................................49
Convención para la crear un archivo Factory...........................................................................................51
Definición de tipo de contenido para la Base de datos en el archivo Factory.........................................52
Métodos (Tipo de contenido) para faker..................................................................................................53
Ejecutar el factory...................................................................................................................55
14 - Realizar consultas a la base de datos con “eloquent”.............................................56
Métodos eloquent y su equivalencia en script........................................................................57
 all()...................................................................................................................................................57
 where(‘NombreColumna’, ‘operador’(opcional), ‘valorAFiltrar’)...................................................57
 get().................................................................................................................................................58
 Orderby(‘NombreColumna’, ‘valorAsc/Desc’)................................................................................58
 first()................................................................................................................................................58
 value(‘nombreColunma’)................................................................................................................58
 find(valorID)....................................................................................................................................58
 select(‘NombreColumna1’,’NombreColumna2-opcional’, ’NombreColumna3-opcional’, etc).....59
 as.....................................................................................................................................................59
 take(cantidad).................................................................................................................................59
15 – Mutadores y Accesores..........................................................................................59
Mutadores (set)......................................................................................................................59
Agregar Mutadores (Laravel 9.x)..............................................................................................................59
Agregar Mutadores (Laravel 8.x)..............................................................................................................61
Accesor (get)...........................................................................................................................61
Agregar Accesores (Laravel 9.x)................................................................................................................61
Agregar Accesores (Laravel 8.x)................................................................................................................62
Abreviatura al crear Mutadores, Accesores (laravel 9.x).........................................................63
Hacer test para probar los mutadores o Accesores.................................................................64
16 – Cómo listar y leer registros en Laravel...................................................................65
Recuperar datos de la base de datos y mostrarlo en un archivo HTML (view).........................65
Recuperar todos los datos de una tabla y mostrarlo en un archivo HTML (view)...................................65
Recuperar un solo registro (un solo campo) y mostrarlo con un determinado formato.........................65
Usar paginación para mostrar los registros que obtuvimos de la tabla...................................67
Poner botones con estilo CSS para desplazarse en la paginación de un archivo view............................68
Paginación con Tailwind.......................................................................................................................68
Paginación con Bootstrap....................................................................................................................69
Crear Alias para llamar a las rutas (URL)..................................................................................70
Crear una lista de con datos de una tabla y cada registro de esa lista sea un enlace el cual con
su ID nos redireccione a otro view para mostrar el campo nombre de ese ID.........................71
Codificación del archivo view Cursos (‘index.blade.php’)........................................................................71
Codificación del archivo controller Cursos (método show()....................................................................73
Codificación del archivo Vista final (show.blade.php)..............................................................................75
17 - Como agregar o actualizar registros desde un formulario.......................................75

Guardar los datos de un formulario en la base de datos.........................................................75
Crear un formulario en el archivo view....................................................................................................75
Agregar un token al formulario................................................................................................................77
Recuperar la información del formulario a una variable..........................................................................78
Guardar en un registro de la base de datos la información del formulario.............................................78
Redireccionar a otra página una vez guardado el formulario en la base de datos..................................79
Editar un registro de la base de datos a través de un formulario.............................................80
Crear un enlace en el archivo view (página web) para ir al formulario de edicion..................................80
Creación de la ruta y método para el formulario de edición...................................................................80
Recuperar datos de la base de datos para llenar el formulario a editar..................................................82
Abreviatura para recuperar datos de la base de datos para llenar el formulario a editar..................82
Llenar el formulario HTML con los valores recuperados de la base de datos para su edición................83
Creación de una nueva ruta (archivo web.php) y método (archivo controlador) para el nuevo
formulario.................................................................................................................................................85
Configuración del método “put” para actualizar la información en la base de datos........................85
18 – Validar formularios en Laravel...............................................................................87

Agregar una validación (Especificar los campos requeridos)...................................................87
Agregar varias validaciones (Especificar los campos requeridos)............................................................88
Especificar los componentes con error (mostrar mensajes de error).......................................89
Configurar los mensajes de error de la validación a español...................................................90
Evitar perder los datos del formulario cuando la validación sea falsa.....................................92
19 – Separar las validaciones en archivos propios (FormRequest)..................................93
Definición................................................................................................................................93
Creación..................................................................................................................................93
personalización de atributos (método Attribute).....................................................................................95
Personalización de mensaje (método message())....................................................................................95
Llamar el archivo Form Request..............................................................................................96
20 – Asignación Masiva de registros a la base de datos.................................................97
Codificar el archivo Controlador..............................................................................................97
Abreviatura de código para asignación masiva........................................................................................98
Codificar el archivo Modelo.....................................................................................................99
Actualización de registros utilizando la asignación masiva....................................................100
21 – Eliminar un registro de la base de datos...............................................................100
Creación de la ruta para eliminar un registro (archivo web.php)...........................................101
Creación del método para eliminar un registro(archivo controller).......................................102
Creación del botón en el archivo vista para eliminar el registro............................................103
Redireccionar al catálogo una vez eliminado el registro........................................................103
21 – Agrupar rutas con Route Resource.......................................................................104
Listar todas las rutas en línea de comando............................................................................104
Abreviando rutas con el método Route Resource.................................................................105
Cambiar las URL que se crean con el método Resource.........................................................107
Cambiar el nombre de la URL identificativa...........................................................................109
Cambiar el nombre de las variables utilizadas en el URL.......................................................110
23 – Como generar URLs amigables.............................................................................111
Agregar una nueva columna a la tabla en la base de datos...................................................111
Modificar el archivo Factory..................................................................................................112
Usando los Helper de Laravel.................................................................................................................112
Cambiar el valor de la variable que pasamos en el URL.........................................................113
24 – Agregar navegabilidad a nuestro sitio web..........................................................115
Agregar el código HTML para crear la navegación.................................................................115
Crear el menú de navegación.................................................................................................................115
Crear y agregar las rutas para la navegación.........................................................................116
Creación de la vista.................................................................................................................................117
Activar el Focus para el enlace activo....................................................................................118
Crear plantillas head y footer (usando Blade)........................................................................................121
25 – Como enviar emails con Laravel...........................................................................122

Configuración del email en el proyecto.................................................................................123
Configuración del proveedor..................................................................................................................123
Configurar la información del remitente................................................................................................125
Crear archivo Mailable para enviar correo electrónico..........................................................126
Creando el disparador para enviar el correo electrónico.......................................................128
Agregar diseño al cuerpo del email.......................................................................................129
26 – Como crear un formulario de contacto.................................................................130
Creando el enlace contáctanos en el archivo vista................................................................130
Configurar la ruta “contactanos” y creación de su controlador.............................................131
Creación del formulario en el archivo vista...........................................................................133
Activación del enlace de navegación (focus)..........................................................................................135
Creación y configuración de ruta – segunda parte.................................................................135
Pasar los datos del formulario al cuerpo del correo electrónico............................................135
Recuperar la información del formulario en una variable.....................................................................137
Configurar el archivo view para recibir los datos del formulario...........................................139
Validar la información que se enviara desde el formulario....................................................139
Definir las validaciones (archivo controlador)........................................................................................139
Definir los mensajes error (archivo vista del formulario).......................................................................140
Redireccionamiento de página al tener éxito el envío de email............................................140
27 – Kits de inicio: Laravel Breeze y Laravel Jestream..................................................142
Creando nuevo proyecto Laravel...........................................................................................142
Configuración de la base de datos..........................................................................................................143
Que es Breeze.......................................................................................................................144
Instalando Breeze...................................................................................................................................144
Que es Jetstream...................................................................................................................146
Instalación de Jetstream.........................................................................................................................147
Personalización de las funciones de JetStream (avatar, términos y condiciones).................................149
Habilitar el avatar del usuario............................................................................................................149
Crear acceso directo de carpetas dentro de carpeta Public.........................................................150
Configurar el almacenamiento de archivos..................................................................................151
Habilitar términos y condiciones.......................................................................................................151
Habilitar trabajar con equipo de personad........................................................................................152
Alpine......................................................................................................................................................153
Usar Bootstrap con JetStream (metodo1)..............................................................................................154
instalación en Laravel 8......................................................................................................................155
Usar Bootstrap con JetStream (metodo2 -correcto-) Laravel 9.............................................................156
28 – Laravel ahora usa Vite ¿Qué ocurrió con Webpack?.............................................158

29 – Componentes blade (de clase y anónimos)...........................................................160
Que son los componentes.....................................................................................................160
Como definir (crear) componentes........................................................................................160
¿Como se utiliza (llamar) el componente?.............................................................................161
Modificar el contenido de un componente............................................................................161
Modificar el contenido principal.............................................................................................................161
Modificar el título del componente........................................................................................................162
Múltiples slots.........................................................................................................................................163
Modificar el tipo de alerta (info, succes, danger)...................................................................................164
Variable $attributes................................................................................................................................165
Combinar atributo clase (merge).......................................................................................................165
Separar código php de la vista (componente de clase)..........................................................................166
Componentes de Breeze y Jetstream....................................................................................167
Componentes Breeze..............................................................................................................................167
Componentes JetStream........................................................................................................................168
Llamada de componentes JetStream.................................................................................................168
Llamada de plantillas en JetStream........................................................................................................168
30.- Modificando la plantilla de JetStream............................................................................170
Ruta de la plantilla................................................................................................................170
Defer.......................................................................................................................................................174
Cambiar el contenido principal de la vista Dashboard...........................................................174
Agregar link al menú de navegación en la vista Dashboard...................................................176
Como reutilizar la plantilla JetStream..........................................................................180
Agregar link al menú de navegación......................................................................................183
Redireccionando a la página principal al dar clic al logo........................................................185
31.- que son los middlewares......................................................................................187
Creación y asignación de un middleware..............................................................................187
Registrar el middleware..........................................................................................................................189
Asignar el middleware a una ruta en especifico.....................................................................................190
Diseño de base de datos (Modelo conceptual).............................................................192

Reglas de negocio..................................................................................................................192
Creando el diagrama DIAGRAM EDITOR................................................................................193
Crear entidades en DIAGRAM EDITOR...................................................................................................194
Creación de la relación entre las entidades............................................................................................195
Creación de la cardinalidad (relación de uno a muchos o combinaciones)...........................................197
Atributos de las entidades......................................................................................................................199
Clave primaria.........................................................................................................................................201
Diseño de Base de Datos (Modelo lógico)....................................................................202

Pasos iniciales Diagrama MySQL Workbech..........................................................................203
Relación 1 a 1........................................................................................................................206
Relación 1 a muchos..............................................................................................................209
Relación de muchos a muchos...............................................................................................210
Relación polimórfica 1 a 1.....................................................................................................212
Relaciones polimórficas uno a muchos..................................................................................214
Relaciones polimórficas muchos a muchos............................................................................216
Normalización de la base de datos..............................................................................218
1ra forma normal...................................................................................................................218
2da forma normal...................................................................................................................220
3ra Forma normal...................................................................................................................221
Diseño Físico Relación 1 a 1.........................................................................................222
Tipos de entidades................................................................................................................223
Creando el archivo migrate...................................................................................................223
Llave foránea en archivos migrate de laravel.........................................................................................224
Creando el archivo model......................................................................................................226
¿cómo puedo hacer para que cuando recupere el registro de un usuario también tenga acceso
al registro de la tabla profiles relacionado con ese usuario?.................................................226
Recuperando los registros de la tabla 2 al acceder a un registro de la tabla1.......................................226
Recuperando los registros de la tabla 1 al acceder a un registro de la tabla2.......................................228
Haciendo pruebas para recuperar los registros en línea de código.......................................................229
Diseño Físico Relación 1 a muchos...............................................................................230

Creando archivos migration y model en una sola línea de comando.....................................231
Creacion del archivo model y al mismo tiempo otros archivos (factory, seeder, controller, etc).........232
Contenido del archivo migrate..............................................................................................232
Recuperar registro de tabla 1 al consultar registro de tabla 2...............................................233
Recuperar registros de forma inversa de tabla 2 al consultar registros de la tabla1 (Relación
Inversa de Post a User)..........................................................................................................234
Haciendo pruebas para acceder a los registros en línea de comando....................................234
Diseño Físico Relación muchos a muchos.....................................................................234
Creando la relación a nivel de modelos.................................................................................236
CAMBIAR ENTRE VERSIONES DE PHP (XAMPP)
Este cambio nos permite poder ejecutar diferentes versiones de php en nuestra
computadora.
Para ello y que Windows lo reconozca debemos configurar las variables de entorno
Para ello en la lupa de Windows escribimos “var” (editar las variables del entorno del
sistema)
En las propiedades de sistema abrimos la opción Variables de entorno… (de la sección

inicio y recuperación)
En las variables de entorno nos vamos en la segunda sección (variables del sistema) y
buscamos “path” para darle oble clic.
En la ventana editar variable de entorno buscamos la ruta que tiene xampp.

Esta ruta es la versión de xampp que esta activa (que reconoce Windows). Si deseamos
ejecutar otra versión de xampp aquí debemos sustituir la carpeta por la versión que
queremos trabajar). En este ejemplo Windows está reconociendo la versión de xampp que
esta instalada en la carpeta C:\xampp_8\php
01 CREAR UN NUEVO PROYECTO EN LARAVEL
Antes de crear un proyecto se debe tener instalado los siguientes programas
Xampp
Composer
Visual Studio Code
Método 1
Dependiendo donde se haya instalado XAMPP buscamos la carpeta “htdocs”.
Luego en línea de comandos (puede ser GIT Bash) nos situamos dentro de esa carpeta.
Y escribimos el comando la instrucción (en este ejemplo example-app es el nombre del
proyecto):
composer create-project laravel/laravel example-app
Es importante escribirlo en minúsculas el nombre de proyecto
Método 2
Puede crear nuevos proyectos de Laravel instalando globalmente el instalador de Laravel a
través de composer.
Para ello vamos a la línea de comandos y escribimos la siguiente instrucción:
composer global require laravel/installer
(nota este comando se puede ejecutar en cualquier carpeta ya que tiene la palabra global)
Una vez instalador composer de manera global ahora cada que deseamos crear un nuevo
proyecto basta únicamente con realizar los siguientes pasos:
En la línea de comandos, situarnos en la carpeta donde queremos que se cree el proyecto.
Por ejemplo: /c/xampp/htdocs/
Luego escribir la siguiente instrucción (en este ejemplo example-app es el nombre del
proyecto):
laravel new example-app
02. INSTALACIÓN DE EXTENSIONES

Laravel Blade Formatter
Del autor Shuhei Hayashibara
Este curso lo que hace es que cuando se pega un código que se copio de otro lado,
normalmente esto lo pega de manera desordenada, por ejemplo una etiqueta es muy a la
izquierda y otra mas a la derecha.
Esto hace que por ejemplo una etiqueta de apertura y una de cierre se colocan en una
misma línea
Php Inteliphese
La que se utiliza es del autor Ben Mewburn
Tiene un icono de elefante. Esta extensión ahorra líneas de código de escritura. Me
permitirá que visual code autocomplete las líneas de código que necesito ahorrando
escribir líneas de código.
Por ejemplo, si sé que usaré el controlador CursoController, yo solo escribo “use” y el
nombre y esta extensión me escribe en automático todo el código necesario para usar
este controlador. Por ejemplo, escribo “use CursoController” y la extensión escribirá por
mi “use App\Http\Controllers\CursoController”
Laravel Blade Snippets

Del autor Winnie Lin
Tiene un icono de Laravel y primero las instrucciones de blade las resalta en color ya que
inicialmente estaban en blanco. Ayuda que visual code autocompletado el código
necesario para instrucciones de blade.
Laravel Snippets
Del autor Winnie Lin
Este es similar a Laravel Blade Snippets solo que nos proporciona ya para los archivos php
de Laravel. Por ejemplo para escribir rutas (route)
Laravel goto view

Del autor codingyu
Esta extensión nos permite movernos entre las diferentes vistas de Laravel.
Para ello apretamos control mas clic sobre el nombre de la vista y nos dirige al archivo
vista.
Spanish Languaje Pack for Visual Studio

Autor Microsoft
Nos permite ver visual studio Code en español.
Tailwind CSS IntelliSense

Del autor TailWind Labs. Generalmente con Laravel usamos Tailwind. Esta extensión me
permite que cuando yo escriba una instrucción Tailwind la extensión me da dando una
serie de opciones sobre lo que vamos a escribir.
Alpine.js IntelliSense
Del autor Adrian Wilcz´nski. Esta extensión es parecido en funcionamiento a lo que hace
Tailwind CSS IntelliSense pero para Alpine.js. Generalmente cuando trabajamos con
Laravel usamos la librería de Javascript Alpine.js. Por ejemplo, esto se instala por defecto
cuando instalamos paquetes de Laravel como Jetstream. Esto lo que hace es que cuando
vamos escribiendo código Alpine la extensión nos va dando “recomendaciones sobre las
instrucciones que escribimos”.
GitHub Copilot
Del Autor Github. Esta extensión se basa en inteligencia artificial. En la cual escribimos un
determinado código y dejando comentarios y en base a los comentarios que escribimos
nos va dando recomendaciones. Otras ocasiones se le va dando un nombre a una función
y en base a ese | nombre de la función te da una serie de recomendaciones o sugerencias
de código.
NOTA esta extensión es de paga (tiene un costo de 10 dolares mensuales)
JSON Formatter
Cuando por ejemplo traemos todos los registros de una tabla de la base de datos en
laravel (por ejemplo “NombreClaseModelo::all()” ) y la almacenamos en una variable y
posteriormente mostramos la información de la variable en una página web. El navegador
la muestra como una sola línea continua de todos los registros.
Esta extensión le dará un formato a la información para que no se muestre como línea
continua como se muestra a continuación:
03.- Rutas en Laravel ¿Qué son y para que sirven?
Al desarrollo en PHP por lo general se crea un archivo php por cada pagina que tenga la
aplicación web.
En Laravel tenemos un solo punto de entrada que es la carpeta public. Los usuarios que
interactúen con nuestra aplicación web solo podrán tener acceso a los archivos que están
dentro de esta carpeta. Po lo que los archivos de JavaScript u hojas de estilo (.css) aquí es
donde deben ir ubicados.
Cuando un usuario escribe una dirección web en especifico (una URL). Este URL pasa al
archivo web.php ubicado dentro de la carpeta “routes/web.php”. En este archivo es
donde definimos donde queremos que sea redirigido el usuario.
Cuando un usuario escriba una URL lo que hará Laravel es verificar si esa URL se ha
definido en el archivo web.php
Definir una ruta

Para indicar hacia donde se dirigirá una URL en específico, lo realizamos a través de la
función Route
Route::get('/', function () {
return view('welcome');
});
El código anterior es que cuando el usuario escriba la ruta raíz de la aplicación (‘/’) esta se
redireccionara al un archivo blade llamado welcome.blade.php (ubicado en la carpeta
“resources/views/welcome.blade.php”)
Cuando una URL no se define en el archivo web.php y el usuario intenta ingresar, esto
genera un error “404 | Page not found”
De a modo de prueba podermos cambiar el método view (que mande a un archivo vista)
por un “string”
//return view('welcome');
return "Bienvenido, estas en la página principal";
});
Esto lo que hace es que cuando se escriba la URL en el navegador imprimirá en pantalla
(en el navegador la etiqueta que se estableció)
IMPORTANTE: En caso de tener una segunda ruta o mas Laravel lee las rutas de arriba
hacia abajo por lo que si tienes dos URL similares, la acción que va a tomar será la primera
URL que encuentre y ahí de manera interna mete un break e interrumpe la búsqueda de
otra URL.
Definir una segunda ruta (URL )

Se escribe Route::get()
Dentro de get se define lo siguiente:
 La URL que queremos definir (en este ejemplo ‘cursos’).
 Una función anónima la cual define la actividad a realizar de esa URL (en este caso
regresa una impresión de pantalla con la cadena “Bienvenidos a la pagina cursos”.
 Route::get('cursos', function(){
 return "Bienvenido a la pagina cursos";
 });
Nota: la forma como esta escrito la URL Laravel identifica que cursos esta después de la
pagina principal (por decirlo de alguna manera, una carpeta dentro de raíz).
http://localhost/abril-23/public/cursos
donde
http://localhost/abril-23/public/ es el URL raíz.
Usar variables en las rutas

Las variables nos sirven para identificar una pagina web de otra. Para entender mejor
Si tenemos la URL http://localhost/abril-23/public/cursos/HTML5 y la URL
http://localhost/abril-23/public/cursos/javascript las variables a pasar seria HTML5 y
javascript ya que cursos seria fijo
Para ello definimos una ruta como en la sección anterior (“definir una segunda ruta”)
 Route::get('cursos', function(){
 return "Bienvenido a la pagina cursos";
 });
Para pasar una variable en la URL se define entre corchetes y también se la pasamos a la
función anonima entre paréntesis y dentro de la función en la cadena que regresamos la
imprimimos (de esta manera la impresión será dinámica de acuerdo al contenido que
traiga la variable)
Route::get('cursos/{curso}', function($curso){
return "Bienvenido al curso: $curso";
});
Nota: observe que la impresión de la variable esta dentro de las comillas del string.
Definir más de una variable en la ruta

Partiendo de la sección anterior donde se define una variable, lo único que se debe hacer
es pasar la otra variable y de igual manera ambas variables deben de definirse en la
función anónima.
Route::get('cursos/{curso}/{categoria}', function ($id, $categoria) {
return "Bienvenido al curso: $id, de la categoria $categoria";
});
Observe que donde se define la URL no necesariamente debe ser el mismo nombre que
recibe la función (en este ejemplo se define el nombre de la variable como {curso} y se
pasa a la función anónima como $id.
Variable Opcional.
Podemos definir que la variable sea opcional (tanto para la URL como para la función
anónima).
Esto se logra colocando un signo ? después del nombre de la variable en donde se define
la URL y en la función tenemos que definirle un valor (puede ser null). Como se muestra a
continuación
Route::get('cursos/{curso}/{categoria?}', function ($id, $categoria = null)
{
});
En este ejemplo, en la función anónima en automático su valor predeterminado de la
variable “$categoría” siempre será “null” hasta que le pasemos un valor a la variable
“categoría” del URL (donde se define el URL) 'cursos/{curso}/{categoria?}'
Con este ejemplo se puede manejar condicionales if para realizar una acción en caso que
la variable categoría de la URL tenga un valor o realizar otra acción en caso que no se haya
definido el valor de la variable categoría. Como se muestra en el siguiente ejemplo:
Route::get('cursos/{curso}/{categoria?}', function ($id, $categoria = null)
{
if ($categoria){
} else{
return "Bienvenido al curso: $id";
}
Nota: el if que evalúa la variable $categoria, es la variable que se denifio en la función

anónima y no es la variable de la URL. Esto es, en caso que no se haya definido la variable
en la URL por consiguiente en la función anónima su valor será el definido como
predeterminado (en este ejemplo null).
Cabe señalar que aunque se puede incrustar código php dentro de las rutas, las buenas
practicas dictan que tengamos separado el código php de las rutas. El código php viene
siendo la lógica que necesitamos por lo que se debe enviar a un archivo controlador. En
este archivo controlador es donde vamos a escribir toda la lógica de nuestra aplicación.
04.- CONTROLADORES EN LARAVEL QUE SON Y PARA

QUE SIRVEN.
Los controladores están en la ruta app/Http/Controllers del proyecto. Su función es la
siguiente:
1. El controlador recibe la petición o solicitud que hace el usuario, este se lo pasa al
modelo.
2. El modelo Realiza los cálculos y la información obtenida se lo regresa al
controlador.
3. El controlador le pasa estos resultados a la vista y
4. la vista ya en una página web HTML le muestra estos resultados el usuario final.
Crear el controlador
Este se crea desde la línea de comando
1. Verificar que estemos dentro de la carpeta del proyecto (por ejemplo c:\xampp\
htdocs\proyectocurso).
2. Escribimos el comando:
a. PHP artisan make:controller HomeController Home controller es
el nombre que queremos darle al controlador. Se recomienda poner un
nombre que identifique para que será el controlador.
b. La convención dicta que tiene que ser singular y posteriormente la palabra
Controller.
c. Puede escribirse en mayúsculas la primera letra de cada palabra sin
espacios.
Este comando me va a crear un archivo HomeController.php. Este archivo tiene código
php, dentro del archivo define un namespace que es donde se define la ruta de donde
están ubicados los controladores
namespace App/Http/Controllers;
También crea una clase con el nombre que le pusimos en este caso HomeController el cual
extiende las propiedades de la clase Controller.
Es dentro de esta clase donde se van a escribir los métodos que se encargarán de
administrar lo que definimos en web.php.
Es importante resaltar que: en “web.php” definimos la ruta y en el controlador definimos

que acción realizará esa ruta en específico, en este caso la ruta “Home”.
Asignar el control de una ruta a un controlador

En Laravel 8 la forma de asignar un controlador a una ruta es diferente con respecto a sus
versiones anteriores.
Los pasos son:
1. Crear el controlador a través en línea de comando a través de la instrucción “php
artisan make:controller NombreController”
2. En el nuevo controlador definimos los métodos (dentro de la clase) que harán
referencia a las rutas definidas en web.php
3. En el archivo web.php se realizan 2 tareas:
a. Definir que vamos a usar el controlador a través del comando “use”
ejemplo, “use App\Http\Controllers\HomeController;
b. Definir la ruta y el controlador del comando “Route” usando la siguiente
sintaxis:
Route::get(‘ruta’, [nombrecontrolador::class, ‘nombreMetodo’];
Llamar controladores versión 8 Laravel

Definiendo controlador para la ruta raíz (página principal del proyecto)
Cuando la ruta es la raíz del proyecto no hace falta definir el nombre del método a usar en
el comando Route. La sintaxis seria:
Route::get(‘ruta’, [nombrecontrolador::class);
Con ello de manera predeterminada Laravel en la clase del controlador buscara el método
__invoke() por lo que es importante resaltar que hay que definir un método __invoke()
cuando se omite el nombre del método en el comando “Route”.
Dentro del archivo web.php hay que especificar que vamos a usar ese controlador a través
del comando “use”
use App\Http\Controllers\HomeController;
Ya definido el “use” podemos hacer uso del controlador de la siguiente manera:
Route::get(‘/’, HomeController::class);
Ahora dentro del controlador (archivo “HomeController.php”) definimos el método que va

a realizar la tarea al ingresar a esa ruta. Nota: estos métodos estarán definidos dentro de
la clase:
class HomeController extends Controller

{
public function __invoke()
{
return “Bienvenido a la página Home, página principal”;
}
}
Nota la función (doble guion bajo invoke “__invoke()”) es utilizada por default para definir
que es la raíz de la ruta (es cuando omitimos el nombre del método en el comando
“Route”.
Definiendo controlador para rutas diferentes a la raíz del proyecto
Por ejemplo, si tenemos el siguiente código (archivo “web.php”):
Route::get('cursos', function(){
return "Bienvenido a la página Catálogo de cursos";
});
Route::get('cursos/create', function () {
return "Página de Formulario";
});
Route::get('cursos/{id}', function ($id) {

});
Podemos observar que tenemos la ruta “cursos” que se repite en los 3 Route. Por lo tanto,
puedo crear un solo controlador llamado CursoController y dentro de la definición de la
clase puedo ingresar las 3 funciones que será el llamado para cada uno de la clase
“Route”.
1. ‘curso’
2. ‘curso/create’
3. ‘curso/{id}’  este es una ruta (“curso”) que recibe una variable, lo que sea
después de curso de guardará en “id”.
El siguiente paso es crear el controlador:
1. Desde la línea de comando (ctrl + ñ en visual code) Escribimos el comando:
a. PHP artisan make:controller CursoController Curso controller es el
nombre que queremos darle al controlador. Se recomienda poner un
nombre que identifique para que será el controlador.
b. La convención dicta que tiene que ser singular y posteriormente la
palabra Controller.
c. Puede escribirse en mayúsculas la primera letra de cada palabra sin
espacios.
2. En el nuevo controlador creado (CursoController.php) dentro de la clase vamos a
crear 3 métodos (“index”, “create”, “show”) que será la conexión con la ruta de
Cursos.
3. class CursoController extends Controller
4. {
5. public function index(){
6. return "Bienvenido a la página Catálogo de cursos desde el
controlador";
7. }
8.
9. public function create(){
10. return "Página de Formulario desde el controlador";
11. }
12.
13. public function show($id){
14. return "Página curso de: $id desde el controlador";
15. }
16.}
17.
El método “index” será para la raíz del curso “/”, el método “créate” será para la
ruta “cursos/create” y el método show será para la ruta “cursos/$variable”.
Cabe señalar que por convección el nombre “index” es para la ruta raíz, “create” se
usa para definir formularios y “show” para mostrar algo.
18. En el archivo “web.php” definimos el uso de ese controlador con el código:

use App\Http\Controllers\CursoController;
19. Luego en este mismo archivo “web.php” se define la clase “Route” con la siguiente
sintaxis:
“Route::get(‘ruta’, [nombrecontrolador::class, ‘nombreMetodo’]);”.
El código sería:
Route::get('cursos', [CursoController::class, 'index']);
Route::get('cursos/create', [CursoController::class, 'create']);
Route::get('cursos/{id}', [CursoController::class, 'show']);

En la última línea de código indica que la URL ‘cursos’ esta siendo administrado por el
método ‘show’ del controlador ‘CursoController’.
Nota: hay que resaltar que “show” no pasa la variable “id”, no es necesario pasar la
variable al nombrar el método a usar (“show”) ya que aquí solo se indica el nombre del
método a usar, pero tanto en la definición del método (archivo “CursoController.php”)
como en la definición de la ruta (archivo web.php -comando Route) ahí se define que hay
una variable en la ruta y esta una función esperando el valor en la definición del método.
Route::get('cursos/{id}', [CursoController::class, 'show']); // archivo
web.php
public function show($id){} //archivo CursoController.php
Llamar controladores versión 7 Laravel

En la versión 7 el código del comando Route se definía de la siguiente manera: (archivo
web.php)
Route::get('\', "HomeController"); //se ponía entre comillas el nombre del
controlador
En la versión 8 se define de la siguiente manera:
Route::get('/', HomeController::class );
Para definir una ruta diferente a raíz en la versión 7 es de la siguiente manera:

Route::get('cursos', "CursoController@index"); //se usaba la arroba para
unir el controlador y el nombre del método
En la versión 8 se define de la siguiente manera:
La principal razón del cambio en la versión 8 es que, si posiciono el puntero del ratón y
presiono la tecla control, al dar clic este me llevará a la definición de esa clase y en la
versión 7 esto no se puede.
Otro cambio en la versión 7 es:
En el archivo RouteServiceProvider.php (app/Providers/RouteServiceProvider.php)
Anteriormente en este archivo tenia una propiedad llamada namespace el cual definía la
ruta de todos los controladores (esto dentro de la clase RouteServiceProvider)
protected $namespace = 'App\Http\Controllers';
En el mismo archivo en la siguiente función se agrega el siguiente código:

->namespace($this->namespace)
quedando la función como sigue:
public function boot()
{
$this->configureRateLimiting();
$this->routes(function () {
Route::prefix('api')
->middleware('api')
->group(base_path('routes/api.php'));
Route::middleware('web')
->group(base_path('routes/web.php'));
});
}
En la versión 8 de Laravel esta propiedad namespace ya no viene definida dentro del

archivo RouteServiceProvider.php. por lo que cada vez que creemos un nuevo controlador
en el archivo web.php hay que definir su uso (comando use) para poder utilizarse.
05.- GRUPO DE RUTAS DE CONTROLADORES.

A partir de la versión 9 de Laravel se puede agrupar un grupo de rutas (archivo web.php) si
estas utilizaran el mismo controlador.
Por ejemplo, del siguiente código
Route::get('/', HomeController::class );
Route::get('cursos/create', [CursoController::class, 'create']);
Route::get('cursos/{id}', [CursoController::class, 'show']);
Existen 3 rutas que utilizan la misma clase “CursoController::class” y estas se pueden

agrupar para definir una sola vez el controlador.
El código sería:
Route::controller(CursoController::class)->group(function(){
Route::get('cursos', 'index');
Route::get('cursos/create', 'create');
Route::get('cursos/{id}', 'show');
});
En este código se define la clase Route el cual hace referencia al método controller.
Dentro del método controller() se va a definir el controlador a usar (sin comillas).
El operador -> hace referencia al método group del objeto Route. Dentro del método
group() se define una función anónima el cual va a contener (se agruparán) todas las rutas
que utilizarán este controlador
06.- VISTAS EN LARAVEL.

Las vistas se encuentran en la carpeta App/resource/vistas
Creación de vistas
Se crean las páginas web o archivos “php” que serán las vistas (este se crea directamente
en la carpeta del proyecto). Por ejemplo, para la página web principal del proyecto se
crear el archivo home.php y se inicializa con la estructura de un código HTML. En caso de
que la clase “Route” (archivo “web.php”) comparta una misma ruta (por ejemplo “cursos”
se puede crear la carpeta cursos y dentro de esta carpeta se crearían las pagina web por
cada una de las rutas)
“Home.php” está en raíz de la carpeta “view”. “Index.php”, “créate.php” y “show.php”

están dentro de la carpeta cursos.
Método View pasando parámetro ruta raíz

Para llamar a la vista, en el controlador en vez de retornar una cadena llamamos al
método “view”, le pasamos como parámetro la ruta del archivo web que creamos
(“home.php”) sin la extensión y entre comillas
return view('home');
NOTA: al pasarlo como parámetro dentro del método “view()” no se necesita poner la
extensión del archivo (se omite “.php”).
Método view pasando parámetro ruta diferente a raíz

El método View lo que hace por default, es dirigirse a la raíz de la carpeta view por lo que
si la página web (“archivo.php”) que estamos buscando están dentro de otra carpeta, se
pone punto para indicar la carpeta y el archivo. Por ejemplo, en la siguiente ruta
“view/cursos/create.php”
Se pasaría como parámetro
return view('cursos.create');
Método View pasando parámetro ruta con variable

En caso de que la clase Route (del archivo “web.php”) necesite pasar una variable
(‘cursos/{id}’), el código sería:
Route::get('cursos/{id}', 'show');
En el archivo controlador que recibe la variable del “web.php”. la variable tiene que
recibirse como parámetro en 2 métodos.
El método “show()” recibe la variable como parámetro y el método “view()”. En el método
“view()” esta variable se pasará como segundo parámetro (en el primer parámetro se pasa
la ruta del archivo).
public function show($id){

return view ('cursos.show', ['id'=>$id]);
}
Cabe señalar que el segundo parámetro que se pasa al método view pasará dentro de
corchetes. El método View tendrá la siguiente sintaxis
“view(‘ruta’, [‘nombreCualquiera’ => $parámetro]);”
en el ejemplo, la variable $parámetro es el parámetro que recibe el método “show()”.

NOTA: ‘NombreCualquiera’ es el nombre de la variable que se usará para poner en el
código HTML como variable php
<h1>Página curso de: <?php echo $ NombreCualquiera; ?>desde el view</h1>
Abreviatura para pasar una variable como parámetro al método View compact()
En el archivo controlador que necesita recibir una variable; en el segundo parámetro,
cuando se utiliza la misma etiqueta tanto en la variable que se le pasara al HTML como la
variable que recibe la información, por ejemplo:
view(‘ruta’, [‘nombreCualquiera’ => $ nombreCualquiera]);
La sintaxis de arriba se puede abreviar usando el método compact(‘NombreCurso’), este

internamente lo traduce en [‘NombreCurso => $NombreCurso]
NOTA: El parámetro que recibe el método “compact()” no lleva signo de pesos, como se
muestra a continuación.
compact('NombreCurso'); //este se traduce en ['NombreCurso'=>$NombreCurso]
por lo que el método View se puede simplificar como se muestra a continuación
//Código sin Simplificar

return view ('cursos.show', ['id'=>$id]);
//Código Simplificado
return view ('cursos.show', compact('id'));
Uso de plantillas en Vistas (Blade)
En HTML si tenemos la misma estructura podemos definir una plantilla.

1. Creamos la carpeta “layouts” dentro de la carpeta vistas del proyecto.
2. Dentro de la carpeta creamos el archivo “plantilla.blade.php” (es importante que
tenga la extensión “.blade”). Este archivo tendrá la estructura HTML básica (por
ejemplo, los tag “<title>”, “<head>”, “<body>”, “<footer>” que es el código HTML
que se repite en otras páginas), es decir será la plantilla base que usaran las otras
vistas.
3. En la plantilla base definimos las partes que queremos que sean contenido
dinámico de acuerdo con la vista utilizada. Estas áreas dinámicas se definen con la
sintaxis @yield(‘nombre’) como se muestra el siguiente código HTML. En este
ejemplo el tag título y contenido son dinámicos, ejemplo de código:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title> @yield('tittle') </title>
</head>
<body>
@yield('content');
</body>
</html>
4. Ya en los archivos vista que usaran la plantilla base (por ejemplo “home.php”), en
vez de usar le código HTML completo solo haremos referencia a las áreas
dinámicas de la plantilla base. Para ello es necesario:
a. Se renombra el archivo vista “home.php” anexándole la extensión “.blade”
quedando de la siguiente manera “home.blade.php”
b. Todas las instrucciones no terminan en punto y coma
c. La primera línea de código es ingresar una extensión con la ruta donde
está ubicada la plantilla @extends(‘rutaPlantilla’). En nuestro ejemplo la
plantilla base “plantilla.blade.php” esta dentro de la carpeta “layouts”.
@extends('layouts.plantilla')
d. Se usa “section” para definir el contenido de un @yield() de la plantilla

principal. “@section(‘identificadorYieldUsandoEnPlantilla’,’contenido a
mostrar’)”
@section('title', 'Pagina create')
e. Si la “section” necesita más de aun línea de código HTML se usa

@section() //código html… @endsection
@section('content') //punto e
<h1>Bienvenido a la página principal (index) desde el view con
plantilla</h1>
@endsection
El código completo de un archivo view (por ejemplo, “create.blade.php”) que no esta

definida como plantilla base
@extends('layouts.plantilla') //se define la ruta
@section('title', 'Pagina create') //section con una sola línea de código
@section('content') //Inicia section con varias líneas de código HTML

<h1>Página de Formulario desde el view usando blade</h1>
@endsection //Finaliza section
Usando blade para sustituir echo php dentro de HTML por {{}}
En vez de imprimir un echo dentro del código HTML podemos simplificar esta instrucción
con dobles lleves como se muestra a continuación
//Incrusta echo $id dentro de código HTML

<h1>Página curso de: <?php echo $id; ?>desde el view usando blade</h1>
//Incrusta echo $id dentro de código HTML para eliminar código php en HTML
<h1>Página curso de: {{$id}} desde el view usando blade</h1>
07.- Introducción al manejo de base de datos con Laravel
Hay que configurar que tipo de base de datos vamos a usar (por ejemplo, SQL server o
MYSQL) y también tenemos que configurar sus parámetros como credenciales de acceso,
puestos, host, etc.).
Esta configuración se podría definir en el archivo “database.php” ubicado en la ruta

“config/database.php”, Como este archivo se subiría tanto en el repositorio como en el
host por seguridad se en el archivo “.env” (ubicado en la raíz del proyecto) es donde se
guardará todas las configuraciones del proyecto incluyendo la de la base de datos.
En le archivo “database.php” encontraremos el siguiente código
'default' => env('DB_CONNECTION', 'mysql'),
Esta instrucción quiere decir que a ‘default’ se le asigna un valor, ya sea del primer
parámetro que tiene el método env(‘parametros1’,’parametro2’) y en caso de no
encontrarlo se le asigna el valor del segundo parámetro. El cual tiene el valor explicito
‘mysql’.
El primer parámetro son las variables definidas dentro del archivo “.env”. En este ejemplo
‘DB_CONNECTION’.
NOTA: El archivo “.env” se preconfigura con los datos del proyecto, como por ejemplo el
nombre de la base de datos, sin embargo en caso de usar un nombre de base de datos
diferente hay que tener en cuenta que se debe configurar.
Estas con las variables que vienen en el archivo “.env” y su configuración par aun proyecto
Laravel llamado “salón”
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=salon
DB_USERNAME=root
DB_PASSWORD=
08.-Introducción a las migraciones

¿Que son las migraciones?
En la Laravel la creación de tablas, actualizaciones y de contenido se hacen a través de
código (sin usar script de SQL). Es decir, se utilizan como si fueran objetos de tipo (como
una clase por ejemplo - el cual es un tipo objeto -)
Estos archivos permiten llevar un control de versiones ya a través de sus métodos pueden
crear o realizar la instrucción (método up) o pueden deshacer esta tarea (método down).
Estos archivos se guardan dentro de las carpetas “datablase/migrations”.
Estructura de un archivo
Un archivo create_users_tabla.php tiene una clase CreateUsersTable que se extiende de la
clase Migration.
Esta clase tiene 2 metodos: le método up() y le método down().
Crear una tabla (método “create()”)

Es dentro del método “up()” donde se realizan las actividades, por ejemplo crear una
tabla.
Crear tabla y columnas

Para crear una tabla se usa el método “create” de la clase Schema y para crear las
columnas se usa la variable $table del objeto BLuePrint, con la siguiente sintaxis:
create(‘nombreTabla’, ‘function(BluePrint $table){… }
el objeto $table se utiliza para crear cada una de las columnas de nuestra tabla
public function up()

{
Schema::create('users', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('email')->unique();
$table->timestamp('email_verified_at')->nullable();
$table->string('password');
$table->rememberToken();
$table->timestamps();
});
}
 En el ejemplo anterior $table->id() crea una columna de nombre “id” de tipo

unsigned, autoincrementable de tipo integer.
 El código $table->string(´nombreColumna); crea una columna de nombreColumna
de tipo “varchar” de 255 caracteres. Sin embargo, si pasamos un segundo
parámetro a este método:
$table->string(‘nombreColumna’, 100);
lo que hace es que en vez de pasarle una propiedad de 255 caracteres como
longitud máxima. Crearía la columna de tipo varchar, de nombre
“nombreColumna” pero con una longitud máxima de 100 caracteres (esto con
propósitos de memoria).
 Si necesitamos que la columna almacene mas de 255 caracteres podemos usar el
método :
Stable->text(‘name);
 La propiedad unique() hace que en esa columna en espeficico no se repitan un
registro (que no tenga registros duplicados) este se utiliza por ejemplo para
almacenar correos electrónicos. Se utiliza de la siguiente manera:
$table->string(‘email’)->unique();
 La propiedad nullable() permite almacenar datos nulos (vacíos) en esa columna, en

caso que ese campo no siempre requiera guardar información como por ejemplo
datos opcionales, es importante poner esta propiedad para evitar error a la hora
de almacenar información. Se utiliza de la siguiente manera:
$table->string(‘email2’)->nullable();
Método timestamps() este método crea 2 columnas “created_at” y “update_at” el

cual almacenara las fechas de creación y guarda la fecha cada que haya un update.
A diferencia del método timestamp() que guarda únicamente fechas.
Revertir una tarea (método down).

El Método “down() es el encargado de revertir la tarea realizada por el método up
de ese mismo archivo migrate.
NOTA: Importante no usar nombre con tildes o caracteres especiales, únicamente

alfanuméricos. En la documentación oficial de Laravel aparatado
database/migration podemos encontrar más información sobre la creación de
columnas y los métodos utilizados. Por ejemplo, useCurrent() que sirve para
establecer la fecha actual (timestamp) actual como default.
Eliminar una tabla (método “dropIfExists()”)

El método dropIfExists se define dentro del método down.
“dropIfExists(‘nombreTabla?);
Este método eliminara la tabla creada por el método “créate”. Nota eliminará la tabla
creada por el método create que este dentro de su mismo archivo migrate.
public function down()

{
Schema::dropIfExists('users');
}
Eliminar todas las tables de la base de datos y volverlas a crear en línea de comando.
Si necesitamos eliminar todas las tablas que tenemos en el sistema y volverlas a crear.
Tenemos 2 instrucciones que podemos usar:
1. php artisan migrate:fresh // este no utiliza el método “down()” para eliminar las
tablas
2. php artisan migrate:refresh //este utiliza el método “down()” para eliminar las
tablas
La instrucción 1 lo que hace es eliminar todas las tablas (sin leer el método “down()”) y
luego ejecuta el método “up()” de cada una de los archivos migrate. En otras palabras,
elimina las tablas sin usar el método down() por lo que de un solo “golpe” elimina todas
las tablas de esa base de datos para después ejecutar uno a uno el método up() de los
archivos migrate que estén en la carpeta “database/migrate”. Esta instrucción garantiza
que se eliminaran las tablas ya que al no usar el método down elimina la posibilidad que el
método este mal escrito y por ende no pueda borrarse la tabla.
La instrucción 2 lo que hace es recorrer la tabla migrations de la base de datos y todas las
migraciones que estén registradas en esta tabla ejecuta su método “dropifExits()” sin
importar su número de lote (elimina cada una de las tablas), a continuación ejecuta el
método “up()” (crea cada una de las tablas). En otras palabras elimina las tablas usando el
método “down()” de todas las migraciones registradas en la tabla “migrations” primero
ejecuta el método “down()” y posteriormente ejecuta el método “up()”.
Con esta instrucción todos los registros de la tabla “migrate” tendrán lote 1 ya que lo que
hace es vaciar la tabla y posteriormente ejecuta el método “up()” con todas las
migraciones que encuentra en la carpeta “database/migrations”, ejecutándolas todas
como un mismo lote, en este caso lote 1.
Nota: Esta instrucción se considera destructiva ya que al eliminar la tabla se elimina

igualmente toda la información (registros) que contiene.
Eliminar todas las tablas (sin volver a crearlas)

Para eliminar todas las tablas que las migraciones han creado en la base de datos y no
volverlas a crear se utiliza la instrucción en línea de comados:
php artisan migrate:reset + enter
Este método lo que hace es un rollingback (ejecutar el método “down()”) de todas las
migraciones pero no realiza el método “up()” de estas migraciones. Con ello en la base de
datos solo dejaría la tabla de migraciones.
Ejecutar una migración (ejecución del método “up()”)
Para ejecutar una migración se va a línea de comandos (por ejemplo, de visual Code
presionando control + ñ) y escribimos el siguiente comando
php artisan migrate + enter
Nota: si hace una modificación (por ejemplo, agregar más columnas, cambiar nombre,
etc.) es importante primero guardar el archivo antes de ejecutar la instrucción, de lo
contrario únicamente ejecutara lo que se haya guardado en el archivo.
Este comando recorrerá y ejecutara únicamente el método “up()” de cada uno de los
archivos migrate (de ese mismo lote) que tengamos dentro de la carpeta
/database/migrate.
Revertir migraciones (ejecución del método “down()”)

Para revertir una migración, esta se hace desde la línea de comando con la siguiente
instrucción
php artisan migrate:rollback + enter
Este comando recorrerá y ejecutara únicamente el método “down()” de cada uno de los
archivos migrate (de ese mismo lote) que tengamos dentro de la carpeta
/database/migrate.
Lotes de migración.
Los lotes se manejan para el control de versiones, todos aquellos registros (archivos
migrate) que compartan el mismo bloque son los que se ejecutaran simultáneamente, ya
sea el consecutivo para registrar la ejecución de una migración o el consecutivo anterior
para deshacer la tarea realizada.
¿Que es un lote?
Dentro de las tablas que se crean por default en la base de datos esta la tabla “migrate”
(esto en base de datos). Esta tabla lleva un control de los archivos migrate que ya se
ejecutaron poniéndoles una bandera de valor 1 (esto por ser la primera ejecución – primer
lote- de la instrucción php artisan migrate + enter) y con ello ya tiene un control sobre los
archivos que se ejecutaron, de esta manera se manejan Lotes.
Cada migración se maneja en bloque (lote)s, es decir cada que ejecutamos la instrucción
“php artisan migrate + enter” busca todos los nuevos archivos existentes en la carpeta
“/database/migrate” y los ejecuta como un segundo lote, poniéndole un numero 2 a la
segunda ejecución y si se vuelve a ejecutar la instrucción buscaría nuevos archivos de
migración y ejecutaría todos los nuevos archivos que encuentre y a estos archivos les
pondría lote 3 y así sucesivamente.
Esto sirve para el control de versiones ya que cada que queramos revertir una actividad,
esta se revertiría por aquellas migraciones que tengan el mismo número de lote es decir
primero se revierte todas las migraciones que tengan el lote 3, luego todos los que tengan
lote 2 y posteriormente los que tengan lote 1.
Nota. Si revierto una actividad por ejemplo el lote 3 y posteriormente vuelvo a revertir la
actividad del lote 2, dejando solamente las migraciones del lote 1. Al volver a realizar la
actividad (ejecutar la migración) este nuevo lote tendrá el numero 2 pero contendrá los
archivos del lote 3 y 2 revertidos anteriormente. Esto porque las migraciones que se
revirtieron quedaron “listas” para volver a ejecutarse y recuerda que la ejecución de la
migración se hace por todos los archivos que estén listos para migrarse.
09.- Como crear migraciones en Laravel

Para crear los archivos migrate se hace a través de la línea de comando (control + ñ en
visual code) esta línea de comandos se puede escribir de 2 maneras.
1. php artisan make:migration nombrearchivo + enter

2. php artisan make:migration create_nombrearchivo_table + enter
El punto 1 nos crea el archivo de migración únicamente con los métodos up y down
vacíos.
class Ejemplo extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
{
//
}
/**
* Reverse the migrations.
*
* @return void
*/
{
//
}
}
Mientras que el punto 2 nos crea los métodos up y down y dentro sus respectivos
métodos (método “créate()” para el método “up()” y “dropIfExists()” para el método
“down()”). En otras palabras, respetando la convención nos ahorra líneas de código. Esto
es posible ya que en el nombre le estamos pasando create y por ende identifica que
queremos crear una tabla.
class CreateEjemplo2Table extends Migration

{
/**
*
* @return void
*/
{
Schema::create('ejemplo2', function (Blueprint $table) {
$table->id();
});
}
/**
*
* @return void
*/
{
Schema::dropIfExists('ejemplo2');
}
}
10.- Como modificar tablas con migraciones.

Este método es para modificar tablas que ya cuentan con contenido (datos en sus
columnas), se puede anexar o eliminar columnas o en su defecto cambiar las propiedades
de la columna. Por ejemplo, pasar de 255 caracteres en un varchar a 100 caracteres
máximo.
Por cada modificación se recomienda crear un archivo migrate a fin de tener un mejor
control. La convención dicta que debe ser lo más descriptivo posibles (en este ejemplo,
agregar una nueva columna) to_nombreColumna_table es la parte importante
php artisan make:migration add_nombreColumna_to_nombretabla_table + enter
en el ejemplo usaremos:
php artisan make:migration add_ColumnaTipo_to_cursos_table + enter
Esto creara una migración (archivo addcolumnatipotocursostable.php) con cierta cantidad

de código ya escrito, en este caso usando el método “table()” (de la clase Schema) en vez
del método “create()”.
class AddColumnaTipoToCursosTable extends Migration

{
/**
*
* @return void
*/
{
Schema::table('cursos', function (Blueprint $table) {
//
});
}
/**
*
* @return void
*/
{
//
});
}
}
Agregar una nueva columna

Aquí hay que tener en cuanta que dentro del método “up()” se anexara el código que
creará la columna (nombre, propiedades, etc.).
Importante, si esta tabla ya tiene valores o registros es importante que se cree la columna
permitiendo valores nulos de lo contrario podría generar error al ingresar los registros

{
$table->string('tipo')->nullable()->after('descripcion')
});
}
En la instrucción:
$table->string('tipo')->nullable()->after('descripcion')
 El método “nullable()” permite que la columna acepte valores nulos. Con
parámetro false se establece que no permite valores nulos.
 El método “after(‘nombreColumna)” permite agregar la columna después de la
columna que manifestamos dentro del método after.
 ->default($value) permite ingresar un valor predeterminado cada que se
agregue un registro.
Dentro del método “down()” hay que meter el código que revierta este proceso.
El método utilizado para eliminar columnas es “dropcolumns(‘nombrecolumna’)”
{
$table->dropColumn('tipo');
});
}
Modificar las propiedades de una columna
Según la documentación de laravel antes de modificar una columna, se debe instalar el
paquete “doctrine/dbal”. La doctrina DBAL library es usada para determinar el estado
actual de la columna y a crear los queries SQL necesarios para realizar los cambios
solicitados en las columnas. Esta instalación es por cada proyecto Laravel.
La instalación se hace en línea de comando (en visual code presionando control + ñ) a

través de la instrucción
composer require doctrine/dbal
Se crea un nuevo archivo migrate únicamente para modificar la propiedad de la columna.

Escribimos la instrucción en línea de comando (visual code presionamos control + ñ)
php artisan make:migration cambiar_propiedades_to_nombretabla_table + enter
en el ejemplo sería:
php artisan make:migration cambiar_propiedades_to_cursos_table + enter
esto creara un archivo con la siguiente estructura

class CambiarPropiedadesToCursosTable extends Migration
{
/**
*
* @return void
*/
{
//
});
}
/**
*
* @return void
*/
{
//
});
}
}
Change() es el método dentro del método “up()” que realice los cambios de propiedad de
la columna. En este caso se configura la columna para aceptar como máximo de 50
caracteres y acepte registros nulos.
$table->string('nombre',50)->nullable()->change();
});
Para el método “down()” realizamos el proceso inverso regresando a 255 el máximo de

caracteres y no soportar caracteres nulos.
$table->string('nombre',255)->change();
});
Renombrar una columna.

1. Necesitamos crear un nuevo archivo “migrate” para que este renombre la
columna:
php artisan make:migration rename_Apellido_column_to_tablaNombre_table
2. Dentro del método “Up()”, en el método “table()” ponemos el código:

$table->renameColumn('nombre1', 'nombre');

{
Schema::table('maestros', function (Blueprint $table) {
$table->renameColumn('nombre1', 'nombre');
});
}
3. Ponemos el inverso en el método down()”, en el método “table()”

$table->renameColumn('nombre', 'nombre1');

{
Schema::table('maestros', function (Blueprint $table) {
$table->renameColumn('nombre', 'nombre1');
});
}
4. Guardamos y ejecutamos el archivo migrate en línea de comando

“php artisan migrate”
11.- Inserción de registros en la base de datos (introducción a

eloquent)
En Laravel se manejan a los registros de las tablas de base de datos como objetos (esto es
a través de ORM de eloquent incluido con Laravel) y a cada columna de una tabla de base
de datos se manejan como una propiedad de ese objeto. Por lo tanto, asignando o
modificando el valor de esa propiedad es que vamos a poder aguarda un registro en la
tabla o en su defecto modificar el valor de un campo en la tabla.
Cada tabla tiene que tener su propio archivo modelo.
Creación de modelos
La ruta donde se almacenan los archivos modelos es “app/models”.
La lógica para la inserción de registro o modificación de registros en una tabla de base de
datos se realiza dentro de los modelos (modelo, vista, controlador) por lo que tenemos
que crear un modelo para cada tabla.
Para crear un modelo se puede crear a través de 2 maneras.

1. A través de una convención. Esta convención se basa en utilizar plural y singular
(en idioma inglés).
a. La tabla tiene que estar etiquetada en plural (por ejemplo, “users”)
b. La creación del archivo modelo tiene que hacerse en singular (por ejemplo,
“user”).
c. Al utilizar esta convención no se necesita especificar el nombre de la tabla
dentro del archivo modelo.
Es decir que si yo creo un modelo llamado “category” (singular), El ORM de
eloquent (laravel) va a saber que tiene que administrar una tabla llamada
“categories” (plural).
2. Indicando directamente la tabla con la que trabajara ese modelo. Para indicar
explícitamente la tabla a utilizar se debe definir la propiedad
protected $table = ‘nombreTabla’;
class curso extends Model

{
use HasFactory;
protected $table = 'users';
}
Con el código anterior lo que hará este archivo modelo es ignorar la convención y
administrar a la tabla asignada. En otras palabras, de esta manera podemos asignar un
modelo a una tabla en específico sin utilizar la convención.
El código en línea de comando para crear el modelo es
php artisan make:model ‘nombre’
Si se usa la convención para crear el modelo, el nombre debería de ser el singular (en
inglés) del nombre que tiene la tabla en la base de datos. Por ejemplo, si la tabla en la
base de datos se llama categories se puede crear el modelo usando:
php artisan make:model ‘category’
Crear modelos y otro tipo de clases simultáneamente

Si desea ejecutar una migración (ejecutar “php artisan migrate”) en le momento que se
crea el modelo puede usar la opción –migration o -m. el código correspondiente sería:
php artisan make:model ‘category’ -m
puede crear diferentes tipos de clases (archivos) al momento de crear el modelo, como
pueden ser factory, seeder, migration, controllers, etc. Estas opciones pueden combinarse
para crear múltiples tipos de clases de manera simultanea
# Generate a model and a FlightFactory class...

php artisan make:model Flight --factory
php artisan make:model Flight -f

# Generate a model and a FlightSeeder class...
php artisan make:model Flight --seed
php artisan make:model Flight -s

# Generate a model and a FlightController class...
php artisan make:model Flight --controller
php artisan make:model Flight -c

# Generate a model, FlightController resource class, and form request classes...
php artisan make:model Flight --controller --resource --requests
php artisan make:model Flight -crR

# Generate a model and a FlightPolicy class...
php artisan make:model Flight --policy

# Generate a model and a migration, factory, seeder, and controller...
php artisan make:model Flight -mfsc

# Shortcut to generate a model, migration, factory, seeder, policy, controller, and
form requests...
php artisan make:model Flight --all

# Generate a pivot model...
php artisan make:model Member --pivot
Valores predeterminados (propiedades) al crear un modelo

Por default, al momento de crear una instancia de una clase de un modelo de forma
predeterminada esa instancia no contiene ningún valor (“$curso = new Curso()”), por lo
que deberá ir especificando el valor de cada una de las propiedades (“$curso->nombre =
‘Alvaro’;”). Si queremos que una propiedad (columna) en específico se inicialice con un
valor cada que instanciamos la clase de ese modelo debemos definir en el modelo una
propiedad “attributes”
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Alumno extends Model

{
use HasFactory;
protected $attributes =['nombre'=>"Alvaro"];
}
Tinker para insertar registros en línea de comandos forma1

Para hacer pruebas o en caso de aun no tener una página de formulario donde se hace
una inserción de datos en una tabla. Esta instrucción nos va a permitir insertar registros en
las tablas de la base de datos.
Para poder activar se escribe la siguiente instrucción en línea de comandos
php artisan tinker
Para salir de este modo escribimos la palabra exit en línea de comandos.
Inserción de registros en la tabla

Para este ejemplo vamos a crear un modelo llamado curso en la línea de comando con la
siguiente instrucción:
php artisan make:model ‘curso’
Este proceso se realiza dentro del Shell de tiker se realiza en 3 fases

1. Primero instanciamos la clase modelo
2. posteriormente vamos asignado a esta variable uno a uno todos los registros que
queremos guardar en la tabla en la base de datos.
3. Mandamos a guardar la información a la tabla en la base de datos. Si omitimos
este paso, aunque hayamos asignado todos los valores a la variable, este no se
almacenara en la tabla hasta que explícitamente no se lo hayamos indicado.
A continuación, se explica un poco más a detalle:

Los datos por insertar en la tabla de la base de datos se manejan como objetos. Primero
se debe crear la instancia de este objeto (de la clase modelo) y posteriormente crear las
inserciones).
1. En línea de comando escribimos php artisan tinker para ingresar al Shell de tinker.
2. Ya dentro del shell tinker se especifica que queremos hacer uso de ese modelo con
la instrucción.
use RutaCarpetaModelo\nombreModelo;
En este ejemplo sería:
use App\Models\curso; + enter
3. Crea una instancia de la clase y asignarla a una variable con el siguiente código
$curso = new curso;
4. Se asigna el dato que queremos guardar en la tabla especificando el nombre de la

columna y el valor a guardar como se muestra a continuación:
$curso->name=’Laravel’; + enter
5. Se asignan todos los demás valores que deseamos ingresar a la tabla de acuerdo
con su propiedad (columna en la tabla de la db) correspondiente. Por ejemplo
$curso->descripción=”framework de php” + enter. // “framework de php” se
guardará en la columna cursos de la tabla Cursos en la base de datos.
Revisar el contenido a guardar en la tabla de base de datos
Antes de mandar a guardar toda la información es recomendable revisar toda la
información que hemos asignado a la variable.
Para ello es suficiente con solo escribir el nombre de la variable:
$curso; + enter
Este nos mostrara todo el contenido que tiene almacenada esta variable (contenido que
nosotros fuimos asignando a la instancia de la clase)
Guardar la información en la tabla de la base de datos
Si todo esta correcto podemos guardar a guardar la información en la tabla de la base de
datos con la propiedad save(). Con la siguiente instrucción se manda a guardar la
información que contiene la variable de la instancia a la tabla de la base de datos.
$curso->save();
Esto lo que hará es que de manera automática se a completará la información de los otros
campos faltantes de la tabla como id, created_at, update_at). Por lo que si volvemos a
revisar el contenido de la variable $curso; este ahora trae toda la información que se
guardó en la tabla de la base de datos y posteriormente se le asigno esta la variable
$curso.
En el primer ejemplo podemos ver que la variable $curso; solo tiene asignado las
propiedades nombre, descripción y tipo.
Posteriormente guardamos la información en la tabla de la base de ($curso->save();).
Al revisar nuevamente la variable $curso; ahora podemos notar que tiene asignadas mas
propiedades como id, update_at y créate_at). Esto es por que la información ya se guardo
en la tabla de la base de datos y al mismo tiempo actualizo la información que se asignó
en la variable $curso
Actualizar un registro ya existente en la tabla de base de datos

Si al querer guardar la información de una variable $curso está ya cuenta con una
propiedad “id” asignado a un valor. Cuando se ejecute save() este no guardara un segundo
registro, lo que hará será actualizar los campos de la tabla de ese mismo registro. Por
ejemplo
En este ejemplo se ejecutó la propiedad save() (se guardó la información en la tabla de la
base de datos) y posteriormente se modificó el valor de la propiedad descripción para a
continuación volver a ejecutar la instrucción save() lo que dio como resultado que sol ose
actualizara la columna descripción de la tabla en ese mismo registro.
Tinker para insertar registros en línea de comandos forma2

Esto es para agregar registros en una tabla intermedia (de muchos a muchos)
Abrimos la terminal de línea de comando de visual studio (control + ñ) y escribimos
php artisan tinker + enter
decimos que modelo vamos a usar escribiendo

use App\Models\User;
recuperamos el usuario con id=1

$user = user::find(1);
Guardar un segundo registro o más en la tabla de la base de datos
Para poder guardar un segundo registro hay que instanciar una segunda variable de la
clase para que desde ahí se guarden todos los registros a almacenar en la tabla de la base
de datos.
Para instancion un segundo registro ya sea que salimos del modo tinker o en su defecto
escribimos una nueva variable
$curso2= new curso;
12.-Creacion de datos de “prueba” en las tablas

Cuando estamos desarrollando un sistema necesitamos poder tener datos de prueba en la
base de datos que nos permitan testear nuestro sistema con información (por ejemplo,
reportes).
Laravel a través de sus “factories” podemos ingresar datos de relleno (datos de prueba) en
las tablas de la base de datos.
Seeders
Estos datos creados por factory se van a ejecutar desde otra estructura conocida como
seeders
Este archivo se encuentra en la carpeta “database/seeders”. En este mismo archivo se

pueden meter todos que se quieren guardar en cada una de las tablas, pero se
recomienda que por cada tabla se tenga un propio archivo seed.
Codificar seed para que tenga la información a ingresar en la base de datos

Anteriormente se describió como ingresar datos desde línea de comandos con “Tinker”.
Con Seed debemos seguir la misma estructura:
1. Declara que vamos a usar el modelo usando use App\Models\curso;
2. Declara una instancia de la clase de ese modelo $curso = new curso();
3. Agregar los datos a guardar en la base de datos a cada una de las propiedades
$curso->nombre=’Laravel’;
4. Mandar a guardar la información en la base de datos $curso-save();
5. Para agregar un segundo registro se tienen que repetir los pasos del 1 al 4.
<?php
namespace Database\Seeders;
use App\Models\curso; //primero definir que se va a usar el modelo con “use”

use Illuminate\Database\Seeder;
class DatabaseSeeder extends Seeder

{
/**
* Seed the application's database.
*
* @return void
*/
public function run()
{
// \App\Models\User::factory(10)->create();
//se hace los mismo que se hacia con tinker

//segundo crear una instancia de la clase que tiene el modelo
$curso = new curso();
//luego se asignan los datos que queremos se guarde en la base de

datos
$curso->nombre='Laravel';
$curso->descripcion='Framework PHP';
$curso->Categoria='Programacion';
//se manda a guardar en la base de datos

$curso->save();
//para guardar un segundo registro en la bae de datos

$curso1 = new curso();
$curso1->nombre='Laravel';
$curso1->descripcion='Framework PHP';
$curso1->Categoria='Programacion';
$curso1->save();
}
}
Ejecutar Seed (guardar los registros en la db)

Para ejecutar Seed y mandar a escribir la información en la base de datos se usa la
siguiente instrucción.
php artisan db:seed
Nota: Hay que resaltar 2 puntos importantes

1. Este comando pordefault únicamente ejecutaría el archivo “DatabaseSeeder.php”
ubicado en la carpeta “database/seeders”.
2. Cada que ejecutemos este comando se ejecutara el archivo seed y por ende se
escribiría nuevamente los registros definidos. En otras palabras, el archivo seed
escribe información en la base de datos sin importar si ya fue ejecutada la
instrucción anteriormente (como sucede con las migraciones), escribiría en la base
de datos las veces que se llame la instrucción.
Otras maneras de ejecutar el comando Seed
Laravel nos permite simplificar la instrucción del comando seed en una misma instrucción,
permitiendo realizar 2 ejecuciones simultaneas (por ejemplo eliminar todas las tablas y
posteriormente ejecutar la instrucción seed)
php artisan migration:fresh --seed

Esta instrucción es útil para reconstruir desde cero su base de datos. Esta instrucción de
manera interna realiza los siguientes paso:
1. elimina todas las tablas (droptable sin usar rollback).
2. crear las tablas (“instrucción “php artisan migrate”)
3. inserta datos en la base de datos ejecutando la instrucción seed (php artisan
db:seed).
php artisan migrate --seed

Esta instrucción realiza los siguientes pasos:
1. crear las tablas (“instrucción “php artisan migrate”)
2. ejecuta la instrucción seed (php artisan db:seed).
Crear un archivo Seed para cada tabla de la base de datos.

Se recomienda tener un archivo Seed por cada tabla, por lo tanto, para crear un archivo
Seed este se hace desde la línea de comando con la siguiente instrucción.
php artisan make:seed ‘nombredescritivoSeeder’;
Esto nos creara el siguiente archivo dentro de la carpeta “database/seeders/”
<?php
class CursoSeeder extends Seeder

{
/**
* Run the database seeds.
*
* @return void
*/
{
//
}
}
En este archivo hay que definir qué modelo vamos a usar y posteriormente dentro del
método “run()”, definir una instancia de la clase para almacenar los datos que se enviaran
a la base de datos
<?php
use app\Models\curso; //definimos el modelo a usar

{
/**
*
* @return void
*/
{
//Instanciamos la clase del modelo y definimos el valor de las
propiedades
$curso1 = new curso();
$curso1->nombre='Laravel';
$curso1->descripcion='Framework PHP';
$curso1->Categoria='Programacion';
$curso1->save();
}
}
Invocar otros archivos Seed desde el archivo “DatabaseSeeder.php”

Hay 2 maneras:
1. directamente invocar el archivo seed desde la línea de comando la opción –class.
a. Esta opción -class nos permite especificar una clase (archivo) seed
específica para que se ejecute individualmente.
php artisan db:seed - - class=CursoSeeder

2. Invocar dentro del archivo “DatabaseSeeder.php” (carpeta database\seeders) que
vamos a llamar al archivo CursoSeeder.php. Esto se logra con la siguiente
instrucción dentro del método “run()”.
$this->call(CursoSeeder::class);
El código completo del archivo “DatabaseSeeder.php” sería:

<?php
use App\Models\curso;
class DatabaseSeeder extends Seeder

{
/**
* Seed the application's database.
*
* @return void
*/
{
// \App\Models\User::factory(10)->create();
$this->call(CursoSeeder::class); //aqui especificamos que archivo
seeder se va a llamar
}
}
Importante: al ejecutar el comando seed (php artisan db:seed”) solo ejecutaría los seeders
que fueron invocados (“$this->call(claseArchivoSeed::class)”)dentro del archivo
“DatabaseSeeders.php”.
13.- Ingresar varios registros de prueba a la base de datos sin usar

“seeders” (factory).
Los factorys son archivos ubicados en la carpeta /Database/factories/.
El “factory” al igual con Seeder son los encargados de llenar nuestra base de datos con
datos de ficticios, la diferencia entre Seeders y factories es la siguiente:
Con “seeders” tenemos que escribir el código necesario cada una de las columnas de una
tabla con el valor que deseábamos (explícitamente tenemos que asignar un valor por cada
columna). Con factory solo tenemos que definir por única ocasión que tipo de contenido
queremos guardar (nombre, dirección, email, teléfono, entre un rango de números, entre
2 opciones, etc.) y posteriormente según lo que hayamos definido factory creara datos
ficticios que se irán almacenando en la base de datos.
Con factory únicamente debemos definir:
 a que tabla se harán las inserciones de datos
 el tipo de contenido para cada columna, (por ejemplo, si es una oración, párrafo,
etc.).
 la cantidad de registros que deseamos ingresar.
Factory de manera automática rellenara cada uno de los campos con información
aleatoria según el tipo de contenido que hayamos seleccionado.
Para lo poder utilizar los factories es necesario:

 Crear y definir un archivo Factory
 En el archivo seeder principal “DatabaseSeeders.php” en vez de definir el archivo
seeder a utilizar (por ejemplo “CursosSeeders.php”) definimos cual es el archivo
factory a usar.
Crear un archivo Factory

Este archivo se crea desde la línea de comandos (en la carpeta “database\factories”) y se
puede crear de 2 maneras:
1. (Laravel versión 8 en adelante)
php artisan make:factory NombreModeloFactory + enter (por ejemplo, “php artisan
make:factory CursoFactory”)
o Esta instrucción es la versión empleada en la versión 8 o posterior de
Laravel ya que crea un archivo austero donde nosotros tenemos que definir
en el archivo creado que modelo voy a usar (agregando use y una
propiedad)
El archivo austero creado por factory quedaría de la siguiente manera:
<?php
namespace Database\Factories;
use Illuminate\Database\Eloquent\Factories\Factory;
class CursoFactory extends Factory

{
/**
* Define the model's default state.
*
* @return array
*/
public function definition()
{
return [
//
];
}
}
Importante: Debido a que los modelos van muy ligados a los factory o seeder (sin un
modelo en factory o Seeder no pudiera funcionar). Se recomienda que al momento de
crear un modelo se cree igualmente el factory (con el fin que ese modelo se enlace de una
vez con ese factory). Esto se logra en línea de comando con la siguiente instrucción (como
ejemplo crearemos el modelo “Curso”)
php artisan make:model Curso -f
2. (versión 7 de Laravel)
php artisan make:factory NombreModeloFactory - - model=NombreClaseModelo +
enter (ejemplo “php artisan make:factory CursoFactory - - model=Curso” + enter)
o En este código al momento de crear un archivo factory por default define
de una vez el modelo a utilizar y las líneas de Código necesarias para
enlazarlo al modelo)
o En la versión 7 o anterior de Laravel si no se usaba la opción –
modelo:NombreClaseModelo creaba un archivo genérico y posteriormente
habría que ingresar el código necesario para enlazar el factory con su
respectivo modelo.
El archivo austero creado por factory quedaría de la siguiente manera:
3. <?php
4.
5. namespace Database\Factories;
6.
7. use Illuminate\Database\Eloquent\Factories\Factory;
8.
9. class CursoFactory extends Factory
10.{
11. /**
12. * Define the model's default state.
13. *
14. * @return array
15. */
16. public function definition()
17. {
18. return [
19. //
20. ];
21. }
22.}
23.
El archivo ya definiendo el modelo a utilizar.
24.<?php
25.
26.namespace Database\Factories;
27.
28.use Illuminate\Database\Eloquent\Factories\Factory;
29.use app\Models\curso; //se agregó esta definición
30.
31.class CursoFactory extends Factory
32.{
33. /**
34. * Define the model's default state.
35. *
36. * @return array
37. */
38. protected $model = curso::class; //se agregó esta definición
39. public function definition()
40. {
41. return [
42. //
43. ];
44. }
45.}
Convención para la crear un archivo Factory

Se debe crear el archivo factory con el nombre de la clase del modelo + el sufijo “Factory”.
Por ejemplo, si el nombre de la clase Modelo se llama “curso” el nombre del factory
deberá de ser “CursoFactory”. Específicamente, el método buscara un factory en
“database/factories” que tenga el nombre de la clase que coincida con el nombre del
modelo y el sufijo Factory. Por ejemplo, si la clase del modelo se llama Curso, Laravel
buscara en la carpeta “database/factories” un archivo factory con nombre “CursoFactory”
En caso de no llevar a cabo la convención, se tiene que definir manualmente lo siguiente

1. En el archivo modelo, dentro de su clase hay que definir con que tabla estará
trabajando el modelo:
class People extends Model

{
use HasFactory;
protected $table = 'peoples';
}
2. En el archivo factory se tiene que definir el modelo con el que se trabajara. La

definición se hace dentro de la clase antes del método “definition()”
<?php
namespace Database\Factories;
use App\Models\People; //se tiene que agregar que vamos a usar este modelo
use Illuminate\Database\Eloquent\Factories\Factory;
class EjemploFactory extends Factory

{
/**
* Define the model's default state.
*
* @return array
*/
protected $model = People::class; //Especificado el modelo a usar ya se
puede usar y por tanto se define el modelo que vamos a trabajar
{
return [
'nombre'=> $this->faker->name()
//
];
}
}
3. Este paso es más delicado, En el archivo “HasFactory.php” hay que sobrescribir el

método newFactory() para regresar la instancia del archivo factory al que se quiere
trabajar. Nota: si se hace este paso, independientemente del modelo siempre se
hará referencia al factory que se definió. Por lo que si un modelo hace referencia a
otro factory, este no se tomara en cuenta y siempre se usara el factory definido
dentro del método newFactory();
4. /**
5. * Create a new factory instance for the model.
6. *
7. * @return \Illuminate\Database\Eloquent\Factories\Factory
8. */
9. protected static function newFactory()
10. {
11. return EjemploFactory::new();
12. //
13. }
Definición de tipo de contenido para la Base de datos en el archivo Factory

Dentro del método “definition()” en el método return se definen todos los tipos de
contenido que queremos especificar para el llenado de la Base de datos.
Nota: definir el tipo de contenido nos referimos, por ejemplo: nombre, dirección, un
teléfono, email, pero no el dato en especificó. Por ejemplo, se define nombre y no
“Gabriel”, se define que el tipo de dato será un teléfono, pero no 9831234567, se define
que el tipo de dato será un email, pero no ejemplo@admin.com y así sucesivamente.
Para generar los datos aleatorios Laravel hace uso de la librería “Faker” de PHP.
1. Se definen los campos que tiene la tabla y quedemos ingresar información. Nota: si
desea omitir un campo debe tener cuidado que ese campo en específico permita
valores nulos.
‘nombre’,
‘direccion’
2. La clase CursoFactory se extiende de una clase base llamada “Factory”, por lo
tanto:
a. Ponemos la palabra $this (para hacer uso de los métodos de la clase -en
este caso como la clase extiende los métodos de la clase base es igual a que
clase llame) y luego decimos que vamos a usar el método faker
‘nombre’=>$this->faker
3. Después del faker es donde va a variar el tipo de contenido según la columna
'nombre' =>$this->faker->name(),
El código completo con el método “definition()” seria:

{
return [
'nombre' =>$this->faker->name(),
'direccion' =>$this->faker->paragraph(),
'nivel' =>$this->faker-
>randomElement(['universidad','postgrado'])
//
];
}
Métodos (Tipo de contenido) para faker

Estos son algunos de los métodos que puedes utilizar para definir el tipo de contenido:
 sentence() – Genera una oración (con punto final) por default son 6 palabras.
Opcionalmente se puede proporcionar un segundo parámetro booleano. Cuando
es “false”, solo se generarán oraciones con la cantidad que se le definió. Por
defecto “sentence” podría desviarse de la cantidad definida en un +/-40%.
faker->sentence();
// 'Sit vitae voluptas sint non voluptates.'
faker->sentence(3);
// 'Laboriosam non voluptas.'
 paragraph() – Genera un párrafo de texto que contenga una determinada

cantidad de oraciones. De forma predeterminada se generan 3 oraciones.
Opcionalmente, se puede proporcionar un segundo parámetro
booleano. Cuando false, solo se generarán oraciones con la cantidad dada de
palabras. De forma predeterminada, las oraciones se desviarán de la longitud de
palabra predeterminada de 6 en +/- 40%.
echo faker->paragraph();
// 'Similique molestias exercitationem officia aut. Itaque doloribus et rerum voluptate

iure. Unde veniam magni dignissimos expedita eius.'
echo $faker->paragraph(2);
// 'Consequatur velit incidunt ipsam eius beatae. Est omnis autem illum iure.'
echo $faker->paragraph(2, false);
// 'Laborum unde mollitia distinctio nam nihil. Quo expedita et exercitationem voluptas
impedit.'
 randomElement() –regresa solo un elemento de una matriz dada. En otras

palabras, nos regresa un dato de un conjunto especifico de datos. Por ejemplo, si
queremos que solo seleccione hombre o mujer la matriz tendría que tener estos
elementos [hombre, mujer].
echo $faker->randomElement(['a', 'b', 'c', 'd', 'e']); // 'c'
 name() – regresa el nombre de una persona, si especificamos el primer parámetro

del método con la variable “$gender” se puede indicar que el nombre aleatorio
que ponga sea de hombre o mujer.
name($gender = null|'male'|'female') // 'Dr. Zane Stroman'
 safeEmail() – Regresa aleatoriamente un email seguro
echo $faker->safeEmail();
// 'spencer.ricardo@example.com', 'wolf.sabryna@example.org'
 unique().- Va en conjunto con otro método (como por ejemplo “safeEmail()”) y
este se encarga que siempre regrese un valor único (que no se repita), si pasamos
un valor true en su parámetro ($reset=true) entonces se pueden repetir los
valores.
// unique() forces providers to return unique values
$values = [];
for ($i = 0; $i < 10; $i++) {
// get a random digit, but always a new one, to avoid duplicates
$values []= $faker->unique()->randomDigit();
}
print_r($values); // [4, 1, 8, 5, 0, 2, 6, 9, 7, 3]
// providers with a limited range will throw an exception when no new

unique value can be generated
$values = [];
try {
for ($i = 0; $i < 10; $i++) {
$values []= $faker->unique()->randomDigitNotNull();
}
} catch (\OverflowException $e) {
echo "There are only 9 unique digits not null, Faker can't generate
10 of them!";
}
// you can reset the unique modifier for all providers by passing true
as first argument
$faker->unique($reset = true)->randomDigitNotNull(); // will not throw
OverflowException since unique() was reset
// tip: unique() keeps one array of values per provider
Esta es la página web se encuentran todos los métodos para faker y su explicación.
https://fakerphp.github.io/
Ejecutar el factory
Existen 2 formas de ejecutar un factory.
1. Esta puede ser desde un archivo seeder que no sea el principal
“DatabaseSeeder.php”. Esta es la manera como ejecutar un factory desde
cualquier archivo seeder.
a. Dentro del archivo seed que queremos utilizar, escribimos el siguiente
código dentro del método “run()”.
Debemos declarar use y la ruta de la clase a usar
NombreClaseModelo::factory(cantidad->create();
Por ejemplo:
use app\Models\curso;

{
/**
*
* @return void
*/
{
curso::factory(3)->create();
}
}
2. Este es la formar que Laravel recomienda para ejecutar el archivo Factory. Debido
a que el archivo principal de los seeder es el archivo “DatabaseSeeder.php”
podemos agrupar desde este archivo todas las llamadas de los factory a ejecutar y
con ello evitar la creación de archivos seeder por cada tabla y así evitar llenarnos
de archivos. Es desde este archivo dentro del método “run()” donde se escribe la
instrucción para ejecutar el factory.
use app\Models\curso;

{
/**
*
* @return void
*/
{
}
}
14 - Realizar consultas a la base de datos con “eloquent”

Como los datos de una base de datos se trabajan como si fueran objetos, para acceder a
ellos nos ayudamos de métodos. Así de acuerdo el método utilizado es el tipo de
información que se puede obtener, por citar unos ejemplos: el método equivalente al
script “select * from tabla” que regresa todos los registros de una tabla, el script que son
equivalentes al “where”, etc.
Para poder realizar pruebas podemos utilizar en línea de comandos “Tinker” (en secciones
anteriores se explica como instalarlo y su uso - capitulo 11 -).
1. Ingresar a “Tinker”, en línea de comando escribimos “php artisan tinker”
2. Indicamos que vamos a utilizar el modelo use App\Models\Curso; (de preferencia
respetar las mayúsculas como lo tenemos en el directorio del proyecto).
3. Se llama al modelo (en este ejemplo es “curso”) se pone el método equivalente al
script que queremos ejecutar y para poder utilizar la información debemos
almacenarla en una variable (en este ejemplo “$curso”) $curso = Curso::all();
Métodos eloquent y su equivalencia en script
Nota: Recuerde que estos métodos se puede combinar para poder hacer una consulta
mas “robusta”. Por ejemplo orderby()->all();
 all() – recupera toda la información que tiene la tabla y lo guarda en una variable
en forma de arreglo, ha colocado cada fila de la tabla en su respectivo índice del
arreglo como si fuera un objeto. Es decir, una fila completa (con todos sus
campos) de la tabla de la base de datos se guardará en el índice 1, la segunda fila
(completa con todos sus campos) de la tabla de la base de datos se guardará en el
índice 2. Para poder acceder a cada campo de la fila y poner estos campos (por
ejemplo, el campo “nombre”) en una tabla o formulario HTML tendríamos que
usar un “foreach” para recorrer uno a uno cada registro y obtener la información
de cada campo (por ejemplo, el campo nombre).
 where(‘NombreColumna’, ‘operador’(opcional), ‘valorAFiltrar’) – Este es el

equivalente al where de un script. Regresa la información que cumpla con la
condición. El primer parámetro es el nombre del campo donde hará la
comparación, el segundo parámetro es el operador, por ejemplo “=, <, >, <>, >=,
<=, like”, etc. Este valor es opcional. Si no pasamos este valor por defecto lo
tomara como un operador “=”. Por ejemplo, para traer la información de todos los
registros que tengan el campo nivel = universidad
$variable = NombreClaseModelo::where(‘nivel’, ’universidad); //se omitió el
parámetro operador”.
$variable2 = NombreClaseModelo::where(‘nombre’,’like’,’% Alvaro %’)->get();//

esta consulta regresa todos los registros que en el campo nombre en alguna
parte contengan la palabra Alvaro (no importa si hay algo adelante o atrás de la
palabra)
Este método por sí solo NO regresa una colección de objetos como el método
“all()”. Por lo que no podríamos usarlo, para que esta información que regresa el
método where puede ser almacenada como un arreglo de objetos debemos
ponerle el método get(). “$variable = NombreClaseModelo::where(‘nivel’,
’universidad)->get();”
 get() – Existen métodos (como “where()”) que únicamente realizan la consulta en

la base de datos pero esta no se guarda como de un arreglo, por lo que el método
“get()” nos permite convertir esta información en una colección de objetos
(arreglo) y así acceder a los datos obtenidos como una propiedad del objeto.
NOTA: al ser un arreglo para acceder al valor de la propiedad hay que espeficicar
elíndice, por lo que no podemos acceder al valor de la propiedad de la siguiente
manera $curso->nombre; para poder acceder de esta manera se usa el método
first();
 Orderby(‘NombreColumna’, ‘valorAsc/Desc’) – Este método te permite ordenar

el resultado de la columna de una columna especificada. Por defecto las consultas
vienen ordenadas de manera ascendente de acuerdo a su ID. El primer parámetro
especifica que columna se ordenara y el segundo parámetro utiliza “asc” y “desc”.
Se usa “asc” para indica si será ascendente y “desc” para indicar si se ordenara
descendente. Para ordenar múltiples columnas, puede invocar sortby() las veces
que sea necesario. Por ejemplo
$users = DB::table('users')
->orderBy('name', 'desc')
->orderBy('email', 'asc')
->get();
//Otro ejemplo
$curso = Curso::where(‘nivel’,’profesional’)->orderby(‘id’,’asc’)->get();
 first() – devuelve el prime registro de una colección. En otras palabras, regresa la
primera fila de la tabla de una base de datos (regresa el índice 0 de un arreglo). Al
ser un arreglo de un solo índice, este método nos permite acceder al valor de la
propiedad sin especificar su índice de la siguiente manera $curso->nombre; a
diferencia de get que al ser un arreglo necesita especificar su índice por ejemplo
con un foreach.
$curso = Curso::where(‘nivel’,’profesional’)->orderby(‘id’,’asc’)->first();
 value(‘nombreColunma’) – Si no necesitas una fila completa, puede extraer un solo

valor de un registro. Este método regresara el valor de una columna directamente.
Este valor se regresa como una asignación directa a la variable (desde mi opinión
creo se guarda con una string), por lo que no se puede acompañar con un método
get() o first().
$curso = Curso::where(‘nivel’,’profesional’)->value(‘nombre’); //esto regresa
Alvaro Muñoz Sabido. Es un equivalente a $curso=’Alvaro Muñoz Sabido’
 find(valorID) – recupera una fila con su valor de id, esto seria lo mismo que
escribir “where(‘id’,5)->first();” por ejemplo.
$curso = Curso::find(5);
 select(‘NombreColumna1’,’NombreColumna2-opcional’, ’NombreColumna3-
opcional’, etc) – este método nos permite regresar únicamente el valor de la
columna que especificamos. Va acompañado del método “get()” o “first()” para
poder obtener un arreglo (colección de objetos)
$curso = Curso::select(‘nombre’,‘nivel’,’descripcion’)->orderby(‘id’,’asc’)->get();
 as - alias para las columna, en el parámetro del select aquella columna que
queremos cambiar su etiqueta por un alias se usa el comando as. Por ejemplo, el
campo “nombre” quiero que ahora se llame “título”. Esto regresa la colección solo
que la propiedad (columna) “nombre” ahora será la propiedad “titulo”.
$curso = Curso::select(‘nombre as titulo’)->get();
 take(cantidad) – Este método me regresa la cantidad de registros que se le

especificaron en el parámetro. Ejemplo para regresar solo 5 registros
$curso = Curso::select(‘nombre as titulo’)->take(5)->get();
En la página oficial de Laravel en la documentación Database/Query Builder podemos ver

a más profundidad todos los métodos para realizar las consultas
https://laravel.com/docs/9.x/queries
15 – Mutadores y Accesores
Los mutadores permiten tomar datos (por ejemplo, de un formulario) e
independientemente de cómo se encuentren (por ejemplo: “EjemPlo”, “EJEMplo”,
“eJEMplo”, etc.) Los mutadores lo convierten en minúsculas y así es como lo almacenaran
en la base de datos.
Estos mutadores se colocan dentro de los modelos encargados de almacenar la
información dentro de nuestra tabla de la base de datos.
Mutadores (set)
Los mutadores usan el comando “set” ya que lo que hace es convertir el dato antes de
guardarlo en la base de datos. Es decir, Los mutadores transforman el valor antes de
almacenarlo en la base de datos.
1. Toma o recibe la información, ya sea de un formulario, o directo de la base de
datos.
2. la convierte según lo solicitado, por ejemplo, todo lo convierte en minúsculas.
3. ya convertida la información, la guarda en la base de datos
Agregar Mutadores (Laravel 9.x)

Para agregar un mutadores estos se hacen dentro del modelo, por lo que escogeremos el
modelo que esté relacionado con la tabla que queremos trabajar en la base de datos. Ya
en el archivo realizamos lo siguiente:
1. Importamos (en la parte de arriba del archivo) el atributo “Attribute” cuidando que
este tenga la ruta “Illuminate\Database\Eloquent\Cast\Attributr\
“use Illuminate\Database\Eloquent\Cast\Attribute;”
2. Dentro de la clase del modelo, creamos un método que este protegido (protected)
que llevará por nombre el nombre de la propiedad(campo) que deseamos
modificar (por ejemplo, el campo ‘name’). Este método nos retornara una nueva
instancia de la clase “Attribute” (recuerden que la definición la declaramos en el
punto anterior). Este método nos va a regresar un “Attribute” (“protected function
name(): Attribute”)
protected function name():Attribute
{
return new Attribute();
}
3. Dentro de la función “Attibute()” agregamos el comando set y una función la cual

es la que va a recibir el dato en una variable llamada “$value”.
set: function($value){}
4. Finalmente dentro de la función que tiene el set retornamos seria el nuevo valor o
la nueva forma (por ejemplo todo en minúsculas o todo mayúsculas) como
queremos que se almacene en la base de datos.
return strtolower($value);
5. El código completo (con todos los puntos anteriores) seria:

protected function name(): Attribute
{
return new Attribute(
set: function($value){
}
);
}
Nota: En este código el comando “strtolower(string)” es una función de PHP que lo que
tiene como “string” lo convierte todo a minúsculas.
Nota: para afectar a varios registros solo cambiamos el nombre de la variable $value por
$value1. El $value afecta al primer registro y el $value1 afecta al segundo registro y así
consecutivamente.
NOTA: VER ABREVIATURAS MAS ADELANTE EN LA VERSION DE LARAVEL 9.X

Agregar Mutadores (Laravel 8.x)
Agregar Accesores o mutadores es muy similar, solo cambia usar el set o get y la forma
como se regresa el valor. Para el Mutador se regresar el valor ya convertido.
La forma como se define un Accesor:
1. En vez de una función protected, esta será una función public..
2. El nombre tenia que ir “armado” de la siguiente manera
set+NombreDelCampo+Attribute($valor)
public function setNameAttribute(){
}
3. Dentro del método cambiamos el atributo antes de almacenarlo en la base de

datos. Para ello se debe acceder al atributo (especificábamos que atributo
queremos modificar) y le pasábamos el valor transformado.
$this->attributes['name'] = strtolower($value);
El código completo para Mutadores sería:

public function setNameAttribute($value){
}
Codigo completo para Accesores y mutadores versión Laravel 8.x

//Crea un Accesor Laravel 8.x
public function getNameAttribute($value){
return ucwords($value);
}
//crea un mutador Laravel 8.x

}
Accesor (get)
Estos permiten recuperar la información de la base de datos, a diferencia del mutador,
este no cambia la información de la base de datos, es decir mutador si cambia la
información que se guardara en la base de datos y el Accesor solo obtiene la información
de la base de datos, la transforma para mostrar al usuario, pero no almacena ese en la
base de datos. Es decir, Los Accesores no modifican los valores en la base de datos,
simplemente transforman como se lo presentan al usuario.
Agregar Accesores (Laravel 9.x)

3. Importamos (en la parte de arriba del archivo) el atributo “Attribute” cuidando que
este tenga la ruta “Illuminate\Database\Eloquent\Cast\Attributr\
“use Illuminate\Database\Eloquent\Cast\Attribute;”
4. Dentro de la clase del modelo, creamos un método que este protegido (protected)
que llevará por nombre el nombre de la propiedad (campo) que deseamos
modificar (por ejemplo, el campo ‘name’). Este método nos retornara una nueva
instancia de la clase “Attribute” (recuerden que la definición la declaramos en el
punto anterior). Este método nos va a regresar un “Attribute” (“protected function
name(): Attribute”)
protected function name():Attribute
{
return new Attribute();
}
6. Dentro de la función “Attibute()” agregamos el comando get y una función la cual

es la que va a recibir el dato en una variable llamada “$value”.
get: function($value){}
7. Finalmente, dentro de la función que tiene el “get” retornamos sería el nuevo valor
o la nueva forma (por ejemplo la primera letra en mayúsculas y lo demás en
minúsculas) como queremos mostrarlo al usuario final. Recuerde que “get() no
modifica la base de datos.
8. El código completo (con todos los puntos anteriores) seria:
{
get: function($value){
}
);
}
Nota: En este código el comando “ucwords(string)” es una función de PHP que lo que
obtiene como “string” convierte la primera letra en mayuscula.
NOTA: VER ABREVIATURAS MAS ADELANTE EN LA VERSION DE LARAVEL 9.X
Agregar Accesores (Laravel 8.x).

Agregar Accesores o mutadores es muy similar, solo cambia usar el “set” o “get” y la
forma como se regresa el valor. Para el Accesor se regresar el valor ya convertido.
La forma como se define un Accesor:
1. En vez de una función “protected”, esta será una función “public”..
2. El nombre tenia que ir “armado” de la siguiente manera
get+NombreDelCampo+Attribute($valor)
public function getNameAttribute(){
}
3. Dentro del método regresábamos el valor ya convertido

El código Para definir Accesores es:

}
Código completo para Accesores y mutadores versión Laravel 8.x

//Crea un Accesor Laravel 8.x
}
//crea un mutador Laravel 8.x

}
Abreviatura al crear Mutadores, Accesores (laravel 9.x)

Esto es válido únicamente para Laravel 9.x en adelante. Se logra usando el operador flecha
de php:
1. Sustituimos la palabra “function” por “fn”.
2. eliminamos las llaves y la palabra return y lo sustituimos por un => (como podrán
ver es algo similar a la función de JavaScript).
3. Eliminamos el punto y coma (;) ya que cuando usamos la función flecha no
necesitamos el punto y coma.
Escribirlo de esta manera…
},
Es lo mismo que escribirlo de esta manera:
get: fn($value)=>strtolower($value)
En el código siguiente (sin usar el operador flecha de php)

{
},
set: function($value){
}
);
}
Es exactamente lo mismo que el siguiente código (usando el operador flecha de php) solo
que es menos escritura de código.
{
get: fn($value) => strtolower($value),
set: fn($value) => strtolower($value)

);
}
Hacer test para probar los mutadores o Accesores

Para realizar las pruebas de los módulos o accesores. Podemos realizar estas pruebas en
línea de comando con Tinker.
1. En la línea de comando de visual code (ctrl + ñ) escribimos php artisan tinker +
enter
2. Definimos el módulo a usar con su ruta “use App\Models\Curso;” + enter
3. Si es para un Mutador salte el punto 3 y 4 y continue en el punto 5. Si es un
Accesor, pedimos el primer registro de la tabla con el método first(), y lo
guardamos en una variable “$curso = Curso::first();” + enter (este nos trae la
información como esta en la base de datos sin hacer aun la modificación).
4. Si revisamos la propiedad $curso->name; veremos que se ha modificado el valor,
pero esto solo en la variable ya que en la base de datos permanece sin
modificaciones. Esto es debido a que a través del Accesor le estoy especificando
que cuando acceda al atributo llamado ‘name’, antes de mostrarlo al usuario
convierte la información (las primeras letras en mayúsculas)
5. Declaramos una instancia del modelo y la almacenamos en una variable “$curso =
new Cursos();” + enter
6. Asignamos un valor a la propiedad con la que haremos la prueba, de preferencia
guardarlo alternando mayúsculas y minúsculas. Por ejemplo, “EsTo Es Un EjEmPlO”
“$curso->name = ““EsTo Es Un EjEmPlO”; + enter
7. En caso de que esta tabla tenga otros campos que no permitan valores nulos
deberemos de llenar igual esa información. Por ejemplo
$curso->email =admin@admin.com; + enter
$curso->password = bcrypt(“12345678”); //bcrypt encriptara (codificara) la
contraseña 12345678
8. Podemos revisar la información que se ha ingresado en la variable antes de
enviarlo a la base de datos, esto escribiendo $curso; + enter
9. Mandamos a guardar la información en la base de datos con el método save()
$curso->save(); enter
16 – Cómo listar y leer registros en Laravel

Recuperar datos de la base de datos y mostrarlo en un archivo HTML (view).
Recordemos que el archivo “web.php” es donde se administran las URL. Es decir, cuando
un usuario escribe en el navegador una URL, el sistema va al archivo “web.php” y desde
ahí según lo que se haya configurado el archivo “web.php” nos enviara a un archivo
controlador y este archivo controlador nos enviara a un archivo view. Este archivo view es
la vista (archivo HTML) que se le muestra al usuario final en el navegador.
(usuario escribe dirección web) URL -> web.php -> ArchivoController -> archivoView
Dado que el archivo controlador es el que indica que archivo view (HTML) es el que se va a
desplegar, este archivo controlador es el que recibe los datos que le envía el archivo
modelo. Es decir, el archivo modelo es el encargado de recibir la información de la base de
datos y este se lo pasa al controlador para que finalmente se lo pasen a la vista.
(usuario escribe dirección web) URL -> web.php -> ArchivoController -> ArchivoModelo-
>ArchivoController->archivoView
Recuperar todos los datos de una tabla y mostrarlo en un archivo HTML (view).
Traer todos los archivos de una tabla de una base de datos puede traer problemas si esta
tabla tuviera por ejemplo más 1000 registros. Más adelante explicaremos como usar la
paginación en un archivo view.
Lo primero es: en el archivo controlador definimos el modelo que administra la tabla en la
base de datos de la siguiente manera:
1. Declarando que se usara ese modelo
“use App\Models\curso”
2. En una variable (por ejemplo $curso1), guardamos lo que traiga el modelo con el
método “all()".
$curso1 = curso::all(); //el método all() trae todos los registros de la tabla que apunte el
modelo, en este caso la clase modelo llamada “curso”.
3. Podemos ver el contenido de la variable con un “return $curso1;”.
Recuperar un solo registro (un solo campo) y mostrarlo con un determinado formato
En el punto anterior todo el registro de una tabla de la base de datos la guardamos en una
variable “$curso1”. Para darle un formato a ese registro hay que pasar la variable
“$curso1” a la vista.
en el archivo controlador definimos el modelo que administra la tabla en la base de datos
de la siguiente manera:
1. Declarando que se usara ese modelo
“use App\Models\curso”
2. En una variable (por ejemplo $curso1), guardamos lo que traiga el modelo con el
método “all()".
$curso1 = curso::all(); // el método all() trae todos los registros de la tabla que apunte el
modelo, en este caso la clase modelo llamada “curso”.
3. Podemos ver el contenido de la variable con un “return $curso1;”.
4. Recuerde que para pasar una variable a un archivo view usamos el método
compact(‘variable’), recuerde que esto es equivalente a:
‘NombreCurso’ = “$NombreCurso”
Nota: ‘NombreCurso’ (sin $) es la variable que va a pasarse al HTML y

“$NombreCurso” (con $) es la variable donde el controlador recibe la información.
compact('NombreCurso'); //este es equivalente ['NombreCurso'=>$NombreCurso]
Nota: El parámetro que recibe el método compact es sin signo de pesos ($) y entre
comillas simple.
El código completo (usando la variable “$curso1” es:

class CursoController extends Controller
{
public function index(){
$curso1 = curso::all();
return view('cursos.index',compact('curso1'));

}
}
En este código ya estamos pasando la variable ‘curso1’ del archivo controlador
(“CursoController.php”) al archivo view (“view\Cursos\index.blade.php”).
5. Habiendo pasado la variable del controlador a la vista, podemos imprimir esos

registros en una lista (tag <ul> de HTML)
a. Ponemos un tag <ul> y cada uno de esos registros los pongo dentro de un
<li>.
b. Actualmente se tienen todos los registros en forma de una colección
(dentro de la variable $curso1). Para poder imprimir/acceder cada registro
de la tabla y ponerlos dentro de un tag <li> tenemos que usar un bucle
“foreach()”. El bucle foreach() va a ir recorriendo registro por registro de la
colección y cada vez que encuentre un nuevo registro lo almacene en una
variable temporal y esa variable será la que se utilizara para imprimir el
registro dentro del tag <li>. Para esto Blade nos proporciona una directiva
llamada foreach. Para escribir esa directiva debe llevar una @foreach …
@endforeach
@foreach ($collection as $item)

@endforeach
c. El foreach lleva 2 parámetros.
i. El primer parámetro es el nombre de la variable que usamos en el
método “compact()” en el archivo controlador, en este ejemplo
‘curso1’.
ii. El segundo parámetro es el nombre de la variable donde se
almacenará temporalmente cada registro (en este ejemplo
“$item”). Este segundo parámetro es el que se usara para imprimir
cada registro que vaya recorriendo el bucle y lo vamos a imprimir
dentro de un tag <li>.
Recuerde que para imprimir una variable PHP dentro de un código HTML lo
puedo hacer de 2 maneras: (la segunda opción Blade entiende que quiero
imprimir una variable PHP)
iii. <h1>Registro inicia: <?php echo $curso1; ?> Finaliza</h1>
iv. <h1> Registro inicia: {{$curso1}} Finaliza </h1>
6. @section('content')
7. <h1>Página Catálogo de cursos desde el view usando blade</h1>
8. <ul>
9. @foreach ($curso1 as $item)
10. <li>{{ $item->nombre }}</li>
11. @endforeach
12. </ul>
13.@endsection
Nota: En el archivo vista si solo imprimimos $item, este imprimirá todo el registro (toda la
fila de la tabla). Para imprimir solo el valor que tiene esa columna usamos $item-
>nombreColumna (en este ejemplo el nombre de la columna es ‘nombre’).
Usar paginación para mostrar los registros que obtuvimos de la tabla.

Como explicamos anteriormente en el archivo controlador al usar el método all() de la
clase modelo esta nos trae toda la información que tiene una tabla de la base de datos
(por su puesto hablamos de la tabla que el modelo administra).
$curso1 = curso::all();
Para usar la paginación se necesitan hacer 2 cambios en dos archivos, el archivo

controlador y el archivo “view”
1. En el archivo controlador cambiamos el método “all()” por el método “paginate()”
como se muestra a continuación:
$curso1 = curso::paginate();
Podemos pasar como parámetro del método “paginate()” el número de registros a

mostrar. Por ejemplo, “paginate(3);” este mostrara solo 3 registros por página. Si
no se pasa ningún parámetro al método “paginate()”, esto me trae los primeros 15
registros.
a. Este punto solo nos dividirá en “paginas” todos los registros. Pero hasta
este puto no tenemos los botones next o prev o los números de pagina
para poder avanzar a la siguiente pagina. Para ver la pagina 2, 3 , etc
debemos agregar al final del URL ‘?page=2’ para ver la pagina 2.
http://localhost/salon/public/cursos?page=2
2. En este punto es donde agregaremos los botones para avanzar/regresar a la

siguiente/anterior página. En el archivo vista, dentro del bloque @section …
@endsection ponemos el siguiente código:
{{$nombreVariable->links()}}
Nota: “$nombreVariable” es la variable que usamos en el método

“compact(‘nombreVariable)” en el archivo controlador. Cuidar que links es en
plural.
@section('content')
<h1>Página Catálogo de cursos desde el view usando Blade</h1>
<ul>
@foreach ($curso1 as $item)
<li>{{ $item }}</li>
@endforeach
</ul>
{{$curso1->links()}} 

@endsection
Poner botones con estilo CSS para desplazarse en la paginación de un archivo view.
Paginación con Tailwind
Tailwind es un framework CSS como lo es Bootstrap. La diferencia es que Bootstrap es una
tanto más difícil de personalizar sus componentes y esto se debe a que la mayoría de los
estilos CSS de Bootstrap tiene la propiedad “important” y esto hace que muchas veces no
permita personalizar sus componentes.
Tailwind CSS lo que quiere es que tú crees tus propios componentes. Es decir, Tailwind nos
brinda estilos que nosotros podemos combinar para crear nuestros propios componentes.
Podemos dar un estilo al botón. Para esto, este curso se basa en estilos Tailwind.
Dado que estas clases de Tailwind se aplicarán para todas las páginas, entonces en la
plantilla base es donde colocaremos el código (librería) que le dará estilo a los botones.
1. En la página https://tailwindcss.com/, ingresamos al apartado “installation”.

Buscamos el apartado donde proporciona el CDN y copiamos el enlace
<link href="https://unpkg.com/tailwindcss@^1.0/dist/tailwind.min.css" rel="stylesheet">
2. Pegamos este enlace entre los tags <head> de la plantilla base (plantilla principal o
en el archivo vista donde queremos que este el estilo CSS de la paginación)
Paginación con Bootstrap

1. En el archivo “App\Providers\AppServicesProvider.php” se pone la directiva
use Illuminate\Pagination\Paginator;
2. En el archivo “App\Providers\AppServicesProvider.php” en el “método boot()” se
pone el código Paginator::useBootstrap();
{
//
Paginator::useBootstrap();
}
3. En el archivo base plantilla se pone el link de referencia al boostrap 4.

<link rel="stylesheet"
href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.0/css/bootstrap.mi
n.css">
4. En el archivo view que no es plantilla base (por ejemplo, “index.blade.php”) antes

de cerrar la sección (@endSection) se pone el siguiente código el cual usa clase
“CSS” de Bootstrap ="d-flex justify-content-center”
<div class="d-flex justify-content-center">
{!! $curso1->links() !!}
</div>
5. El código completo del “@section” es:

@section('content')
<h1>Bienvenido a la página Catálogo de cursos desde el view usando
blade</h1>
<ul>
<li>{{ $item }}</li>
@endforeach
</ul>
<div class="d-flex justify-content-center">

{!! $curso1->links() !!}
</div>
@endsection
Crear Alias para llamar a las rutas (URL)

Laravel recomienda que apuntemos a las rutas de esta manera
Esto significa que creamos un alias para cada una de las rutas (del archivo web.php).
Al crear alias para las rutas no imposta cuando cambie la URL mientras se esté apuntando
por el alias no tendrá que actualizar en todos lados del proyecto donde apunte este alias.
Esto se logra con el uso de dos métodos:
1. El método “name(‘nombreAlias)” en el archivo “web.php”
2. El método “route(‘nombreAlias’,’parámetro’)” en el archivo vista. Cuando el
archivo web.php pasa una variable, el método “route()” recibe 2 parámetros:
a. El primer parámetro es el alias de la ruta (definida por el método “name()”
en el archivo “web.php”).
b. El asegundo parámetro es la variable. Si la clase “Route::get()” del archivo
“web.php” pasa una variable, entonces este parámetro es obligatorio.
Recuerde que el archivo view ya recibió esta variable (por ejemplo, para
trabajarlo con el “@foreach()”, esta es la variable que usaríamos como
segundo parámetro.
3. El método “route()” es código PHP por lo que se tiene que insertar dentro del
código HTML del archivo vista.
Nota: Recuerde que para insertar código PHP dentro de HTML se puede usar:
a. Código HTML <?php route(‘nombreAlias’)" ?> Código HTML
a. Código HTML {{route(‘nombreAlias’)}} Código HTML… este último es una facilidad
que nos da Blade.
Laravel recomienda que apuntemos a las rutas de esta manera principalmente por dos
razones
1. Por mantenimiento del código, ya que si cambiamos físicamente la URL del archivo
vista (por ejemplo, lo cambiamos de carpeta o de nombre) el alias sigue apuntando
a ese path URL y por lo tanto no tendríamos que actualizar el código donde se hizo
referencia a esa URL.
2. Por seguridad. Esto es cuando usamos controladores para redirigir el URL, ya que
al crear un alias podemos esconder la ruta (path) real de nuestro archivo vista. Es
decir, al escribir el URL que tiene el alias, este nos redireccionara a la vista, pero la
dirección del navegador mostrar como link el alias y no el directorio real.
Es decir, de este código donde tenemos definido el URL real “cursos/ejemplo”
Route::get('cursos/ejemplo', [CursoController::class, 'ejemplo'])-
>name('URLEscondido');
Al usar el alias podríamos esconder el URL. En vez de que el usuario escriba la ruta real
“cursos/ejemplo” podrá escribir “http://localhost/salon/public/e” y accedería a la misma
página solo que el URL está escondido.
Route::get('e', [CursoController::class, 'ejemplo'])->name('URLEscondido');
Lo anterior es posible ya que al detectar el URL “http://localhost/salon/public/e” este

llamará al método llamado “ejemplo” de la clase CursoController. Dentro de este método
“ejemplo” se define la ruta real hacia donde se redireccionará el sitio. Para más claridad
ponemos un fragmento de un archivo controlador.
//Este es archivo controlador
{
public function ejemplo()
{
return view('cursos.ejemplo');
}
}
Como podrán ver aquí el método “ejemplo()” es el que regresa el método “view()” con la
ruta real (URL) del archivo vista.
Crear una lista de con datos de una tabla y cada registro de esa lista sea un enlace el
cual con su ID nos redireccione a otro view para mostrar el campo nombre de ese
ID.
Para esta tarea se van a trabajar 3 archivos
1. El archivo view Cursos (‘index.blade.php’). El cuál es el archivo vista que desplegara
el “catalogo cursos” por la columna nombre.
2. El archivo controlador el cuál a través de su método correspondiente (en este
ejemplo “show()”) traerá toda la información de la base de datos para después
pasarla al archivo vista final (‘cursos\show’).
3. El archivo view final (‘cursos\show’) que recibirá la variable del controlador que
tiene los registros de la tabla de la base de datos y los mostrara al usuario final.
Codificación del archivo view Cursos (‘index.blade.php’).

En el capítulo “usar paginación para mostrar los registros de la tabla”, si realizamos bien el
procedimiento nos arroja una tabla como la siguiente:
Estos registros están dentro de un tag <li>. Esta lista es la columna nombre de la tabla
Cursos de la base de datos.
Para convertir la lista en enlace:
1. Dentro del tag <li> vamos a poner un tag <a href””>… </a> para convertir cada
registro de la lista en un link y dentro del tag <a> imprimimos la variable PHP que
trae el registro (en este caso la columna nombre).
<ul>
<li>
<a href="">{{ $item->nombre }}</a>
</li>

@endforeach
</ul>
2. Ponemos como enlace (dentro del “href”) el alias del view. Esto se logra con el
método “route(‘alias’, ‘parámetro-opcional-’ )”.
<ul>
<li>
<a href="{{route('cursos.show',$item->id)}}">{{ $item->nombre
}}</a>
</li>
@endforeach
</ul>
En este ejemplo, en el método “route()” estamos pasando 2 parámetros:

a. el alias ‘cursos.show’ utilizado en la clase route del archivo “web.php”, si no
se utilizara un alias se pondría el URL entre comillas.
b. la columna id de la tabla de base de datos. En la variable $curso1 se tienen
todos los registros que el archivo controlador recupero de la base de datos.
Con el foreach se va recorriendo registro por registro y se almacena de
manera temporal en la variable “$item”. Desde la variable “$item”
podemos acceder a cada propiedad (campo) de ese registro.
Para el texto del tag <a href=””> estamos imprimiendo la columna nombre de la
base de datos con la propiedad ”$item->nombre”.
El archivo completo del archivo index.blade.php
@section('title', 'Pagina index')
@section('content')
<h1>Bienvenido a la página Catálogo de cursos desde el view usando
blade</h1>
<br>
<ul>
<li>
<a href="{{route('cursos.show',$item->id)}}">{{ $item->nombre
}}</a>
</li>
@endforeach
</ul>
@endsection
Codificación del archivo controller Cursos (método show().
En el archivo controlador, buscamos el método que tiene como destino archivo view final
(en este caso archivo (‘show.blade.php’).
Dentro de este método (método “show()”) codificamos 2 puntos:
1. Obtenemos los registros de la base de datos y lo guardamos en la variable
“$curso”. En este ejemplo Utilizamos el método “find()” para obtener los registros
de la base de datos. Este método pasa el id del registro y recupera los demás
registros faltantes de ese id. Recuerde que en la página catálogo de cursos (archivo
‘index.blade.php’) en el link de cada lista pasamos el ID del registro y este id es el
que pasamos como variable en clase Route::get() del archivo web.
$curso = curso::find($id);
2. Los registros guardados en la variable “$curso” se lo pasamos al archivo vista final

(‘show.blade.php’):
return view('cursos.show', compact('curso'));
Archivo controlador completo:
<?php
namespace App\Http\Controllers;
use App\Models\curso;
use App\Models\Maestro;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\URL;
use Illuminate\Support\Str;

{
public function index()

{
$curso1 = curso::paginate();
return view('cursos.index', compact('curso1'));
}
public function show($id, Request $request)

{
$URL=URL::previous(); //obtenemos el URL anterior (obtener de donde
venimos)

if (Str::contains($URL, 'maestro')){ //buscamos si el URL viene de la
pagina maestros
$curso = Maestro::find($id);
return view('cursos.show',compact('curso'));
}
if(is_numeric($id)){ //saber si el URL contiene el ID para utiliar

el método find
$curso = curso::find($id);
}else{
$curso = $id; //de lo contrario se pasa lo que tiene la URL para
enviarlo a la pagina show
}

}
}
Codificación del archivo Vista final (show.blade.php)
Este archivo es el que desplegara al usuario el nombre del curso de acuerdo al id
obtenido.
1. En el archivo vista Blade final (en este caso ‘cursos/show’), dentro de “@section”
vamos imprimir en el HTML el nombre
<h1>Bienvenido al curso "{{$curso->nombre}}" desde el view usando blade</h1>
Archivo show.blade.php completo:

@section('title', 'Pagina show - '.$curso)
@section('content')
@if (is_string($curso)) {{-- Se usa if para busca si la variable es un
registro (colección de la base de datos) o solo una cadena (string)--}}
<h1>Bienvenido al curso "{{$curso}}" desde el view usando blade</h1> {{-- Si
es una cadena se imprime la cadena --}}
@else
<h1>Bienvenido al curso "{{$curso->nombre}}" desde el view usando blade</h1>
{{-- si es un registro se imprime su propiedad --}}
@endif
<a href="{{route('cursos')}}">Regresar al catalogo de cursos</a>

<br>
@endsection
17 - Como agregar o actualizar registros desde un formulario

Este capítulo se dividirá en 3 etapas
1. Crear el formulario en el archivo view
2. Guardar los datos del formulario en la base de datos
3. Editar un registro de la base de datos a través del formulario.
Guardar los datos de un formulario en la base de datos

Crear un formulario en el archivo view.
Este formulario se va a crear usando las tags, form, label, input, textarea y el botón submit
para enviar el formulario.
@section('title', 'Pagina create')
@section('content')
<h1>Página de Formulario desde el view usando blade</h1>
<form action="" method="post">
<label>
Nombre:
<br>
<input type="text" name="name">
</label>

<br>
<label>
Descripcion :
<br>
<textarea name="descripcion" rows="5">
</textarea>
</label>
<br>
<label>Categoria
<br>
<input type="text" name="categoria">
</label>
<br>
<br>
<button type="submit"> Ingresar registros</button>
</form>
@endsection
Luego que el usuario llene los campos del formulario esta información se tiene que enviar
a algún lado para que se procese. En la propiedad “action” del “form” es donde indicamos
la acción a tomar una vez que el usuario haga clic en el botón “submit”. En este ejemplo se
enviará a una URL.
El tag Form utiliza dos maneras de enviar la información de su formulario:
 get – Es la menos segura esto es porque la información capturada en el formulario
se envía por medio de la URL. Es decir, la URL tiene insertado datos que fueron
ingresados al formulario y es visible para el usuario final.
 post – la información capturada en el formulario se envía de manera oculta
utilizando el “body” del HTTP Request. Por tema de seguridad siempre que
enviemos información de un formulario, deberemos utilizar el método “post”.
Para la propiedad action del “form” que platicamos anteriormente, vamos a crear una
nueva ruta de tipo post. Cada formulario debe de tener su propia ruta, es decir por cada
formulario debemos definir una clase “Route::post” en el archivo web.php como se
muestra a continuación:
Route::post('cursos',[CursoController::class, 'store'])->name('cursos.store');
En el código anterior le estamos diciendo que la clase controlador “CursoController” en su
método “store()” es el que se va a encargar de controlar lo que pasa con esa ruta (lo que
esa ruta va a realizar) y para acceder a la ruta lo hacemos a través del alias ‘cursos.store’
con el método “route()”. Este alias es el que vamos a agregar a la propiedad “action” del
formulario.
<form action="cursos.store" method="post">

En el archivo web.php habíamos declarado la ruta como tipo POST ( “Route::post(…)” ) es
por eso que la propiedad “method” del formulario debemos especificarla como post
(“method=’post’”).
El objetivo de especificar la propiedad method del formulario con “post” o “get” es para
que Laravel sepa a que ruta (en el archivo web.php) se aplicara la propiedad “action” del
formulario. Por ejemplo, si en el archivo web.php tenemos dos clases Route con la misma
ruta (‘cursos’) únicamente la diferencia esta en sus métodos post (Route::post) o get
(Route::get) como se muestra a continuación:
Route::get('cursos', [CursoController::class, 'index'])->name('cursos');
Route::post('cursos',[CursoController::class, 'store'])->name('cursos.store');
Al especificar en el formulario la propiedad “ method=’post’ ” Laravel sabe que la

propiedad “action” de ese formulario debe dirigirse al segunda ruta que tiene el método
“store”. Por el contrario si hubiéramos definido la propiedad “ method=’get’ “ del
formulario, entonces Laravel se direcciona a la primer ruta que tiene el método “index”.
Agregar un token al formulario

Es impórtate señalar que Laravel exige crear un token cada que se envié información
(datos) por el método post, es decir debes enviar también un token junto al formulario.
Omitir el token al procesar el formulario Laravel me mostrara la página como un Error
419| Page Expired.
Esto lo hace Laravel para evitar que un usuario malicioso a través de herramientas de
desarrollador de Chrome, quiera enviar información a la base de datos desde un
formulario ficticio (creado por las herramientas de desarrollador de Chrome).
Para agregar el token, dentro del formulario se agrega una directiva de Blade “@csrf”
<form action="cursos.store" method="post">
@csrf
Esta directiva @csrf agrega un input oculto con la propiedad “ name = ‘token’ “ y es la
encargada de generar un token para este formulario.
La directiva “@csrf” además de crear el token también lleva un registro de los tokens que
se generan. En este registro por cada token generado crea una relación del URL que lo
manda, así como el URL que recibe (el valor de la propiedad “action” del formulario). Con
ello garantiza que, aunque de manera local adultere el formulario, este no sería
procesado.
Otro punto interesante de los Token es que estos tienen un tiempo de vida. Laravel
después de cierto tiempo va eliminando esos registros de los token, por ende, si tenías
una pagina abierta con un formulario, pero dejaste inactiva por mucho tiempo la página,
al querer procesar ese formulario te aparecerá como que la pagina ya expiro. Si
trabajáramos con PHP puro todos estos temas de seguridad tendríamos que hacerlos
nosotros mismos.
Recuperar la información del formulario a una variable

Para esto tengo que ir al controlador y centrarme en el método que administra la ruta
‘cursos.store’ (esto se definió en el archivo “web.php”).
Para recibir lo que se manda desde un formulario, al método “store()” se le tiene que
pasar un parámetro de tipo Request. Este objeto de tipo Request es el encargado de
interactuar con la solicitud actual HTTP que maneja la aplicación, así como recuperar los
inputs (los datos de un formulario), las cookies y los archivos que se enviaron con la
solicitud.
public function store(Request $request)
{

}
Para ver lo que trajo el objeto “Request”, hacemos un “return” a la variable “$request”
invocando a su método all()
{
return $request->all();
}
Guardar en un registro de la base de datos la información del formulario

En el capítulo 11 de este curso se explicó como a través de Tiker usando línea de
comandos podemos agregar registros a la base de datos. De esta misma manera es que se
va a guardar los registros capturados en el formulario en una base de datos:
1. se crea una instancia de la clase modelo y se guarda en una variable
2. A cada propiedad de la variable “$curso” (con propiedad nos referimos a cada

columna de la tabla) que tiene la instancia se le asignan los datos recuperados por
el objeto Request con sus respectivas propiedades obtenidas del formulario.
$curso->nombre = $request->nombre;
$curso->descripcion = $request->descripcion;
$curso->categoria = $request->categoria;
3. Importante antes de guardar la información revísela retornando la variable para
verificar que es lo que contiene y así ver que se guardaría en ella.
return $curso;
4. Se manda a guardar la información en la base de datos con el método “save()”

$curso->save();
El código completo seria:

{

$curso->save();
}
Redireccionar a otra página una vez guardado el formulario en la base de datos.

Esto se logra en el archivo controlador. Dentro del método asignado para el URL, antes de
terminar el método (como ultima actividad del método) le vamos a pedir que retorno un
URL. Para ello vamos a usar el método “redirect()” y el método “route(parametro1,
parametro2 )”. En el método route pasamos 2 parametros.
1. El primer parámetro es la ruta o URL a donde nos queremos redireccionar
2. El segundo parámetro es opcional y depende de que la URL a la que vamos a
direccionar esta esperando o no una variable. Para este ejemplo la enviamos a una
URL que si esta esperando una variable por lo tanto se la tenemos que pasar, en
este caso el id.
return redirect()->route('cursos.show', $curso->id);

En el último parámetro si en vez de escribir $cursos->id escribiéramos únicamente $curso
(es decir omitiéramos el id). Laravel es suficientemente inteligente para identificar que
nos referimos al id por lo que al omitirlo Laravel haría referencia al id. Cabe señalar que
desconozco si esto es porque al ser la primera columna de la tabla Laravel trae este primer
registro en automático.
Entonces este código

Es lo mismo que este código

return redirect()->route('cursos.show', $curso);
Editar un registro de la base de datos a través de un formulario.
El siguiente paso es escribir el código necesario para poder actualizar el registro del
capítulo anterior. Para esto lo que tendríamos que hacer es
 Crear un enlace que diga editar curso
 Al dar clic al enlace “editar curso” nos redirija a un formulario (similar al que
utilizamos para crear un nuevo registro). Este formulario ya debería de estar
llenado con la información de la base de datos
Crear un enlace en el archivo view (página web) para ir al formulario de edicion.

Para esto nos vamos al archivo “show.blade.php” y creamos un link con el tag
“<a href=’’>…</a>”. Este link va a llevar por nombre “editar curso”.
<a href="">Editar Curso</a>
Creación de la ruta y método para el formulario de edición.

Recuerde que por cada enlace debemos de crear su propia ruta. Creamos la nueva ruta en
el archivo web.php.
Esta ruta será de tipo “get” y la URL llevará una variable de la siguiente manera
‘cursos/{id}/edit’
Route::get('cursos/{id}/edit', [CursoController::class, 'edit'])
->name('cursos.edit');
La razón de estar pasando la id por el URL es porque a través de este id vamos a recuperar
el id del registro y con esos datos vamos a llenar el formulario, además estamos agrgando
a la URL la cadena ‘/edit’ para diferenciarla de otra clase “Route” creada anteriormente
que tiene la misma ruta ‘cursos/{id}’ como veremos en el siguiente código.
Estas son hasta el momento las clases “Route” creadas en el archivo “web.php”
Route::get('/', HomeController::class);
Route::get('cursos', [CursoController::class, 'index'])->name('cursos');
Route::get('cursos/create', [CursoController::class, 'create'])

->name('crea');
Route::post('cursos',[CursoController::class, 'store'])
->name('cursos.store');
Route::get('cursos/{id}', [CursoController::class, 'show'])

->name('cursos.show');
Route::get('cursos/{id}/edit', [CursoController::class, 'edit'])

->name('cursos.edit'); //esta es la que queremos diferenciar con la ruta
anterior agregándole la terminación /edit
Creamos ahora en el archivo controller el método definido en la nueva ruta del archivo
web.php (en este caso es el método “Edit()” ).
Como recuerdan por el URL estamos mandando una variable por lo que el método tiene
que ir definido con el parámetro que recibirá esa variable.
public function edit($id)

{

}
Una vez creada la nueva ruta (archivo web.php) y su respectivo método de la ruta. Ahora
en el archivo view (show.blade.php) podemos definir la propiedad href=”” con el valor que
se definió como alias de la nueva ruta (en este ejemplo ‘cursos.edit’). Esto lo hacemos
imprimiendo el método “route()” y pasándole 2 parámetros
1. El primer parámetro es el URL en este caso el alias definido para este URL
2. El segundo parámetro es el id que ya tiene la variable $curso.
<a href="{{route('cursos.edit',$curso->id)}}">Editar Curso</a>
Hasta este punto si ingresamos desde el formulario un nuevo registro para guardar en la
base de datos, al guardar la información nos redireccionará a la página “show.blade.php”
y nos despliega una página con la información que capturamos en el formulario.
Si damos clic en el enlace “editar curso” este nos mandara a una página en blanco, pero lo
que nos interesa es que en el URL vendrá el ID que necesitamos para obtener el registro
de la base de datos
http://localhost/salon/public/cursos/8/edit
Recuperar datos de la base de datos para llenar el formulario a editar
Realizado el punto anterior, ahora en el archivo controlador, dentro del método para esta
ruta (en este caso el método “edit()” ) Recuperamos el registro de ese id en específico a
través del método “find()” y lo guardamos en una variable.

{
$curso= curso::find($id);
return $curso;
}
Recuerde que con Return y la variable podemos realizar una prueba y verificar que
información es la que recupero el método “find()” de la base de datos antes de mandar a
guardar la información en la base de datos.
Abreviatura para recuperar datos de la base de datos para llenar el formulario a editar
Otra forma de recuperar los registros de la base de datos es pasando el parámetro del tipo
de la clase del modelo, es decir, si la clase modelo es ‘curso’ entonces pasamos el
parámetro de tipo curso.
Es decir, este código

{
$curso= curso::find($id);
return $curso;
}
Regresa lo mismo que este código
public function edit(curso $curso)
{
return $curso;
}
Si pasamos como parámetro el tipo de la clase modelo, Laravel entiende que quiero que la
variable “$curso” sea una instancia de la clase curso Modelo cuyo id (del registro a
recuperar) sea lo que estemos mandando por el parámetro. De esta manera escribiríamos
menos código.
Llenar el formulario HTML con los valores recuperados de la base de datos para su edición
El siguiente paso es sustituir el “return $curso” por la ruta de la vista. Esta vista aun no la
hemos creado. Este archivo vista lo creamos dentro de la carpeta
view/cursos/edit.blade.php
Hasta este punto este es el código del archivo edit.blade.php tendría este aspecto: (aun
no nos faltaría poner en el formulario los datos recuperados en la base de datos.
@section('title', 'Pagina Editar')
@section('content')
<h1>En esta pagina podras editar un curso desde el view usando blade</h1>
<form action="{{route('cursos.store')}}" method="POST">

@csrf
<label>
Nombre:
<br>
<input type="text" name="nombre">
</label>

<br>
<label>
Descripcion :
<br>
<textarea name="descripcion" rows="5">
</textarea>
</label>
<br>
<label>Categoria
<br>
<input type="text" name="categoria">
</label>
<br>
<br>
<button type="submit">Actualizar registros</button>
</form>
@endsection
Para llenar los registros del formulario con los registros recuperados de la base de datos
(recuerde que en la variable “$curso” se almaceno los registros recuperados en la base de
datos. Por lo tanto, si el tag HTML soporta la propiedad “value”, entonces en este valor se
imprime la variable $curso->nombre como se muestra a continuación:
<input type="text" name="nombre" value="{{$curso->nombre}}">
En caso de que el tag no tenga la propiedad “value” entonces se imprime el valor de la

variable “$curso->nombre” de la siguiente manera
<textarea name="descripcion" rows="5">{{$curso->descripcion}}</textarea>
El código completo seria (aun nos falta crear una ruta que será la que reciba el formulario
al dar clic al botón “actualizar registros”)
@section('title', 'Pagina Editar')
@section('content')
<h1>En esta pagina podras editar un curso desde el view usando
blade</h1>
<form action="{{route('cursos.store')}}" method="POST">

@csrf
<label>
Nombre:
<br>
<input type="text" name="nombre" value="{{$curso->nombre}}">
</label>

<br>
<label>
Descripcion :
<br>
<textarea name="descripcion" rows="5">{{$curso-
>descripcion}}</textarea>
</label>
<br>
<label>Categoria
<br>
<input type="text" name="categoria" value="{{$curso-
>categoria}}">
</label>
<br>
<br>
<button type="submit">Actualizar registros</button>
</form>
@endsection
Creación de una nueva ruta (archivo web.php) y método (archivo controlador) para el
nuevo formulario
Recuerde que por cada formulario se tiene que crear su propia ruta por lo que a
continuación necesitamos crear una nueva ruta en el archivo “web.php”. Esta nueva ruta
será la encargada de actualizar el registro en la base de datos a través de su método del
controlador.
Route::post('cursos/{curso}', [CursoController::class, 'update'])-

>name('cursos.update');
Como se va a traer información del formulario usamos POST. Con esto ocultamos la
información del formulario (recuerde que “GET” envía a través del URL los datos del
formulario y por ende es visible al usuario final)
Configuración del método “put” para actualizar la información en la base de datos
IMPORTATE Laravel recomienda que cuando queramos actualizar un registro en vez de
usar el método POST utilices el método “PUT”.
Route::put('cursos/{curso}', [CursoController::class, 'update'])-
Sin embargo, los formularios HTML solo soportan 2 métodos: “GET” y “POST”. Para lograr
definir el formulario como método “put” necesitamos realizar 2 acciones
1. Definir la propiedad “method” del formulario como “POST” (method=”POST”)
2. Pasarle en el cuerpo del formulario la directiva @method('put’)
<form action="{{route('cursos.update', $curso->id)}}" method="POST">

@method('put')
Como podrá observar en la propiedad “action” pasamos el método route con 2

parámetros
1. el alias de la nueva ruta creada en el archivo web.php, en este caso ‘cursos.update’
2. Como la nueva ruta tiene una variable (URL ‘cursos/{curso}’), este sería el segundo
parámetro $curso->id
En el archivo controlador creamos el método update(). Este método va a recibir dos
parámetros:
1. El primer parámetro será de tipo clase modelo (recuerde el modo abreviado
Laravel entiende que la variable $curso es instanciando la clase modelo y guardado
en esta variable y además recupera el id de ese registro)
2. Como segundo parámetro es una variable de tipo “Request” ya que esta variable
es la que nos ayudara a rescatar la información que el usuario escribió en el
formulario.
public function update(curso $curso, Request $request)

{

}
El siguiente paso es dentro del método, actualizar la variable $curso con lo que tiene la
variable $request. Esto lo hacemos por cada columna que tiene la tabla de la base de
datos
Antes de guardar revisamos que datos se han guardado en la variable “$curso” con un
return

{
return $curso;
}
Si todo esta correcto sustituimos el return por el método “save()” para ahora si actualizar
el registro en la base de datos.
{
$curso->save();
}
IMPORTATE: Recuerde que “Tinker” si queremos guardar un nuevo registro tiene que ser
una instancia que no haya guardado algún registro en la base de datos, de lo contrario si
usamos una instancia que ya ha guardado información en la base de datos va a detectar
que tiene la misma ID (aunque hayamos modificado los otros campos) y por ende lo que
hará será editar la información del registro de esa ID en vez de guardarlo como un registro
nuevo. Ese mismo principio es el que aplica aquí. Si observa el método “store()” solo trae
como parámetro la información del formulario (“Request $request), pero el método
“update()” trae dos parámetros: la información del formulario (“Request $request”), pero
también trae el registro de la base de datos (“curso $curso”) por ende esta variable ya
tiene un id asignado y al editar los demás campos lo que realiza en la base de datos sería
una actualización y no un registro nuevo.
Como último punto, una vez actualizado el registro en la base de datos redireccionamos a
la página donde me mostrará los detalles del curso (página show.blade.php, su alias es
cursos.show)
El código completo del método update es

{
$curso->save();
}
18 – Validar formularios en Laravel.

Una vez llenado los datos del formulario, antes de enviarla a una base de datos, verificar
que la información sea correcta: los campos obligatorios y en caso de estar vacíos
redireccionar al mismo formulario y marcar los campos incorrectos.
El código para esta validación se hará en el archivo controller. Dentro del método que
asigna los valores y lo guarda en la base de datos. Este será el primer código por
ejecutarse dentro del método (antes de asignar los valores y por supuesto antes de
guardar con el método “save()” los valores en la base de datos) ya que si la validación es
incorrecta interrumpe el flujo del código.
Agregar una validación (Especificar los campos requeridos).

En el método que utilizamos para guardar los datos del formulario en la base de datos que
se encuentra dentro del archivo controlador vamos a agregar antes que cualquier otro
código un método que nos ayude a validar la información que se capturo en el formulario.
Este método es “validade()” y dentro podemos resaltar 2 puntos de este método:
1. Dentro de él podemos indicar los campos que deseamos verificar (los datos
capturados en el formulario).
2. Este método se aplica a la variable “$request” (recuerde que este variable de tipo
“Request” obtiene la información capturada en el formulario.
El código seria:
//código para validar los datos del formulario.
$request->validate([
'nombre' => 'required',
'descripcion' => 'required',
'cantidad' => 'required'
]);
Es importante señalar que este código únicamente validaría la información como falso o
verdadero para continuar (validación verdadera) o detener (validación falsa) el flujo del
código. En este último punto (validación falsa) se podría comparar con deshabilitar el
botón “submit” del formulario (por lo que la pagina se refrescaría y se perdería la captura,
evidentemente se detiene el flujo y no se guardaría la información en la base de datos).
Por lo que todavía tendríamos que indicarle que hacer si la validación fue falsa, como por
ejemplo que campos fueron incorrectos
Agregar varias validaciones (Especificar los campos requeridos).

Se puede agregar varias validaciones simultáneamente para un mismo componente
separándolos con un amperson |(nota se pueden concatenar N validaciones) observe que
todas las validaciones están dentro de un mismo par de comillas simples.
'nombre' => 'required | max:10',
Con esto le estoy diciendo que el componente HTML con el atributo name=’nombre’ tiene
2 reglas
1. Que es un campo requerido
2. Que solo puede capturar un máximo de 10 caracteres.
En la siguiente página
https://laravel.com/docs/9.x/validation#available-validation-rules podemos encontrar
todas las validaciones y sus funciones.
Es importante señalar que Laravel recomienda tener las validaciones en otro archivo y no
dentro del archivo controller, pero cuando son validaciones muy pequeñas se puede
poner dentro de los métodos del archivo controller como en el ejemplo anterior. Más
adelante (en el capítulo “que son los “Form Request”) vamos a explicar cómo tener las
validaciones en otro archivo y ligarlos al archivo controlador.
Especificar los componentes con error (mostrar mensajes de error)
Esto se hace en el archivo vista donde tenemos el formulario y para ello vamos a utilizar la
directiva de Blade “@error” y la variable PHP “$message”.
La variable “$message” es donde en caso de haber algún error se guardar de manera
interna el registro de ese error.
Este código se agregaría por cada input o componente como e muestra a continuación:
<label>
Nombre:
<br>
<input type="text" name="nombre" value='{{$material->nombre}}'>
</label>
<br>
@error('nombre') {{-- el parámetro ‘nombre’ es el valor de la propiedad

name del input --}}
<small>*{{$message}}</small>
@enderror
<br>
A continuación se muestra el código completo del formulario en el archivo vista:

<form action="{{route('materiales.storeM')}}" method="POST">
@csrf
<label>
Nombre:
<br>
<input type="text" name="nombre">
</label>
@error('nombre')
@enderror
<br>
<label>
Descripcion :
<br>
<textarea name="descripcion" rows="5"></textarea>
</label>
@error('descripcion')
@enderror
<br>
<label>Cantidad
<br>
<input type="number" name="cantidad">
</label>
@error('cantidad')
@enderror
<br>
<br>
<button type="submit">Ingresar registros</button>
</form>
Configurar los mensajes de error de la validación a español.

Dentro de la carpeta del proyecto tenemos una la ruta “resource/lang” dentro de esta
carpera se encuentran todos los mensajes de error que tiene Laravel.
Si queremos cambiar estos mensajes al español tenemos de duplicar esa carpeta y su

contenido, pero en vez que diga “en” debemos ponerlo en “es” como se muestra a
continuación:
El siguiente paso es traducir al español cada uno de los archivos de la carpeta “es”. Pero
en Google podemos encontrar estos archivos ya traducidos. Para ello vamos a Google y
escribimos “Laravel es español”. Damos clic en el enlace
https://github.com/Laraveles/spanish
Buscamos la carpeta “es” (la ruta pudiera ser resources/Lang/es). Esto nos mostrara los
archivos que ya están traducidos, por lo que tenemos que abrir cada uno, copiar su código
completo y pegarlo en el archivo del proyecto correspondiente para reemplazar su
contenido anterior.
Una vez reemplazado el contenido de los archivos al español, el siguiente paso es indicarle
a Laravel que queremos usar la carpeta “es” y no la carpeta “en”.
Para esto debemos ir a la carpeta “config” que se encuentra en la raíz del proyecto y
abrimos el archivo “app.php”. Este archivo tiene la configuración general de nuestro
proyecto.
En este archivo buscamos el código

'locale' => 'en',
Y cambiamos ‘en’ por ‘es’
'locale' => 'es',
Con esto estamos indicando que ahora los mensajes la toma de la carpeta ‘es’.
Es importante tomar en cuenta que la traducción toma el nombre del atributo que se le
haya puesto al input o componente
<textarea name="description" rows="5"></textarea>
por lo que si lo pusimos en ingles el mensaje de error saldría:
El campo description es obligatorio.
Para solucionar esto en el archivo “validation.php” (la carpeta del proyecto

resource/Lang/es) al final se encuentra el siguiente código
'attributes' => [],
Dentro de este arreglo enumeramos los atributos de los inputs (componentes) que
quisiéramos traducir
'attributes' => ['name'=>'nombre','description'=>'descripcion'],
De esta manera si el valor de name del input es description, Laravel lo identifica y lo
traduciría como descripción.
Nota Laravel sustituirá el valor description por lo que hayamos definido, por ende, si
definimos ‘description’=>’asd’ el mensaje de error seria
“el campo asd es obligatorio”
Evitar perder los datos del formulario cuando la validación sea falsa
Esto se hace en la vista que tiene el formulario.
Al llenar un formulario y enviarlo pero la validación es negativa, lo que hace el sitio web es
refrescar la pagina y por ende perdemos lo que se había capturado. Para evitar perder la
captura cuando la validación es errónea, usamos el método “old()”.
La sintaxis del método “old(parametros1, parametro2)” es:
 El parametro1 es el valor del atributo name del componente html
 El parámetro2 es opcional y es para especificar el valor por default con el que
iniciara.
Este segundo parámetro es idea para los formularios que son para actualizar los datos. Ya
que por default le ponemos el valor del registro y con el método old no perdemos las
ediciones realizadas en los componentes. Así si editamos ese componente no se perdería
la información en caso de que la validación sea falsa.
En la atributo “value” le asignamos como valor el método “old()” pasando a este método
como parámetro el valor que tenga el atributo “name” del input.
<input type="text" name="nombre" value='{{old('nombre')}}'>
El código completo del formulario sería
<form action="{{route('materiales.storeM')}}" method="POST">
@csrf
<label>
Nombre:
<br>
<input type="text" name="nombre" value='{{old('nombre')}}'>
</label>
@error('nombre')
@enderror
<br>
<label>
Descripcion :
<br>
<textarea name="descripcion"
rows="5">{{old('descripcion')}}</textarea>
</label>
@error('descripcion')
@enderror
<br>
<label>Cantidad
<br>
<input type="number" name="cantidad" value='{{old('cantidad')}}'>
</label>
@error('cantidad')
@enderror
<br>
<br>
<button type="submit">Ingresar registros</button>
</form>
Como se explico anteriormente para usar el método old en un formulario que se utiliza
para editar la información de la base de datos debería de usarse
<input type="text" name="nombre" value='{{old('nombre',$material-

>nombre)}}'>
19 – Separar las validaciones en archivos propios (FormRequest).

Definición
Para escenarios de validaciones más complejas, es posible crear los “form Request”. Estos
archivos encapsulan su propia lógica de validación (una validación mucho más
personalizada) y autorización.
Creación
Para crear un archivo “Form Request” se hace desde la línea de comandos con la
instrucción:
php artisan make:request NombreMetodoControlador

Por ejemplo, la intención de crear este archivo es crear reglas de validación para el
método store() del controlador “CursoController” Por lo que el nombre seria StoreCurso
php artisan make:request StoreCurso.
Esto nos creara un archivo “StoreCurso.php” en la ruta “app/Http/Requests”. Es

importante señalar que en caso de que no exista la carpeta “Request” al momento de
crear el archivo también crearía la carpeta.
class StoreCurso extends FormRequest

{
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize()
{
return false;
}
/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules()
{
return [
//
];
}
}
Como podrá observar el archivo creado tiene una clase llamada “StoreCurso” de tipo
“FormRequest” y dentro de esta clase se definen 2 métodos:
 authorize() – Dentro de este método se establece la lógica necesaria para verificar
si el usuario que está intentando ingresar datos a la base de datos cuenta con los
permisos para poder hacerlo; por ejemplo, que tenga los permisos de
administrador, creador de contenidos, editor de contenido o algún permiso que le
permita escribir en la base de datos.
Si los permisos son correctos entonces regresa el valor de “true” en caso de que el
usuario no cuenta con los permisos regresa el valor de “false”. Regresar el valor “
false” es el valor predeterminado.
Solo si regresa el valor de “true” continua al método siguiente (rules()), en caso
contrario la autorización falla y regresa un mensaje diciendo usuario no autorizado.
 rules() – En este método entre corchetes se van a agregar todas las validaciones
que necesitemos para este formulario como se muestra a continuación:
public function rules()
{
return [
//
'nombre'=>'required',
'descripcion'=>'required',
'categoria'=>'required'
];
}
personalización de atributos (método Attribute)

Dentro el archivo Request (en este ejemplo “StoreCurso.php”) definimos un método de
tipo publico llamado “Attribute”. Dentro de este método (entre corchetes) es donde se
definen todos los atributos que tiene el formulario y su correspondiente mensaje. (con
atributos nos referimos el valor que tiene la propiedad “name” de cada uno de los
componentes que tiene el formulario como se muestra en el siguiente código).
<input type="text" name="nombre" value="{{old('nombre')}}">
En otras palabras, dentro del método Attribute por ejemplo, definimos el atributo
“nombre” (el valor de name=”nombre”) y en caso de encontrarlo sustituirá el atributo
“nombre” por el mensaje/palabra que definimos.
public function attributes()
{
return [
'nombre' => 'nombre del curso',
];
}
Con este método sustituimos del mensaje predeterminado de error: “El campo nombre es
obligatorio”, a el mensaje: “El campo nombre del curso es obligatorio”.
Personalización de mensaje (método message())

Dentro el archivo Request (en este ejemplo “StoreCurso.php”) definimos un método de
tipo publico llamado “message”. Este método nos permite sustituir el mensaje de error
predeterminado de esa validación por un mensaje personalizado. Importante resaltar que
la sustitución del mensaje aplicaría únicamente para el componente del formulario al que
se especifica, es decir el valor de su propiedad name del formulario tiene que ser igual al
atributo definido en el método message()
Para esto tenemos que definir 2 cosas
 A cuál atributo se personalizaría el mensaje.
 La validación en específico al que se aplicaría ese mensaje. La sintaxis para ello es
“atributo.validacion”. Recuerde que un atributo puede tener más de una
validación y cada validación tiene su propio mensaje. Por ejemplo, la validación
“request” tiene predeterminado el mensaje “El campo nombreatributo es
obligatorio, o la validación “max:10” tiene el mensaje predeterminado “solo se
permiten como máximo 10 caracteres”.
public function messages()
{
return[
'descripcion.required' => 'Nuevo Mensaje de error - campo
obligatorio'
];
}
Con este método va a recorres cada uno de los componentes del formulario buscando
en su propiedad name el valor de “descripcion” y una vez que encuentre el
componente validara el tipo de error, si el error es que el componente esta vació
(required) entonces sustituirá el mensaje de error predeterminado y mostrara el
mensaje personalizado: “Nuevo mensaje de error – campo obligatorio”
Llamar el archivo Form Request

Ya creado el archivo Request y sus validaciones, la llamada se trabajará en el archivo
controlador que tiene el método al que aplicaran las validaciones (en este ejemplo es el
archivo store del controlador “CursoController.php”). Para ellos vamos a realizar 2 pasos.
1. Hay que indicar (después del “namespace” del archivo) que vamos a usar el
archivo Request (para este ejemplo el archivo Request se llama “StoreCurso.php”)
de la siguiente manera:
use App\Http\Requests\StoreCurso;
2. En el método que aplicaremos las validaciones (en este ejemplo el método
“store()”) le cambiaremos el tipo de dato del parámetro por el tipo de la clase del
FormRequest (para este ejemplo “StoreCurso”). Al declarar que el parámetro es un
objeto del tipo de la clase Request (“StoreCurso”) su variable ($request) va
almacenar toda la información que mandemos desde el formulario y al mismo
tiempo hará las validaciones correspondientes definidas en el método rules() del
archivo Request (StoreCurso.php). En caso que la validación falle regresa un
mensaje de error y ya no se ejecuta la siguiente línea de código (“$curso = new
Curso();”), es decir detiene el flujo del código.
public function store(StoreCurso $request)
{

$curso->save();

}
20 – Asignación Masiva de registros a la base de datos

En capítulos anteriores explicamos que para poder guardar los datos de un formulario en
la Base de Datos en el método del controlador utilizado para guardar los registros se
aplicaba el siguiente código:
$curso->save();
Como podrá observar

1. Creamos una instancia de la clase modelo y se la asignamos a un variable.
2. A esta variable le vamos asignando registro por registro
3. Con el método “save()” se guardan los registros en la base de datos.
El problema con este procedimiento es que tenemos que declarar registro por registro del
formulario y asignarle su valor correspondiente. Esto puede ser más complejo ya que es
común tener 2 métodos que utilizan estos registros, el método utilizado para guardar
(store) la información en la base de datos y el método utilizado para editar (update) la
información de la base de datos.
Con la asignación masiva podremos simplificar lo anterior en una sola línea de código,
independientemente de cuantos registros sean.
Para poder realizar la asignación masiva se necesitan codificar 2 archivos.

1. El archivo controlador que contiene el método que realiza ya sea el store o update
de los registros en la base de datos.
2. El archivo modelo asignada a esa tabla de la base de datos.
Codificar el archivo Controlador.

En el archivo controlador, dentro del método que almacene (store) los registros en la base
de datos
1. Creamos una variable (por ejemplo “$curso”) pero en vez de asignarle una
instancia de la clase modelo, le asignamos el método “create()” que pertenece a la
case modelo de la siguiente manera.
$curso = curso::created([]);
Observe que el método es “create()” y no “created()”
2. Dentro del método “create() entre corchetes vamos a definir manualmente cada
una de las propiedades que deseemos se “tomen en cuenta” y sus valores
correspondientes
$curso = curso::create([
'nombre' => $request->nombre,
'descripcion' => $request->descripcion,
'categoria' = $request->categoria
]);
El código anterior realiza de manera interna
1. Crear una instancia del modelo (“$curso = new curso();”),
2. Asigna en cada propiedad su correspondiente valor (“$curso->nombre => $request
->nombre”) y
3. Ejecuta el método save() que es el encargado de guardar en la base de datos los
valores que se asignaron a cada propiedad. ($curso->save()”).
Como podrá observar este código aún tiene que definir cada una de las propiedades con la
que se llenara la base de datos y sería igual de tedioso llenar registro por registro y asignar
sus correspondientes valores
Abreviatura de código para asignación masiva

Para simplificar lo anterior podemos usar le método “all()” de la variable “$request”. Es
decir en vez que al método “create()” le pasemos como parametros un arreglo con las
propiedades que necesitamos, le podemos pasar el método “all()” de la variable $request
como se muestra a continuación:
$curso = curso::create($request->all());
Si recuerdan el método “all()” regresa un arreglo donde muestra todo lo que se estaba
enviando desde el formulario como se muestra en el siguiente ejemplo:
{"_token":"TadynjTEepN3erqHtHbsiBOL5mDS570UuCiTGhtb","nombre":"JavaScript
","descripcion":"Complemento para Css y HTML","categoria":"Programacion"}
Como podrá observar lo que regresa “all()” son las propiedades (en este ejemplo
“nombre”) con sus respectivos valores (en este ejemplo “JavaScript”), por lo que de
manera interna dentro del método “create()”, este código será el que sustituirá al código
siguiente:
'nombre' => $request->nombre,
'descripcion' => $request->descripcion,
'categoria' = $request->categoria
Entonces esta abreviación de código $curso = curso::create($request->all());

Lo que hace es; de manera interna:
1. Crear una instancia del objeto modelo (“$curso = new curso();”),
2. Asigna en cada propiedad su correspondiente valor (“$curso->nombre => $request
->nombre”), todos estas propiedades y sus valores son almacenadas en la variable
$curso. Cabe señalar que únicamente toma en cuenta las propiedades que son
similares a los campos de la tabla por lo que la propiedad token no se toma en
cuenta para la asignación.
3. ejecuta el método save() que es el encargado de guardar en la base de datos los
valores que se asignaron a cada propiedad. ($curso->save()”).
Importante: si ejecutamos el código sin haber configurado previamente el archivo modelo,

nos arrojara un error indicando que debemos agregar la propiedad fillable en archivo
modelo (el modelo relacionado con la tabla). En otras palabras, se necesita configurar el
archivo modelo para poder realizar la asignación masiva.
Codificar el archivo Modelo

Derivado que en el archivo controlador en el modo abreviado no tenemos declarado
explícitamente las propiedades a utilizar. Dentro del archivo modelo (archivo modelo
relacionado con la tabla donde guardarremos la información) debemos declarar una
propiedad con las siguientes características
 tipo protegido,
 llevará signo de pesos (como si fuera variable)
 y será le guardara un arreglo (es decir lleva corchetes)
Esta propiedad puede ser “fillable o “guarded”

 fillable, en esta propiedad se declaran entre corchetes, todas las propiedades que
serán “tomadas en cuenta” para la asignación de valores, es decir, aquellas
propiedades que no se encuentren dentro de esta lista serán ignoradas para la
asignación de valores y por consecuencia son las propiedades o campos ignorados
para guardarse en la base de datos.
protected $fillable = ['nombre', 'descripcion', 'categoria'];

En este ejemplo solo las propiedades ‘nombre’, ‘descripcion’, ‘categoria’, serán
únicamente los campos que se les asignaran valores y se guardaran en la base de datos
 guarded – Esta propiedad es el inverso de la propiedad “fillable”, es decir aquí se

enlistan las propiedades que deseamos sean ignoradas y todas aquellas
propiedades que no se encuentren en esta lista serán “tomadas en cuenta” para la
asignación de valores y posteriormente guardar en la base de datos.
protected $guarded =['status'];
En este ejemplo solo la propiedad ‘status’ se ignorará, por lo que no se le asignara ningún
valor y no se guardara en la base de datos (todas las demás propiedades si serán tomadas
en cuentan)
NOTA: Si a la propiedad “$guarded” la declaramos con un arreglo vacío (es decir no

enlistamos ninguna propiedad)
protected $guarded =[];
Recuerde que “$guarded” enlista las propiedades a ignorarse, por lo tanto, dejar la
propiedad “$guarded” vacío es otra forma de decirle a Laravel que tome en cuenta todas
las propiedades parar la asignación de valores. En otras palabras, dejar la propiedad
“$guarded” vacío de alguna manera le estamos diciendo a Laravel que no hay propiedades
que ignorar y por ende todas las propiedades deben tomarse en cuenta.
Actualización de registros utilizando la asignación masiva

Para actualizar un registro utilizando la asignación masiva se utiliza el método “update()”.
$curso->update($request->all());
 Donde la variable “$curso” es la variable del tipo de la clase Modelo. Esta variable
trae los datos origen de la base de datos con los que se rellenan los datos del
formulario antes de su edición.
 Se le pasa el parámetro “$request->all()” ya que este método regresa un arreglo
con las propiedades y sus respectivos valores que son las que se tendrá el
parámetro.
Para una idea más clara aquí el código completo del método que actualiza la información
en la base de datos (recuerde que este método está en el archivo controlador)
{
'nombre'=>'required',
'descripcion' => 'required',
'categoria'=>'required'
]);
$curso->update($request->all());

}
21 – Eliminar un registro de la base de datos

Al igual que se hizo en el CRUD (Create, Read, Update y Delete) en la base de datos. Para
eliminar un registro también debemos crear la ruta que se va a encargar de eliminar ese
registro.
Para eliminar un registro se deben de realizar 3 pasos generales.
1. En el archivo web.php, crear la ruta que se va a encargar de eliminar ese registro.
Al igual que hemos hecho con los procesos, leer, guardar y actualizar registros en
la base de datos, para eliminar un registro también debemos de crear su propia
ruta.
Route::delete('materiales/{material}',[MaterialeController::class,
'destroy'])->name('materiales.destroy');
2. En el archivo controlador, crear el método encargado de eliminar ese registro.
public function destroy(curso $curso)
{
$curso->delete();
}
3. En el archivo vista, crear el botón que permita eliminar el registro

<form action="materiales.destroy" method="POST">

<button type="submit">Eliminar Material</button>
</form>
4. Redireccionar al catalogo
{
$curso->delete();
return redirect()->route('cursos.index'); //redireccion a
cursos.index
}
Creación de la ruta para eliminar un registro (archivo web.php)

Como se había comentado para cada acción del CRUD ((Create, Read, Update y Delete) de
la base de datos, debemos crear su propia ruta. Por lo tanto, debemos crear la ruta que se
va a encargar de eliminar ese registro.
Para ello nos vamos en el archivo “web.php” y creamos la nueva ruta.

Route::post('cursos/{curso}', [CursoController::class, 'destroy'])-
>name('cursos.destroyer');
Analicemos el código:
 Después de la clase “Route” debemos definir el método por usar (get/post) - Vale
la pena comentar que el método “get” se utiliza normalmente para recuperar
datos y estos se envían dentro de la misma URL del navegador por lo que es visible
para el usuario. Por el contrario, el método “post” se utiliza para almacenar o
actualizar datos, estos datos se envían en el cuerpo del código por lo que van
ocultos para el usuario. El método “post” es recomendó para obtener datos de un
formulario.
Dicho lo anterior lo primero es analizar que va a hacer esta ruta. Esta ruta no va a
mostrar información y como no va a mostrar información, no podemos definir esta
ruta de tipo “get”. Esta ruta lo que va a hacer es procesar información, es decir
recibirá información y con ello decide que acción tomar (en este caso eliminar el
registro), por lo tanto, podríamos usar el método “post”.
Sin embargo, Laravel recomienda que cuando se vaya a eliminar un registro no se
utilice el método “post” si no el método “delete”. Esta recomendación es porque:
o Suponiendo que tengamos la siguiente ruta ‘cursos/{curso}’, esta misma
URL la podríamos tener también definidas en otras rutas (otras clases
Route()”). ¿Entonces como sabe Laravel a que ruta apuntar?, cuando
nosotros hacemos una solicitud le pasamos 2 puntos
 le pasamos la URL (por ejemplo ‘cursos/catalogo’)
 también le pasamos el método (“get”, “post”, “put”, “delete”, etc).
De esta manera tenemos URLs sin preocuparnos que habrá conflicto entre
ellas.
Route::delete('cursos/{curso}', [CursoController::class, 'destroyer'])-
>name('cursos.destroyer');
 Luego tenemos los parámetros

o Como primer parámetro tenemos que darle una URL identificativa y
también hay que indicar que le vamos a pasar información por la misma
URL a través de una variable llamada $curso.
o El segundo parámetro es asignarle esa ruta a un método llamado “destroy”
del controlador “cursoController”. Importante por convención se le llama
“destroy” al método utilizado para eliminar el registro.
 Como punto final creamos el alias a través del método “name()” asignado para
esta ruta la cual para este ejemplo es “cursos.destroy”.
Creación del método para eliminar un registro(archivo controller)

En el archivo controlador creamos un método llamado “destroy”. Este método tiene las
siguientes características
o Es un método publico
o Recibe un parámetro. Como recuerdan se definió la ruta para recibir una
variable en su URL (‘cursos/{curso}’). Debido a que a que se está enviando
información por la URL, esa variable también tenemos que pasarlo como
parámetro al método. Cabe señalar que para este ejemplo el valor de la
variable que pasaremos será la id en la base de datos del registro a
eliminar.
La variable será del tipo clase del modelo. Como recuerdan al definir desde
el parámetro la variable del tipo modelo esto permite ejecutar de manera
interna:
 Instanciar la clase modelo y guardarlo en la variable
 Ejecutar el método find() y guardar sus registro en la variable
Dentro de este método vamos a ejecutar otro método llamado “delete() del tipo modelo.
$curso->delete();
Así nos quedaría el código completo del método “destroy”

{
$curso->delete();
}
Creación del botón en el archivo vista para eliminar el registro.

Nos dirigimos al archivo vista que nos muestra el detalle del registro (en este ejemplo es
‘cursos.show’).
Abrimos el archivo show.blade.php y dentro del “section” del “body” HTML creamos un
formulario. Para incluir ese botón lo vamos a hacer dentro de un formulario. La razón que
el botón se está haciendo desde un formulario y no desde un enlace, es que cuando
nosotros ponemos una URL en un enlace este va a tratar de redirigirte a la URL pero
utilizando el método “get” y como nosotros definimos (en el archivo web.php) la ruta con
el método “delete”. Con el formulario es la única forma que podemos definir el tipo de
método a utilizar, en este caso el método “delete”.
Por ende definimos el formulario con los siguiente valores
o La propiedad action recibe una clase route con 2 parametros: la ruta y la
variable
o Definimos la propiedad “method” de tipo “post”. Recuerde que HTML solo
reconoce 2 tipos de métodos, “get” y “post”. Por ende, en el cuerpo del
formulario definimos una directiva blade method con valor “delete”
<form action="{{route('cursos.destroy' $curso)}}" method="POST">
o En el cuerpo del formulario definimos una segunda directiva blade @csrf
que nos permite generar el token del formulario. Recuerde que esta
directiva es indispensable al usar formularios ya que con ella valida que el
formulario se autoriza por parte de Laravel evitando así algún tipo de
ataque
o Dentro del cuerpo definimos el botón de tipo submit
<button type="submit">Eliminar</button>
El código completo del formulario seria:

<form action="{{route('cursos.destroy' $curso)}}" method="POST">
@method('delete')
@csrf
<button type="submit">Eliminar</button>
</form>
Redireccionar al catálogo una vez eliminado el registro

Una vez eliminado el registro nos debemos de redireccionar al catálogo de los registros.
Para ello en el archivo controller dentro del método que asignamos para eliminar el
registro (en este ejemplo llamado ‘destroy’ agregamos el siguiente código:
return redirect()->route('cursos.index');
donde la ruta ‘cursos.index’ es la ruta de la página catálogo.
21 – Agrupar rutas con Route Resource
Agrupar las rutas únicamente funciona si se han seguido las convenciones en los nombres
y alias. Con esto nos referimos por ejemplo que para almacenar un registro en la base de
datos se utilizo el nombre store o delete para eliminar un registro. Lo mismo para los alias,
poniendo el NombreURLidentificativa.NombreMetodo.
Normalmente en el archivo “web.php” tendremos más de 5 rutas por cada CRUD (create,
read, update y delete) realizado en nuestro proyecto. Con Route::resourse podemos
agrupar todas estas rutas en una sola línea de código (siempre y cuando se hayan seguido
las convenciones en los nombres asignados)
Listar todas las rutas en línea de comando

En el archivo web.php tenemos las siguientes rutas creadas
Route::get('cursos', [CursoController::class, 'index'])-

>name('cursos.index');
Route::get('cursos/create', [CursoController::class, 'create'])-

>name('cursos.create');
Route::post('cursos',[CursoController::class, 'store'])-
>name('cursos.store');
Route::get('cursos/{curso}', [CursoController::class, 'show'])-

>name('cursos.show');
Route::get('cursos/{curso}/edit', [CursoController::class, 'edit'])-

>name('cursos.edit');

Route::delete('cursos/{curso}', [CursoController::class, 'destroy'])-

>name('cursos.destroy');
En línea de comando podemos listar estas rutas de la siguiente manera:

1. Ingresamos a la línea de comando – Como recomendación usar una línea de
comando que no sea visual code ya que visualmente distorsionaría la tabla
dificultando su lectura. (en este proyecto usamos Git Bash).
2. Es importante estar dentro de la carpeta del proyecto de Laravel. Como por
ejemplo ‘C:\xampp\htdocs\salon’
3. Ejecutamos la instrucción “php artisan r:l” – esto significa php artisan rol:list-
Esto nos muestra una lista como la siguiente
En esta lista podemos observar las siguientes columnas:

 Columna Method- Esta es la columna que nos indica que método está usando cada
ruta ruta (get, post, delete, put)
 Columna URI – nos muestra la ruta “real”, la URL identificativa
 Columna Name – Este es el alias asignado a cada ruta, es decir el alias con la que
vamos a identificar cada una de las rutas.
 Columna Action – Nos muestra cual es el nombre de los métodos utilizados en el
archivo controlador para cada una de las rutas.
Por ejemplo en el archivo web.php tenemos la ruta
La cual nos dice:
 Su método es “put”
 Su URI es “curso/{curso}”
 El método en el controlador se llama “update”
 Su alias es “curso.update”
Esto lo podemos ver en línea de comando encerrado en un recuadro amarillo
Para esto nos sirve enlistas las rutas en línea de comandos ya que al abreviar (agrupar)
todas las rutas en una sola línea de comando podemos ver cual es su alias, el método que
se utiliza en el archivo controlador y su ruta “identificativa”.
Abreviando rutas con el método Route Resource

Para definir las rutas escribimos el siguiente código
Route::resource('urlidentificativa','controladorqueAdministraEstaURL');
Donde el parámetro ‘urlIdentificativa es el URLque identifica a todas las demás URL. Si

observa el archivo web.php que se listo en este capitulo podrá ver que en este ejemplo la
URL identificativa es ‘cursos’
El parámetro ‘controladorQueAdministraEstaURL’ es el nombre de la clase del controlador
asignada a esta ruta, para este ejemplo es “CursoController::class”. Nota es solo el
controlador y no el nombre de algún método como se hacia anteriormente.
El código quedaría de la siguiente manera:

Route::resource('cursos',CursoController::class);
Ahora vamos a listar las rutas en linea de código
Como podrá observar la lista de rutas en ambas tablas es exactamente lo mismo. La

primera tabla es un listado de las rutas sin aplicar la abreviación, es decir:
La segunda tabla es listando las rutas pero usando una sola línea de código
Es importante señalar que el método Route resource solo le pasamos como parámetro la
URL significativa y como segundo parámetro la clase del controlador.
 De manera interna Laravel ha creado las 7 rutas significativas que se encargaran de
administrar el CRUD (créate, read, update y delete).
 Además, este método (Route resource ) ha determinado que las rutas que
necesitan un variable, el nombre de la variable sería el singular del URL
identificativa. 'cursos/{curso}'
 También ha identificado que el alias empezarían con el nombre de la ruta
identificativa.nombreAccion, por ejemplo para guardar un registro en la base de
datos el alias seria 'cursos.store', cursos.edit – para la acción de editar un
registro, cursos.show para la acción de mostrar un registro, etc.
 Lo mismo para los nombres de los métodos donde se realizan las acciones del
CRUD en el archivo controlador.
Es por esto por lo que es super importante seguir las convenciones que nos da Laravel (al
momento de ir creando las rutas, alias para las rutas y métodos en el controlador) y con
ello podemos abreviar las rutas y escribir mucho menos líneas de código.
Cambiar las URL que se crean con el método Resource

Cambiar las URL no afectaría el proyecto si estamos apuntando a estas URL por el alias y
no directamente por la URL de lo contrario hacer esta modificación debemos de también
cambiar en el proyecto las áreas donde hacen referencia a estas URL, es por esto la
importancia de usar alias y no las URL directamente.
Por ejemplo, en el siguiente código

El método Resource crea las siguientes URL

 “cursos/create” para la página del formulario
 ‘cursos/{curso}/edit para la página que editar el contenido.
Pero nosotros queremos que se cambie por la URL las palabras “create” por “crear” y
“edit” por “editar”. Quedando la ruta
 “cursos/crear”
 “cursos/{cursos}/editar
Para esto entramos a la documentación de Laravel y buscamos “controller” y entramos a

la primera opción y luego con control + f (para buscar en el navegador) buscamos
“resourceVerbs” (queremos buscar “#Localizing Resource URIs”)
Con el método “resourceVerbs()” debemos enlistar un arreglo con todos los URIs que
deseamos modificar.
Para ello poder realizar este cambio localizamos y abrimos el archivo
“AppServiceProvider.php” ubicado en la carpeta del proyecto “app/Providers/”.
En este archivo vamos a realizar dos pasos:
1. Definir que vamos a usar la clase “Route”.
use Illuminate\Support\Facades\Route;
2. Dentro del método “boot()” definimos otro método Route::resourceVerbs() con las
palabras y sus respectivas sustituciones, quedando el código completo del método
“boot()” de la siguiente manera:
{
//
// Paginator::useBootstrap();
Route::resourceVerbs([
'create' => 'crear',
'edit' => 'editar',
]);
}
Si volvemos a correr en línea de comando la instrucción “php artisan r:l” nos mostrará la
lista de rutas con los cambios realizados.
Cambiar el nombre de la URL identificativa

Como podrá ver en la lista de rutas nuestra URL identificativa es “cursos”. Pero y si
queremos que en vez de cursos ahora diga “materias”, debemos considerar lo siguiente:
Una posible solución es: en la pagina web.php en el método

Cambiamos en el primer parámetro ‘cursos’ por ‘materias’

Route::resource(‘materias’,CursoController::class);
Hacer esto implicaría que también se cambien el alias y por ende fallaría toda la aplicación
(enlistamos todas las rutas para que se aprecie lo anterior)
La posible solución es cambiar manualmente en todo el proyecto donde hace referencia

los alias, pero por obvias razones esto ni es practico ni tampoco la solución.
Para lograr que el método “Route::resource()” solo cambie el URL sin mover el alias le
agregamos el método “names(‘URLsustituto’)”.
Route::resource(‘materiales’,CursoController::class)->names(‘cursos’);
Con este método le estamos indicando que para las rutas utilice la palabra “materiales” y
que para el alias utilice la palabra “cursos”. Es decir con el método ‘names(‘nombreAlias)”
le indicamos cual será el nombre del alias.
Para tener una mejor perspectiva listamos nuevamente la lista de rutas en línea de
comando
Otro posible error que nos sale es que también se cambia el nombre de las variables.
Antes teníamos $curso y ahora tendríamos $materia
Cambiar el nombre de las variables utilizadas en el URL

Como recordaran definir el método de la siguiente manera
Route::resource(‘materiales’,CursoController::class)->names(‘cursos’);
En caso de tener variables dentro de la misma URL, Laravel la creará como singular de la
URL identificativa que hayamos pasado como primer parámetro en el método
“resource()”. Es decir, usara como URL identificativa “materias” y como variable
“materia”, por lo tanto la URL seria de la siguiente manera:
“materias/{materia}/editar”
siendo {materia} la variable en el URL.
Con el método “ parameters([ArregloParámetro])” le indicarle a Laravel que nombre se

usaría para las variables.
Como parámetro le pasamos un arreglo listando el nombre de la URL identificativa y el

nombre por el que quiero el nombre de las variables ['materias’ => ‘cursos’].
El código completo quedaría de la siguiente forma

Route::resource('materias',CursoController::class)->
parameters(['materias'=>'curso'])->names('cursos');
Esto cambiaria el nombre de las variables por el de curso como se muestra a continuación
en el listado de rutas en línea de comandos.
23 – Como generar URLs amigables.
Como podrá observar en nuestro proyecto las URLs que hemos generado no son muy
descriptivas, Por ejemplo, cuando pasamos la IP por el URL para obtener un registro,
generamos una dirección similar a la siguiente
http://localhost/salon/public/materiales/55
Lo importante de un sitio que no describe mucho su contenido puede ser perjudicial para
los buscadores y por consecuencia ser más difícil aparecer en la búsqueda de resultados
de los buscadores de manera organiza (las búsquedas orgánicas con aquellas que no son
de paga). Los motores de búsqueda “recompensan” aquellos sitios web que son claros y
descriptivos para el usuario final. Por se recomienda que en vezde tener una URL
http://localhost/salon/public/materiales/55 tengamos una URL asi
http://localhost/salon/public/materiales/Laptop-Gamer-Acer
Para esto se necesita

1. Agregar una nueva columna a la tabla en la base de datos
2. Para efectos de prueba rellenar el nuevo campo modificando el archivo Factory.
3. Pasar el nuevo valor en el URL
Agregar una nueva columna a la tabla en la base de datos

Se va a crear una nueva columna en la tabla (en nuestro ejemplo es la tabla cursos). Para
esto hay dos maneras de hacerlo:
1. Creando un nuevo archivo “migrate” que únicamente agregue este nuevo campo,
2. Modificando el archivo que utilizamos para crear la tabla (en nuestro ejemplo “…
create_cursos_table.php”.
Tanto en el procedimiento 1 como en el procedimiento 2 vamos a crear un nuevo campo

con las siguientes características:
 Tipo “string”
 El nombre será “slug”
$table->string('slug');
Solo recuerde que en el procedimiento 2 debeos agregar el método after(‘nombreCampo’)

para posicionar el nuevo campo, de lo contrario este se agregara al final de todos los
campos.
$table->string('slug')->after('nombre');
Modificar el archivo Factory

Para rellenar el nuevo campo con registros “de prueba”, debemos modificar el archivo
factory, por ende, abrimos nuestro archivo factory (por supuesto nos referimos al archivo
factory relacionado con la tabla a la que le acabamos de agregar el nuevo campo – en
nuestro ejemplo es “CursoFactory.php”). – ). Este archivo se encuentra en la ruta del
proyecto “database/factories”.
Nota recuerde que la definición pudiera estar en el archivo factory o en un archivo seeder
(“CursoSeeder.php”).
Usando los Helper de Laravel

Lo que queremos lograr en este llenado es que el slug tenga lo mismo que el nombre del
curso separado por guiones. Es decir si el curso se llama “Laravel desde cero” el slug
quedaría: “Laravel-desde-cero”.
Esto lo logramos con un “helper” de Laravel (así lo encontramos en la documentación de
Laravel “helper”).
Los helper son funciones (métodos) globales PHP. En esta pagina podemos encontrar toda
la lista de funciones helper que podemos utilizar
https://laravel.com/docs/9.x/helpers#main-content
Para poder tomar el campo nombre y sustituir los espacios en blanco por guiones
necesitamos el helper “Str::slug()”.
Este método slug(‘cadenaATrabajar’,’caracterSustituto’) recibe 2 parametros
1. El string con el que se trabajara, es decir al cual se le sustituirán los espacios en
blanco
2. El carácter que sustituirá los espacios en blanco
Cabe señalar que el slug regresa la cadena en minúsculas.
Para poder utilizar el método slug necesitamos definir que vamos a utilizarlo con un
El código quedaría de la siguiente manera


{
$nombre = $this->faker->sentence(3);
return [
'nombre' => $nombre,
'slug' => Str::slug($nombre,'-'),
'descripcion' => $this->faker->paragraph(),
'categoria' => $this->faker-
>randomElement(['principiante','intermedio','avanzado'])
//
];
}
Si observamos el código podremos ver que fuera del “return” hemos guardado en una
variable (“$nombre”) el enunciado (cada enunciado será de 3 palabras). Esto se hizo de
esta manera para que lo que tenga la viable $nombre se le asigne tanto al campo
‘nombre’ como al campo ‘slug’. De otra manera tendríamos un enunciado para el campo
nombre y otro enunciado para el campo ‘slug’ y lo que nosotros queremos es que tanto el
nombre como el slug tengan los mismo.
Corremos el factory para generar los datos de prueba en la base de datos. Recuerde que
para correr el factory necesitamos 2 puntos
1. En el archivo base Seed (DatabaseSeeder.php) agregar el código
2. Ejecutar en línea de comando “php artisan db:seed”
Cambiar el valor de la variable que pasamos en el URL.

Como recordaran en el URL pasamos el valor de la variable, en ella pasamos el ID
http://localhost/salon/public/materiales/55
Obteniendo el Id del registro es que podemos conseguir los registros en la base de datos
que corresponden a ese ID
Analicemos el siguiente código:

Si recuerdan en la vista (index.blade.php – esta vista muestra la lista de cursos) tenemos el
siguiente código HTML
<a href="{{route('cursos.show',$item->id)}}">{{ $item->nombre }}</a>
Este código nos dice que la propiedad “href” nos vamos a dirigirnos al alias “cursos.show”
y vamos a pasar un valor $item. El valor del $item es el id en la base de datos.
Dando como resultado un URL de la siguiente manera:
http://localhost/salon/public/cursos/9
Es importante señalar que si a la variable $item->id le quitamos el “->id” dejando solo
$item, pasara igualmente solo el numero del id. Esto es posible ya que Laravel pasa el
primer registro de la tabla siempre y cuando cumpla los siguientes requisitos: sea un
campo id, autonumérico y sea “Primarykey”. En otras palabras, pasara el valor del id si el
primer campo de la tabla cumple con los estándares para ser un campo ID, de lo contrario
se tiene que especificar el campo (por ejemplo, “$item->nombre”).
Como mencionamos anteriormente la propiedad “href” nos va a dirigir al alias
“cursos.show”, para saber que acción realiza esta ruta, en el archivo controlador,
buscamos el método show (buscamos el alias en el archivo web.php y nos dirigimos a su
método del alias) y veremos el siguiente código
public function show(curso $curso)
{
}
podremos observar que este método recibe un parámetro que es donde va a recibir el ID
que envío el archivo view. Si analizan el código podrán observar que el parámetro tiene
una
variable (“$curso”) de tipo “curso”, es decir del tipo de la clase del modelo.
Definir el tipo de la clase del modelo nos permite abreviar código. Con esto Laravel
entiende que quiero que la variable “$curso” sea una instancia de la clase curso Modelo
cuyo id (del registro a recuperar) sea lo que estemos mandando por el parámetro. De esta
manera escribiríamos menos código.
Es decir, este código
public function store($curso)
{
$curso= curso::find($curso);
return $curso;
}
Regresa lo mismo que este código
public function store(curso $curso)
{
return $curso;
}
Esto es posible por el método “RouteKeyName()”, método que pertenece a la clase

principal “model”. Es decir, como la clase “curso” es una clase que se extiendo de una
clase padre llamada “model”, por consecuencia la clase “curso” tiene acceso a los
métodos que tiene la clase padre “model”.
El código por default de este método
public function getRouteKeyName()
{
return $this->getKeyName();
}
Este código es el responsable que el método store(curso $curso) regrese el id de una

tabla, por lo que si sobrescribimos el método cambiando el return por el siguiente código
{
return 'slug';
}
Este código nos regresara el valor de la columna slug y al mismo tiempo nos regresara los
valores faltantes de las otras columnas que correspondan a ese registro. Es decir, se
comportaría como si fuera el valor id y obtendría los registros de ese id, solo que ahora
estaría mandando el valor de la columna slug.
Es importante señalar que es una mala práctica sobrescribir el método “original” que
viene por defecto en el framework, por lo que para poder sobre escribirlo se hace desde el
archivo modelo como se muestra a continuación
class curso extends Model
{
use HasFactory;

{
return 'slug';
}
}
Resumiendo, para crear URL´s que sean más descriptivas debemos tener un campo en la
tabla con nombre slug y posteriormente sobre escribir el método getRouteKeyName() en
el archivo modelo. Con esto el método del controlador en vez de buscar el id y buscar el
registro de ese Id, buscara el slug y el registro perteneciente a ese slug. Por lo que la URL
mostrará el contenido del slug y no el id. Esto con la finalidad que los motores de
búsqueda nos puedan posicionar de manera orgánica.
24 – Agregar navegabilidad a nuestro sitio web

En este capítulo vamos a agregar navegación a nuestro proyecto. Esto quiere decir que
agregaremos enlaces que nos permitan desplazarnos a diferentes páginas del proyecto,
como por ejemplo de la página catalogo desplazarnos a la página formulario “creación de
cursos”.
De manera general podemos decir que realizaremos los siguientes pasos:
 Agregar el código HTML para crear la navegación
 Crear y agregar las rutas para esta navegación, así como los archivos vistas.
 Crear un enfoque (focus) en el enlace activo; es decir, señalar en que “botón” está
activo.
Agregar el código HTML para crear la navegación.

Crear el menú de navegación.
Para esto abrimos la plantilla general (en nuestro proyecto es “plantilla.blade.php”, esta
es la plantilla que las demás vistas usan de base) y
 Dentro del tag <body> ponemos un tag <header>
 Dentro del <header> ponemos 2 tags
o Un <h1> Curso de Laravel</h1>
o y un <nav>
 Dentro del <nav> abriremos una lista y ahí pondremos las opciones del menú en
forma de enlaces (con el tag <a href>)
<body>
<header>
<h1>Curso de Laravel</h1>
<nav>
<ul>
<li><a href="">Home</a></li>
<li><a href="">Cursos</a></li>
<li><a href="">Nosotros</a></li>
</ul>
</nav>
</header>
@yield('content')
</body>
Esto nos genera una pagina vista como la siguiente
Crear y agregar las rutas para la navegación

Nos vamos al archivo de rutas “web.php” y al archivo de ruta (que es el URL principal)
Le vamos a poner el alias “home”, como se muestra a continuación
Route::get('/', HomeController::class)->name('home');
Ahora en el archivo vista plantilla general en la lista de navegación que acabamos de crear
vamos a poner sus respectivos enlaces.
o route(‘home’) para Home
o route(‘cursos.index’) para Cursos
o route(‘nosotros’) para nosotros. Este ultimo no hemos creado ni su ruta ni
su archivo vista, por lo que si corremos la aplicación nos generara un
error. El siguiente paso es crear su ruta y su archivo vista.
<body>
<header>
<nav>
<ul>
<li><a href="{{route('home')}}">Home</a></li>
<li><a href="{{route('cursos.index')}}">Cursos</a></li>
<li><a href="{{route('nosotros')}}">Nosotros</a></li>
</ul>
</nav>
</header>
@yield('content')
</body>
Ahora nos dirigimos al archivo “web.php” para crear la ruta ‘nosotros’. Con el método
view
Route::view('URL','ArchivoView')->name('alias');
Este método “view()” solo lo vamos a utilizar cuando queremos mostrar contenido
estático, es decir que no nos vamos a conectar con nuestra base de datos. Simplemente
queremos mostrar una vista.
Este archivo lo vamos a configurar de la siguiente manera
Route::view('nosotros','nosotros')->name('nosoteos');
Esto quiere decir
o El valor del la URL es ‘nosotros’ (parámetro 1)
o El nombre del archivo vista será ‘nosotros’ (parámetros 2 – el nombre
completo del archivo vista es “nosotros.blade.php”)
o Y su alias será ‘nosotros’ (método “name()”)
Creación de la vista
Para esto vamos a la carpeta view y desde esa carpeta creamos el archivo
“nosotros.blade.php”. dentro de este archivo pondremos el siguiente código
@section('title', 'Pagina Nosotros')
@section('content')
<h1>Bienvenido a la página Nosotros (index) desde el view con plantilla
usando blade</h1>
@endsection
Este código solo es provisional ya que mas adelante vamos a modificarlo.
Activar el Focus para el enlace activo

En este punto lo que vamos a realizar es que en el enlace que nos encontremos en ese
momento resalte para dar la sensación de que es el enlace activo.
Para esto tenemos que hacer que Laravel entienda en que ruta nos encontramos.
Para ellos vamos a ir a la página vista platilla general (en esta pagina fue donde creamos
los enlaces de navegación) en cada una de las lista anexamos código php de la siguiente
manera
<li><a href="{{route('home')}}">Home</a>
<?php
dump(request()->routeIs('home'));
?>
</li>
El método routeIs() va a verificar si no encontramos en la ruta ‘home’ y de ser así regresa

un “true” de lo contrario regresa un “false”.
El método “dump()” es un helper de Laravel, lo que hace es imprimir el valor de una
variable o en este caso imprime el valor de lo que regresa “request()->routeId(‘home’)”
Como podrán ver en la imagen imprime el valor de “true” ya que en este momento la
página se encuentra en el URL home (está en la raíz del o página principal).
Ahora en vez de incrustar código PHP dentro del código HTML podemos usar la directiva
de Blade @dump() y el resultado sería exactamente lo mismo
<li><a href="{{route('home')}}">Home</a>
@dump(request()->routeIs('home'))
</li>
Entonces con esta directiva de Blade @dump(request()->routeIs('home')) podemos
identificar en que ruta nos encontramos.
Identificar la ruta nos sirve para saber si nos regresa un valor falso o verdadero, por
consiguiente, si nos regresa un valor verdadero buscamos que se aplique una clase
especifica (la clase ‘active’), de lo contrario que la clase este vacía.
Esto lo haríamos dentro del siguiente código HTML
<li><a href="{{route('home')}}" class="{{aqui se aplica el if}}">Home</a>
En vez de usar un if para saber si regresa un valor verdadero o false usaremos una
condicional utilizando operadores ternarios
 Primero llamamos a la función request()->routeIs('home')
 Después de la función ponemos el signo de interrogación (al poner un signo de
interrogación es como si todo el código lo hubiéramos puesto dentro de un if)
request()->routeIs('home') ?
Luego del signo de interrogación va lo que quiero que imprima en caso que regrese
verdadero request()->routeIs('home') ? ‘active’
 Al final poner 2 puntos para indicar que imprimiría en caso de que sea falso (como
el else). Para este ejemplo lo dejamos vacio por que no queremos que se imprima
nada request()->routeIs('home') ? ‘active’ : ’’
Por lo tanto, el código completo para la clase seria
<a href="{{route('home')}}" class="{{request()->routeIs('home') ? 'active' :
''}}">Home</a>
Modificamos el código de los otros enlaces y el código completo seria:

<body>
<header>
<nav>
<ul>
<li><a href="{{route('home')}}" class="{{request()-
>routeIs('home') ? 'active' : ''}}">Home</a></li>
<li><a href="{{route('cursos.index')}}" class="{{request()-
>routeIs('cursos.index') ? 'active' : ''}}">Cursos</a></li>
<li><a href="{{route('nosotros')}}" class="{{request()-
>routeIs('nosotros') ? 'active' : ''}}">Nosotros</a></li>
</ul>
</nav>
</header>
@yield('content')
</body>
IMPORTANTE: No basta con agregar la clase=’active’, debemos crearla y definirla. Para ello
dentro del tag <head> agregamos el tag <style></style> y entonces definimos la clase
“active” como sigue:
<style>
.active{
color:green;
font-weight: bold;
}
</style>
Y entonces ahora si nos aparecerá en verde el enlace activo, activando un focus en el

enlace que nos encontramos actualmente.
El problema que surge es que si damos clic en cualquiera enlace del catalogo (por ejemplo
“QUIA MAJORES MODI BEATAE”) o nos vamos a crear un nuevo curso, aunque nos
encontremos en la sección de cursos el enlace se desactiva ya que actualmente solo esta
codificado para una sola ruta (“cursos.index”)
Para resolver esto sustituimos la ruta “cursos.index” por “cursos.*”.
>routeIs('cursos.*') ? 'active' : ''}}">Cursos</a></li>
Al poner asterisco en la ruta es un comodín. Con este comodín le indicamos que sustituya
el asterisco por lo cualquier etiqueta, basta que la ruta empiece con “cursos.” entonces lo
tome como verdadero.
Con esto podremos estar en la ruta “cursos.edit” o “cursos.create” o “cursos.show” y
siempre mostrarse activo ya que solo toma en cuenta “cursos.”
Crear plantillas head y footer (usando Blade)

Como podemos ver en el proyecto insertamos el código del header dentro de la misma
platilla base, sin embargo, para tener un proyecto mucho mas organizado podemos
separar estos archivos plantillas.
La idea es crear estos archivos como plantillas y luego en la plantilla base
(plantilla.blade.php) insertarlos.
Para esto vamos a crear primero el archivo plantilla para el header
1. Dentro de la carpeta “layouts” de nuestro proyecto crear otra carpeta llamada
“partials”
2. Dentro de esta carpeta creamos un archivo llamado “header.blade.php”. dentro de
este archivo pondremos todo lo que está dentro de los tags <header> en el archivo
plantilla base.
<header>
<nav>
<ul>
<li><a href="{{route('home')}}" class="{{request()-
>routeIs('home') ? 'active' : ''}}">Home</a></li>
>routeIs('cursos.index') ? 'active' : ''}}">Cursos</a></li>
<li><a href="{{route('nosotros')}}" class="{{request()-
>routeIs('nosotros') ? 'active' : ''}}">Nosotros</a></li>
</ul>
</nav>
</header>
Para llamar a la plantilla header dentro de la plantilla base lo hacemos a través de una
directiva de Blade llamada “@include(‘rutaArchivoVistaHeader’)”
@include('layouts.partials.header')
Recuerden que la búsqueda de los archivos view los hace desde la carpeta view del
proyecto la cual toma como si fuera la raíz de la ruta.
Para crear la plantilla footer hacemos exactamente lo mismo
1. Creamos el archivo footer.blade.php dentro de la carpeta “partials”
2. Al archivo footer.blade.php le ponemos un código de prueba solo que aquí hay que
usar los Tags <footer></footer>
<footer>
<small>Esto es el pie de pagina</small>
</footer>
3. Llamar la plantilla footer en la plantilla base

El código completo de la plantilla base seria
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>@yield('title')</title>
<style>
.active{
color:green;
font-weight: bold;
}
</style>
</head>
<body>
@include('layouts.partials.header')
@yield('content')
@include('layouts.partials.footer')
</body>
</html>
Como podrá observar de esta manera mantenemos mas “limpia” la plantilla base.
25 – Como enviar emails con Laravel

Para envió de correos electrónicos desde nuestro proyecto, Laravel trabaja con el
protocolo SMTP y controladores basados en API´s.
El servicio de correo de Gmail utiliza el protocolo de SMTP, por lo que podrías utilizar tu
cuenta de Gmail para poder enviar correos electrónicos desde tu proyecto Laravel.
Algunos proveedores que trabajan con controladores basados en API´s de correo
electrónico son Mailgun, Postmark, Amazon SE y sendmail. Laravel ya viene pre-
configurado para trabajar con estos controladores sin embargo se pueden usar otros
proveedores que se basen en API´s solo que habría que realizar configuraciones
adicionales.
La documentación de la Laravel nos dice que “Los controladores basados en API, como
Mailgun y Postmark, suelen ser más sencillos y rápidos que los servidores SMTP. Si es
posible, debe utilizar uno de estos controladore
Nota: Todos los controladores de API requieren la biblioteca HTTP Guzzle, que se puede
instalar a través del administrador de paquetes Composer:
composer require guzzlehttp/guzzle
se requieren varios pasos para poder enviar un email
1. Configuración del proveedor de email en el proyecto
2. Configurar los datos del remitente
3. Creación del archivo Mailable para poder enviar el email
4. Creación del a ruta que será el disparador del email.
Configuración del email en el proyecto
Configuración del proveedor.
En el archivo “mail.php” (en la carpeta “config” de nuestro proyecto) es donde
encontramos toda la configuración que necesitamos para poder enviar correos
electrónicos desde Laravel.
El primer código que vamos a encontrar es el siguiente,
'default' => env('MAIL_MAILER', 'smtp'),
Este código nos dice que lo primero que tenemos que definir es si vamos a conectar a un
proveedor basado en SMTP o API´s y nos dice que esa información deberíamos definirlo
en una variable llamada “MAIL_MAILER” y colocarlo dentro del archivo “.env” (este
archivo e encuentra en la raíz del proyecto). En el caso no coloque esta variable (no exista)
dentro del archivo “.env”, entonces tomara como conexión predeterminada el protocolo
‘SMTP’
Lo siguiente es buscar esa variable en el archivo “.env” la cual encontraremos las

siguientes variable y sus valores
MAIL_MAILER=smtp
MAIL_HOST=mailhog
MAIL_PORT=1025
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS=null
MAIL_FROM_NAME="${APP_NAME}"
Como podemos observar la variable MAIL_MAILER tiene valor SMTP lo que quiere decir
que utilizara el protocolo SMTP para envío de emails.
Para este proyecto vamos a utilizar un proveedor basado en SMTP.

Regresando al archivo “mail.php” podremos encontrar que el siguiente código sería
'smtp' => [
'transport' => 'smtp',
'host' => env('MAIL_HOST', 'smtp.mailgun.org'),
'port' => env('MAIL_PORT', 587),
'encryption' => env('MAIL_ENCRYPTION', 'tls'),
'username' => env('MAIL_USERNAME'),
'password' => env('MAIL_PASSWORD'),
'timeout' => null,
'auth_mode' => null,
],
Podemos observar que las credenciales que debemos de pasar es el

 host con variable MAIL_HOST
 port con variable MAIL_PORT
 encryption con variable MAIL_ENCRYPTION
 username con variable MAIL_USERNAME
 password con variable MAIL_PASSWORD
Todas las variables anteriores se encuentran dentro del archivo “.env”, por lo que
regresamos al archivo “.env” para poder configurarlo con los valores correctos.
Para efectos de este proyecto vamos a utilizar mailtrap como proveedor. Mailtrap es un
servidor “falso” que utiliza el protocolo SMTP para que los desarrolladores realicen
pruebas, vean el diseño del email y compartan emails desde su proyecto en desarrollo sin
realizar spam. En otras palabras, mailtrap no envía los emails a sus destinatarios. Mailtrap
intercepta ese email y te lo muestra en su la propia bandeja de entrada de mailtrap tal
cual le llegaría al destinatario. Por su puesto que cuando el proyecto pase a producción
habría que configurar estos datos con otro proveedor de correos electrónicos.
Para poder conectarnos con mailtrap debemos de tener una cuenta, de lo contrario
tendríamos que registrarnos
Una vez que ingresamos podemos ver la siguiente ventana de bienvenida
En esta ventana podemos ver que tenemos un correo electrónico en la bandeja de

entrada. Este email es la documentación para configurar Mailtrap en nuestro proyecto.
Como podemos ver la configuración que nos ofrece para Laravel es
MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=15be5fcdb57818
MAIL_PASSWORD=2bddb463c011e1
MAIL_ENCRYPTION=tls
Ahora en el archivo “.env” debemos buscar estas variables y sustituir sus valores por los
que el archivo Mailtrap nos proporciona.
Nota: en el caso de las variables MAIL_USERNAME y MAIL_USERPASSWORD asegúrate de
no llevarte espacios en blanco antes y después de los caracteres.
La variable MAIL_ENCRYPTION es opcional
En el archivo “.env” así quedaría el código

MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=15be5fcdb57818
MAIL_PASSWORD=2bddb463c011e1
MAIL_ENCRYPTION=tls
Configurar la información del remitente

Siempre que nosotros enviamos un correo electrónico este debe de llegar con la
información de quien lo envía y su correo electrónico y hasta el asunto (subject).
Por ejemplo, como remitente podríamos poner el nombre de tu pagina web y el correo
electrónico de tu empresa.
Dentro del archivo “.env” podemos encontrar el siguiente código

'from' => [
'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
'name' => env('MAIL_FROM_NAME', 'Example'),
],
Este código nos dice que las variables MAIL_FROM_ADDRESS y MAIL_FROM_NAME
tendrán el email y nombre respectivamente de quien lo envía. Como las variables
anteriores, estas se configuran en el archivo “.env”
Crear archivo Mailable para enviar correo electrónico

Una vez configurado el proveedor de email y los datos del remitente, el siguiente paso es
crear un archivo “mailable”.
La creación de este archivo se hace desde la línea de comandos con la instrucción
php artisan make:mail ContactanosMailable
Nota: por nombre llevaría el nombre que identifique el motivo de ese email(por ejemplo
contactarnos) con la terminación Mailable.
Esto me va a generar una nueva carpeta llamada “Mail” dentro de la carpeta “app” y
dentro de la carpeta “Mail” me habrá creado un archivo “ContactanosMailable.php”.
El código completo del archivo “ContactanoMailable.php” es el siguiente:
<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;
class ContactanosMailable extends Mailable

{
use Queueable, SerializesModels;
/**
* Create a new message instance.
*
* @return void
*/
public function __construct()
{
//
}
/**
* Build the message.
*
* @return $this
*/
public function build()
{
return $this->view('view.name');
}
}
En este archivo es donde puedo personalizar lo que va a ir dentro del correo electrónico.
Por ejemplo, para definir el asunto de un correo electrónico se crea una propiedad pública
llamada “subject” dentro de la clase “ContactanosMailable”
class ContactanosMailable extends Mailable

{
use Queueable, SerializesModels;
public $subject='Email De prueba';
... //código
...//código
}
Es importante señalar que es sumamente importante escribir correctamente $subject ya
que si por error nos faltara una letra el asunto que escribimos no se enviaría y en su lugar
se enviaría como asunto “contáctanos Mailable” (que es el nombre de nuestro archivo
Mailable).
Nota: todas las propiedades que aquí definamos estas son como variables globales que
pueden pasarse al archivo vista.
Ahora para definir el cuerpo del email, este se realiza dentro del método build(). Por
default la definición de este método regresa un archivo vista.
{
return $this->view('view.name');
}
Con esto queremos resaltar el cuerpo del correo electrónico se construirá dentro de un
archivo vista con formato HTML.
Para ello, dentro de la carpeta view vamos a crear otra carpeta llamada “emails” y dentro
de esta carpeta crearemos el archivo vista “contactanos.blade.php” con lo cual la ruta
quedaría “emails.contactanos” como se muestra a continuación:

{
return $this->view('emails.contactanos');
}
El archivo vista “contactanos.blade.php” lo vamos a definir con formato HTML y dentro
del tag <body> es donde debemos escribir el contenido del correo electrónico.
El siguiente código es una propuesta del archivo “contactanos.blade.php” para efectos de
prueba
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<h1>Correo Electrónico</h1>
<p>Este es el primer correo electrónico que mandaré por Laravel</p>
</body>
</html>
Como podrán ver dentro del body tenemos las etiquetas <h1> y <p> las cuales tienen
como titulo “Correo Electrónio” y de párrafo “Este es el primer correo electrónico que
mandaré por Laravel”.
Creando el disparador para enviar el correo electrónico

Crearemos una nueva ruta en el archivo “web.php” el cual servirá como disparador para
enviar el correo electrónico. Es decir, cuando el usuario ingrese al URL
‘cursos/contáctanos’ se enviará el correo electrónico.
Primero en el archivo “web.php” vamos a importar 2 clases

use App\Mail\ContactanosMailable;
use Illuminate\Support\Facades\Mail;
luego creamos la ruta de la siguiente manera

Route::get('contáctanos', function () {

});
La ruta se define de este modo ya que vamos a ingresarle código

1. primero vamos a crear una variable llamada “$correo” y le voy a decir que sea una
instancia de la clase ContactanosMailable
$correo = new ContactanosMailable;
2. luego voy a llamar a la clase Mail (la clase que importamos) y voy a acceder al
método “to()”. Dentro de este método “to()” tengo que definir el email al que se lo
voy a enviar y al final le paso un método que es el método send(). Dentro de este
método send() le pasare la variable que tiene la instancia de
“ContactanosMailable”.
Mail::to('jacgms@hotmail.com')->send($correo);
Al final le retornamos un mensaje indicando que el email fue enviado, de lo contrario la

página se quedaría en blanco lo que pudiera confundir al usuario.
El código completo de la ruta seria

return "Mensaje enviado";
});
Si ingresamos a la ruta contáctanos (por ejemplo en mi proyecto la ruta seria

http://localhost/salon/public/contactanos) y automáticamente el email se enviaría.
Recordemos que al estar utilizando mailtrap no llego al destinatario si no que lo envio a la
cuenta de mailtrap, por lo que para verlo tendríamos que ingresar a la cuenta de mailtrap
y en la bandeja de entrada podríamos verlo exactamente como le hubiera llegado al email
destinatario.
Agregar diseño al cuerpo del email

Al ser una pagina web (archivo view) el cuerpo del email, podemos agregarle estilos CSS
para darle un diseño más personalizado
Por ejemplo, podemos decir que el titulo tengan un color azul. Para esto agregamos un tag
<style> y dentro definimos el color del tag h1
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<style>
h1{
color:blue;
}
</style>
</head>
<body>
</body>
</html>
Y con ello enviaríamos un email con el titulo de correo electrónico en azul
Y de esta manera es que podrías personalizar tus emails tanto como desees
26 – Como crear un formulario de contacto

Como primer paso a nuestro menú de navegación le vamos a agregar un enlace más. Este
enlace llevará por nombre contáctanos que cuando le demos clic lo que va a hacer es
redirigirnos a una vista que nos va a amostrar un formulario. La idea es que en ese
formulario el usuario podrá poner su nombre, su email y un mensaje que nos quiera
enviar. Nosotros tomaremos esa información y la enviaremos a un correo electrónico. (es
importante haber tomado el capitulo 25 donde se explica como configurar Laravel para
poder enviar correos electrónicos).
Creando el enlace contáctanos en el archivo vista

Como recordaran en el capitulo anterior creamos una plantilla para el header. Abrimos
esta plantilla. En nuestro proyecto se llama “header.blade.php” y esta en la ruta
“view/layouts/partials”
Dentro de ese archivo le agregamos una etiqueta <li> y dentro de la etiqueta <li> otra
etiqueta anchor <a href=””> la cual llevara por nombre “Contáctanos”.
<li><a href=""></a>Contáctanos</li>
Si recuerdan en el archivo “web.php” creamos una ruta que será el disparador (trigger)
que enviara el email, esta ruta es “contáctanos”. Lo que vamos a hacer es ponerle un alias
y con ello el código quedará de la siguiente manera:
})->name('contactanos.index');
Regresando al archivo plantilla “header.blade.php” le agregamos la ruta al enlace

“contáctanos” como se muestra a continuación
<li><a href="{{route('contactanos.index')}}"></a>Contactanos</li>
Configurar la ruta “contactanos” y creación de su controlador

Si observan el archivo web.php, ruta contactanos. Esta Ruta es un disparador que cuando
ingresen a esta ruta enviara el correo electrónico. Pero nosotros necesitamos que cuando
ingresen a la ruta contactanos nos mande a una vista que tenga un formulario de
contacto.
Para cambiar esto lo primero que vamos a realizar es crear un controlador para que se
encargue de administrar la ruta “contactanos”. Entonces en línea de comando escribimos
la siguiente instrucción:
php artisan make:controller ContactanosController
Esto nos creara el archivo “ContactanosController.php” (este archivo esta en la ruta

app/Http/Controllers” con el siguiente contenido:
<?php
class ContactanosController extends Controller

{
//
}
Dentro de la clase “ContactanosController” le vamos a crear dos métodos

 index() – este método es el encargado de mostrarnos el formulario (con el método
view llamar una vista)
 store() – este método es el encargado de procesar la información y enviar el correo
electrónico.
{
{
}
public function store()
{

}
}
Regresamos al archivo “web.php” y cortamos el siguiente código

y se lo pegamos al archivo controlador “ContactanosController”. Esto es por que vamos a
necesitar incluir estas clases para el código que vamos a meter en el método “store()”.
Repetimos la misma operación, regresamos al archivo “web.php” y ahora cortamos el

siguiente código que se encuentra dentro de la ruta “contactanos”
Este código lo pegamos en el archivo controlador “ContactanosController” dentro del

método store() quedando de la siguiente manera
public function store()
{
}
En el archivo “web.php” codificamos la ruta “contactanos” para que pase de esto…

Route::get('contactanos', function () {

})->name('contactanos.index');
A esto, ya que necesitamos indicarle a la ruta cuál será su controlador

Route::get('contactanos', [ContactanosController::class, 'index'])->name
('contactanos.index');
Nota: al agregar el controlador se debio agregar de manera automática el siguiente código

use App\Http\Controllers\ContactanosController;
En caso de que no se haya agregado, se debe anexar el código anterior para incluir la clase
del controlador.
En el archivo controlador en el método “index()” le vamos a pedir que nos retorne una
vista. Este archivo vista va a estar dentro de una carpeta llamada contactanos y se va a
llamar index
{
return view('contatanos.index');
}
Creación del formulario en el archivo vista

Una vez definido el método “index()” del controlador, el siguiente paso es crear esa vista.
Si recuerdan tenemos la ruta “contactanos.index”, por lo que debemos crear la carpeta
“contactanos” en la raíz de la carpeta “view” de nuestro proyecto y dentro de
“contactanos” el archivo “index.blade.php”
El código que por el momento le vamos a poner al archivo “index.blade.php” será el

siguiente:
@section('title', 'Contactanos')
@section('content')
<h1>Dejanos un mensaje</h1>
@endsection
En esta vista lo que deseamos es mostrar un formulario, donde el usuario pueda poner su
nombre, su correo electrónico y un mensaje que desee enviar.
Por lo que debajo de la etiqueta <h1> y antes de “@endsection” escribimos el siguiente
código
<form action="{{route('contactanos.store')}}" method="POST">
@csrf
<label>
Nombre:
<br>
</label>
<br>
<label>
Correo Electrónico:
<br>
<input type="text" name="email">
</label>
<br>
<label>
Mensaje:
<br>
<textarea name="mensaje" rows="5"></textarea>
</label>
<br>
<button type="submit">Enviar mensaje</button>
</form>
Guardamos y revisamos (nos debe desplegar una página web similar a la siguiente)
En la etiqueta <form> hay que destacar 2 putos

 El método es de tipo “POST”, recuerde que cuando mandamos información de un
formulario es altamente remendable hacerlo por el método “POST” ya que este
envía la información de manera oculta para el usuario. Por lo mismo la ruta (del
archivo web.php) que se encargara de procesar esta vista tendrá que ser
igualmente de tipo “POST” (Route::post(…//);
 La directiva @csfr. Como se explicó en capítulos anteriores, esta directiva lo que
hace es generar un token para este formulario y de esta manera validar la
autenticidad del formulario. Generar este toquen es obligatorio para los
formularios ya que omitirlo no permitirá procesar el formulario y desplegara una
página con la leyenda “page expired”.
Activación del enlace de navegación (focus)
Para esto nos dirigimos al archivo plantilla header (en la ruta
view/layouts/partials/header.blade.php y a la etiqueta <a href> le anexamos su propiedad
class con el siguiente código
class="{{request()->routeIs('contactanos.index') ? 'active' : ''
En vez de usar un if para saber si regresa un valor verdadero o false usaremos una
condicional utilizando operadores ternarios
 Primero llamamos a la función request()->routeIs('contactanos.index')
 Después de la función ponemos el signo de interrogación (al poner un signo de
interrogación es como si todo el código lo hubiéramos puesto dentro de un if)
request()->routeIs('contactanos.index') ?
Luego del signo de interrogación va lo que quiero que imprima en caso que regrese
verdadero request()->routeIs('contactanos.index') ? ‘active’
 Al final poner 2 puntos para indicar que imprimiría en caso de que sea falso (como
el else). Para este ejemplo lo dejamos vació por que no queremos que se imprima
nada request()->routeIs('contactanos.index') ? ‘active’ : ’’
<li><a href="{{route('contactanos.index')}}" class="{{request()-

>routeIs('contactanos.index') ? 'active' : ''}}">Contactanos</a></li>
Creación y configuración de ruta – segunda parte

Ya que tenemos la vista con el formulario, debemos crear una ruta que se encargue de
procesar la información de ese formulario.
Esa ruta será de
 tipo “post”,
 su URL será “contactanos”,
 El método encargado de procesar esa información será el método “store()” del
controlador “ContactanosController”.
 El alias será “contactanos.store”
Para esto nos vamos al archivo web.php y cumpliendo con los puntos anteriores
escribimos el siguiente código
Route::post('contactanos',[ContactanosController::class, 'store'])-
>name('contactanos.store');
Hasta este punto si le damos clic al botón “enviar” del formulario nos enviara el correo
electrónico que podemos revisar en la bandeja de Mailtrap (en el capítulo anterior se
explicó como configurar en Laravel el correo electrónico y que es Mailtrap y su
funcionamiento).
Pasar los datos del formulario al cuerpo del correo electrónico.

Antes de explicar cómo le vamos a pasar información del formulario a nuestros correos
electrónicos, deseo explicar el siguiente comportamiento.
En el archivo “Mailable” (“ContactanosMailable.php”) le agrego una nueva propiedad de
tipo publica
public $contacto ='Esto es una prueba';
Cualquier propiedad que incluyamos en el archivo “Mailable” (En nuestro ejemplo el
archivo “ContactanosMailble” dentro de la clase) podrá ser accedida desde el archivo view
que tiene el cuerpo del correo.
Recuerde que el cuerpo del email se definió en un archivo vista (que en nuestro ejemplo
se llama “emails.contactanos” – email es el nombre de la carpeta donde esta y
contactanos es el nombre del archivo – la vista se llama desde el archivo “Mailable” por el
método “build()”.
{
return $this->view('emails.contactanos');
}
Entonces si entramos al archivo vista podremos acceder e imprimir el contenido que tenga
la propiedad que definimos en el archivo “Mailable”. En este ejemplo el contenido de la
propiedad se imprimirá como párrafo después de “Este es el primer correo electrónico
que mandare por Laravel” en el cuerpo del email.
<body>
<p>
{{$contacto}}
</p>
</body>
Como se mencionó el valor de la propiedad se imprimirá en el cuerpo del correo

electrónico
Teniendo claro lo anterior, la forma que tenemos para pasar la información a nuestro
correo electrónico es la siguiente.
Recuperar la información del formulario en una variable
Vamos al archivo controlador “ContactanoController” en el método “store()” le agrego
como parámetro la variable $request como tipo Request.
{
.....
}
Dentro de este mismo método donde se está creando la instancia de la clase Mailable, le
voy a pasar información al constructor a través de la variable $request y ejecutando a su
método “all()”.
$correo = new ContactanosMailable($request->all());
El código completo del archivo controlador “ContactanoController.php” quedaría de la

siguiente forma (pong especial atención al método “store()”:
<?php

{
{
return view('contactanos.index');
}

{
}
}
Como le estoy mandando información al constructor (“ $correo = new

ContactanosMailable($request->all()); ”), esto lo tengo que recibir en el método
“_construct()” a través de un parámetro (El método “_construct()” está en el archivo
“Mailable” – creado por default al crear el archivo, en nuestro ejemplo el archivo se llama
“contactanosMailable” ), es decir al método “_construct()” le tenemos que definir un
parámetro que es donde recibirá los datos que me envía el archivo controlador al crear la
instancia.
Por lo que la definición del método “_construct()” quedaría de la siguiente manera.
public function __construct($contact)
{

}
Si recuerdan en este mismo archivo Mailable, se había creado una propiedad de tipo
publico llamado $contacto.
Entonces a esta propiedad le vamos a asignar el valor que trae el parámetro que recibe el
método “_construct()”. Observe que la propiedad se definede tipo publica y con signo de
pesos. Pero al definirla dentro del método “_construct()”, se utiliza $this y no lleva signo
de pesos el nombre de la propiedad.
$this->contacto = $contact
Los siguiente es el archivo completo del método “_construct():

public function __construct($contact)
{
$this->contacto = $contact
}
Aun no podemos hacer una prueba enviando el mail ya que en el archivo view tenemos el
siguiente código
{{$Contacto}}
En blade este es un similar a un echo de PHP, es decir imprimir, por lo que espera un
string y nosotros estamos enviando un arreglo.
Por lo que nos arrojaría el siguiente error.
htmlspecialchars() expects parameter 1 to be string,
array given
Configurar el archivo view para recibir los datos del formulario.

En el archivo view que es el cuerpo del email (en nuestro ejemplo
“contactanos.blade.php”) vamos a escribir el siguiente código
<p><strong>Nombre:</strong>{{$contacto['name']}}</p>
<p><strong>Correo:</strong>{{$contacto['correo']}}</p>
<p><strong>Mensaje:</strong>{{$contacto['mensaje']}}</p>
Este código lo vamos a poner dentro de la etiqueta <body> y si observan la variable

$contacto lleva entre corchetes el nombre del componente del formulario. Esto es porque
los valores guardados en $contacto es un arreglo.
Si enviamos el email (ingresando a la ruta que dispara el email) nos llegaría un email ya
con los datos que se escribieron en el formulario
Validar la información que se enviara desde el formulario.

Este proceso se divide en 2 etapas
 Definir cuáles serán las validaciones a verificar, Esto en el método que dispara el
email (en este caso el método store() del archivo controlador)
 Codificar el archivo view parra desplegar el mensaje de error.
Definir las validaciones (archivo controlador)

Las validaciones se realizan a través del método “validate()” de la variable $request”.
Este método se define dentro del método que dispara o activa el enviar el correo. En este
caso es el método “store()” del archivo controlador. Dentro del método “store()” la
ejecución del método “validate()” debe ser el primer código a ejecutarse ya que si una de
las validaciones fallara, se detiene el flujo de ejecución y redirecciona al mensaje de error
en el archivo vista.
Entonces en el archivo controlador, dentro del método “store()” escribimos el siguiente

código.
'correo' => 'required|email',
'mensaje' => 'required',
]);
El archivo completo del método “store()” sería

{
'correo' => 'required|email',
'mensaje' => 'required',
]);

}
Definir los mensajes error (archivo vista del formulario)

En el archivo vista del formulario (en este ejemplo “index.blade.php”) después de cada
componente debemos de definir la directiva de blade “@error” imprimimos el posible
error que se almacena en la variable “$message”.
@error('name')
<p><strong>{{$message}}</strong></p>
@enderror
(en este ejemplo “name” es el nombre del componente input)
Redireccionamiento de página al tener éxito el envío de email.

Lo que buscamos es que cuando nosotros enviemos con éxito un correo electrónico nos
retorne a la vista index.blade.php (el archivo vista que tiene el formulario) y nos aparezca
una alerta que nos diga mensaje enviado.
Para esto lo primero es que vamos al controlador (archivo “ContactanosController”) y

dentro del método “store()” sustituimos el “return“
por el siguiente código (este route me va a redireccionar a contactanos.index y además
nos va a crear un mensaje de sesión.
return redirect()->route('contactanos.index')->with('info','Mensaje
Enviado');
a este return le vamos a agregar un mensaje de sesión, para esto le pasamos el método
“with()” y a este método debemos de pasarle dos parámetros
 El primer parámetro será el nombre de nuestra variable de sesión, podemos
ponerle por ejemplo “info”.
 El segundo parámetro será el mensaje que deseamos enviar, por ejemplo “email
enviado”.
Ahora el archivo vista vamos a codificarla para imprimir una alerta, pero esa alerta solo
quiero que se mande si es que hay un mensaje de sesión y esto lo vamos a lograr con un if
y dentro del if voy a preguntar si existe una variable de sesión. Esto se logra con el método
“sesión()” y como parámetro voy a preguntar si existe la variable “info”.
@if (session('info'))

@endif
Entonces si existe la variable “info” quiero que imprimas una alerta, y lo que se va a
imprimir es lo que trae la variable de sesión “info”
<script>
alert("{{session('info')}}")
</script>
@endif
El código completo del archivo index.blade.php quedaría de la siguiente manera

@section('title', 'Contactanos')
@section('content')
<h1>Dejanos un mensaje</h1>
<form action="{{route('contactanos.store')}}" method="POST">
@csrf
<label>
Nombre:
<br>
</label>
@error('name')
@enderror
<br>
<label>
Correo Electrónico:
<br>
<input type="text" name="correo">
</label>
@error('correo')
@enderror
<br>
<label>
Mensaje:
<br>
<textarea name="mensaje" rows="5"></textarea>
</label>
@error('mensaje')
@enderror
<br>
<button type="submit">Enviar mensaje</button>
</form>
<script>
alert("{{session('info')}}")
</script>
@endif
@endsection
27 – Kits de inicio: Laravel Breeze y Laravel Jestream

Estos son kits o paquetes enfocados en registrar a un usuario, login, reset password, etc.
La diferencia entre Breeze y Jestream es que por decirlo de alguna manera “Breeze”
cumple con las necesidades básicas para un registro y autentificación de un usuario,
mientras que Jestream proporciona muchas más funciones que van más allá del registro y
autentificación del usuario.
En ambos casos será necesario realizar la instalación de estos kits a nuestro proyecto de
Laravel.
Estos kits arman automáticamente tu proyecto con las rutas, controladores y vistas que se
necesita para registrar y autentificar a los usuarios en tu sistema.
Creando nuevo proyecto Laravel

Podemos para modo de prueba iniciar un nuevo proyecto Laravel
Abrimos una ventana de línea de comandos (fuera de visual code) como por ejemplo “Git
Bash” y nos dirigimos a la carpeta de xampp/htdocs
Para dirigirnos directamente a esa carpeta podemos escribir la siguiente instrucción
cd /c/xampp/htdocs
Creamos el nuevo proyecto Laravel llamado breeze (en minúsculas todo el nombre del
proyecto) como se muestra a continuación:
Creado el nuevo proyecto de Laravel lo abrimos en el visual Code
Configuración de la base de datos

Abrimos el archivo .env (ubicado en la raíz del proyecto) y en la variable DB_DATABASE
ponemos el nombre de la base de datos a trabajar, en este caso la base de datos se llama
breeze
DB_DATABASE=breeze
En caso de que aún no se haya creado la base de datos en PHPMyAdmin debemos de

crearla (recuerde con el nombre la base de datos debe llevar por nombre breeze).
Que es Breeze
Breeze es una implementación mínima y simple de todas las funciones de autentificación
de Laravel, incluido el inicio de sesión, el registro, el restablecimiento de contraseña, la
verificación de correo electrónico y la confirmación de la contraseña.
Breeze trabaja con Blade para sus vistas y Tailwind
Instalando Breeze
Primero, debe crear una nueva aplicación Laravel , configurar su base de datos y
ejecutar las migraciones de su base de datos. Una vez que haya creado una nueva
aplicación Laravel, puede instalar Laravel Breeze usando Composer:
Primero vamos a instalar los paquetes de Breeze usando Composer. Para esto en la línea
de comandos de visual code escribimos la siguiente instrucción
composer require laravel/breeze --dev
Para la versión Laravel 8 se tiene que ejecutar con el siguiente comando

composer require laravel/breeze:1.9.2
Lo anterior únicamente instala el paquete de “breeze” pero no crea las vistas,

controladores, las rutas y otros recursos que se necesitan para la autentificación. Para
esto para esto hay que instalar el paquete en el proyecto ejecutando el siguiente
comando
php artisan breeze:install
Esto me va a crear unos archivos en mi proyecto como, por ejemplo

 postcss.config.js ubicado en la raíz del proyecto
 tailwind.config.js ubicado en la raíz del proyecto – todas las vistas que va a agregar
Breeze lo ha diseñado con tailwind y para lo cual ha instalado tailwind dentro de
nuestro proyecto.
 Ha creado una carpeta auth con varias vistas ubicado en la carpeta view
 Ha creado la carpeta components y dentro varios archivos ubicado en la carpeta
view
 Ha creado 2 plantillas app.blade.php y guest.blade.php ubicados en la carpeta
layouts, estas son las plantillas que usaran las vistas ubicadas en la carpeta auth.
 Archivos migreate para crear tablas en la base de datos.
El siguiente paso es ejecutar el comando migrate en línea de comando para crear las
tablas necesarias para la autentificación (recuerde que previo a ejecutarse la instrucción
debimos haber ya creado la base de datos y configurado el archivo .env)
php artisan migrate
Una vez creadas las tablas en la base de datos el siguiente paso es ejecutar la instrucción
npm install
npm son las siglas de “node package manager”, básicamente es el mejorador de paquetes
de javascript, es decir nos permite instalar paquetes que se ejecutan del lado del cliente
(frondend).
NOTA: es importante que antes de ejecutar npm install se haya instalado “node.js”
https://nodejs.org/en/
Por último, vamos a ejecutar

npm run dev
Esta instrucción lo que hace es ejecutar una tarea npm llamada dev y se suele usar para
levantar servidores de desarrollo locales Vite. Es decir, creara un nuevo servidor de Vite y
a partir de ese servidor de se van a compilar todos los estilos que aparezcan en mi sitio
web y yo voy a poder previsualizarlos en el browser.
Esto nos creó un servidor vite
Ahora tengo que crear un servidor de php (esta es una opción, podemos usar localhost) y
así poder trabajar con una URL. En línea de comando de visual code ejecutamos la
siguiente instrucción
php artisan serve
Hasta este punto Breeze ya es funcional, el registro de usuario y autentificación.
Para la versión 8. En caso de que no se vea correctamente el estilo en las plantillas

app.blade.php y guest.blade.php (ambas ubicadas en la carpeta “layouts”) comentar
código
@vite(['resources/css/app.css', 'resources/js/app.js'])
Y agregar el siguiente código
<link rel="stylesheet" href="{{ asset('css/app.css') }}">
<script src="{{ asset('js/app.js') }}" defer></script>
Y ya podrá ver una página web como la siguiente
Si deseamos habilitar el reset para olvido de contraseña es necesario configurar el

proyecto para poder enviar un correo electrónico. En capítulos anteriores se explicó como
configurar Laravel para poder enviar un correo a través de un proveedor.
En conclusión, para usar el paquete Breeze debemos prácticamente correr las siguientes
instrucciones en ese orden y ya podríamos utilizar la autentificación y registro de usuarios
en nuestro proyecto.
php artisan migrate

composer require laravel/breeze --dev
php artisan breeze:install

php artisan migrate
npm install
npm run dev
Importante que si al dar clic al login o registro no se muestra un correcto diseño (digamos
sale el logo desproporcionado) buscar las plantillas app.blade.php y guest.blade.php
(ambas ubicadas en la carpeta “layouts”) comentar código
Y agregar el siguiente código
<link rel="stylesheet" href="{{ asset('css/app.css') }}">
<script src="{{ asset('js/app.js') }}" defer></script>
Que es Jetstream
Breeze proporciona un simple y mínimo punto de partida para registros y autentificación
de usuarios, Jetstream aumenta esa funcionalidad con características más robustas y
stacks adicionales de tecnología frontend. Para aquellos que son nuevos en Laravel, se
recomienda aprender bien Breeze antes de Jetstream.
Jetstream proporciona un kit de módulos que incluye inicio de sesión, registro de usuarios,
verificación de correo electrónico, autentificación de dos factores, administración de la
sesión, soporte de APIs a través de Laravel Sanctum y administración de equipos (teams)
de trabajo (opcional). Jetstream está diseñado con Tailwind y si o si en su instalación
tenemos que escoger trabajar ya sea con Livewire o inertia.
Para este ejemplo antes de la instalación se realizaron los siguientes pasos:

 Creación de un nuevo proyecto Laravel llamado Jetstream
 Creación de la base de datos con nombre Jetstream
 Configuración de Laravel para conectarse a la base de datos
 Configuración de Laravel para envío de correo electrónico.
Instalación de Jetstream
Lo primero que hay que saber es que JetStream tiene conflicto con Laravel 8. Esto
principalmente se debe a que JetStream trabajo con la directiva vite pero la directiva vire
trabaja a partir de Laravel 9. Laravel 8 en vez de trabajar con la directiva vite trabaja con la
directiva mix. Se estuvo investigando en internet y algunas personas comentan que
“Jetstream not working with Laravel 8”. Sin embargo es ALTAMENTE recomendado que
revise la documentación de Laravel en el apartado “Starter Kits”.
Por lo tanto, se recomienda que si usara JetStream sea con laravel 9. Dicho lo anterior, la
siguiente explicación está enfocada en Laravel 9
Hay dos maneras de instalar JetStream

1. Instalando desde que se crea el proyecto
2. Instalando de manera manual
Para instalar desde que se crea el proyecto escribimos la siguiente instrucción desde la
línea de comando (desde la carpeta de su servidor local)
"laravel new proyecto --jet"
Este código procederá a crear el proyecto y posteriormente continuará con la instalación
de JetStream
Para instalar jetStream de manera manual:
Lo primero es instalar el paquete en línea de comando de visual code con el siguiente
comando:
composer require laravel/jetstream
El siguiente paso es instalar Jetstream ya sea con Livewire o Inertia

 Para instalar Jetstream con Livewire usamos la siguiente instrucción en línea de
comando de visual code. Se puede instalar de 2 formas, el primer comando es para
una instalación normal, y la segunda es para permitir equipos de trabajo.
php artisan jetstream:install livewire
php artisan jetstream:install livewire --teams
 Instalando Jetstream con Inertia usamos la siguiente instrucción en línea de

comando de visual code. Se puede instalar de 2 formas, el primer comando es para
una instalación normal, y la segunda es para permitir equipos de trabajo.
php artisan jetstream:install inertia
php artisan jetstream:install inertia –teams
La diferencia entre Livewire e Inertia es que si por ejemplo estas trabajando con Livewire y
estas familiarizado con Blade se te hará muy sencillo el funcionamiento de Livewire. Por el
otro lado trabajar con Inertia tienes que estar familiarizado con algún framework de
JavaScript por ejemplo “vue.js”.
Para este proyecto vamos a realizar la instalación con Livewire
Después de instalar Jetstream debemos instalar y crear sus dependencias NPM y ejecutar
la migración, es decir debe de ejecutar los siguientes códigos en ese orden.
npm install
npm run build
php artisan migrate
una vez instalado jetstream la primera diferencia que podremos observar será que una
vez registrado e ingresado el usuario, este tendrá una opción (que no tiene Breeze) para
poder ver el perfil del usuario llamada “profile”.
Importante: En modo local para efectos de prueba es importante que escriba este
comando en línea de código (visual code)
php artisan serve
Esto habilitara un servidor virtual de php (como si la página estuviera en el hosting) y
poder probar las funciones por ejemplo cambiar el nombre, email, cambiar el avatar del
usuario, etc.
Si intenta probar la página con localhost ningún cambio se registrará en la base de datos
(no se conecta con ella para los update) si puede registrar nuevos usuarios solamente.
Por ende, se recomienda que preferentemente cree un servidor “php artisan serve”.
Personalización de las funciones de JetStream (avatar, términos y condiciones)

Habilitar el avatar del usuario
Para esto tendremos que abrir el archivo de configuración de JetStream. Este se encuentra
en la carpeta “config” del proyecto. El nombre del archivo es “jetstream.php”.
Dentro de este archivo buscamos el apartado ‘features’

'features' => [
// Features::termsAndPrivacyPolicy(),
// Features::profilePhotos(),
// Features::api(),
// Features::teams(['invitations' => true]),
Features::accountDeletion(),
],
podremos ver por ejemplo que si queremos habilitar se muestre el “avatar” del usuario
registrado. Solo des comentamos “Feature::profilePhotos(),”
'features' => [
// Features::termsAndPrivacyPolicy(),
Features::profilePhotos(),
// Features::api(),
],
Esto nos mostrara esta imagen donde en vez del nombre se muestra el avatar del usuario
Como nota importante es que si habilitamos que se vea el avatar del usuario y este no se
ve (como se muestra en la imagen)…
Esto se debe a 2 problemas

1. La ruta del sitio actualmente al montar el servidor php es http://127.0.0.1:8000/
pero la configuración del archivo .env en el apartado
APP_URL=http://localhost
Apunta a localhost por lo que hay que configurarlo para que apunte al 127.0.0.1:8000 (no
lleva barra diagonal al final)
APP_URL=http://127.0.0.1:8000
Nota es importante tener servidor php activo (En línea de comando ejecutar “php artisan
serve”)
2. La ruta donde se almacena físicamente el archivo. En el archivo de configuración
de jetStream (jetstream.php), al final no indica donde se guardan las imágenes
'profile_photo_disk' => 'public',
Quiere decir que la imagen actualmente se encuentra en la carpeta public pero de la

carpeta storage y no en la raíz del proyecto. Es decir, la carpeta actualmente se encuentra
en la ruta
C:\xampp_8\htdocs\jetstream\storage\app\public\profile-photos
Pero se requiere que este en la carpeta public raíz del proyecto
C:\xampp_8\htdocs\jetstream\public
Entonces lo que tenemos que hacer para que el proyecto pueda acceder a la imagen es
crear un acceso directo de la carpeta “profile-photo” pero dentro de la carpeta public
Crear acceso directo de carpetas dentro de carpeta Public

La única carpeta que tiene acceso el proyecto es la carpeta public de la raíz del proyecto
C:\xampp_8\htdocs\jetstream\public
Por lo tanto si tenemos alguna imagen u otro recurso en otra carpeta, para tener acceso a
ella debemos crear un acceso directo de ese recurso dentro de la carpeta public.
Esto se logra en línea de comando con el siguiente código
php artisan storage:link
Configurar el almacenamiento de archivos

Como una observación adicional en el archivo .env en la sección
FILESYSTEM_DISK=local
Debería de cambiarse a public
FILESYSTEM_DISK=public
Esto es porque actualmente solo las imágenes de perfil están subiéndose a la carpeta
public, pero más adelante cuando necesitemos otros recurso (como archivos, pdf, etc)
también se suban a esta misma carpeta
Habilitar términos y condiciones

Para habilitar los términos y condiciones nos vamos al archivo de configuración de
jetstream y descomentamos “termAndPrivacyPolicy()” como se muestra en la imagen
'features' => [
Features::termsAndPrivacyPolicy(),
Features::profilePhotos(),
// Features::api(),
],
Esto habitara en la página de registro el checkbox para aceptar los términos y condiciones
Solo aceptando las políticas podrá registrarse el usuario.
Para modificar el contenido de las políticas y condiciones, esto se encuentra en la raíz del
proyecto, en la carpeta resource/markdown. Ahí encontraremos lo archivos policy.md y
terms.md, lo que escribamos dentro de estos archivos es lo que se mostrara en las
políticas y condiciones respectivamente.
Habilitar trabajar con equipo de personad

Si deseamos trabajar con equipos de personas (teams) no basta con des comentar el
código
También hay que realizar la instalación

php artisan jetstream:install livewire --teams
Alpine
Como resumen podemos decir que tanto JetStream como Breeze instalan Tailwind pero
adicionalmente ambos kits instalar “alpine”.
Alpine es una librería de JavaScript que nos permite agregar interactividad en nuestro sitio
web
Si vemos el archivo “app.js” (carpeta “resource/js”) podemos ver el siguiente código:

import './bootstrap';
import Alpine from 'alpinejs';
window.Alpine = Alpine;
Alpine.start();
Podemos ver que se está importando Alpine y además se está inicializando Alpine
(“window.Alpine = Alpine” y “Alpine.star()”).
Cuando hemos ejecutado la instrucción “npm run build” lo que hemos hecho es crear un
manifiesto que básicamente es compilar todos los archivos
Y toda esa compilación lo coloca dentro de la carpeta “public/build/assets” en 2 archivos
uno para css (terminación .css) y otro para javascript (.js),
Estos archivos (tanto css como js) son archivos minimizados como se muestra a
continuación
Actualmente nuestro alpine se encuentra incorporado dentro del archivo .js (en algún
lugar de todo ese código) y lo mismo para el tailwind, este se encuentra en algún lado del
archivo Css (archivo terminación .css)
Estos archivos se incorporan dentro de nuestras paginas porque cada página tiene las
siguientes directivas



@livewireStyles
@livewireScripts
Por ejemplo, la directiva @vite y las rutas estamos incorporando los assets minimizados
(los que se encuentran en la ruta (public/build/assets)
Con la directiva @livewireStyle incorporamos los estilos de livewire y para incorporar los
scripts de livewire usamos la directiva @livewireScripts
Entonces cada que deseemos incorporar esas tecnologías ya sea alpine, tailwind o livewire
se deben incorporar esas directivas. Por lo tanto, para evitar declararlas en cada pagina
podemos crear una vista plantilla y meter ahí todas esas directivas y solo invocarlos en las
páginas donde queremos ocuparlos.
Usar Bootstrap con JetStream (metodo1)

Este método me da errores, pero lo ponemos como referencia
De manera predeterminada JetStream utiliza Tailwind para sus diseños CSS. Sin embargo,
también se puede configurar el proyecto para que JetStream funcione con BootStrap.
Este procedimiento lo que hace es reemplazar de laravel los archivos que trabajan con
tailwind (por ejemplo, el archivo “tailwind.config.js”) por los archivos que trabajan con
Bootstrap.
Dicho lo anterior hay que recalcar que si configuramos JetStream para que trabaje con
BootStrap en vez de tailwind también tenemos que configurar que la paginación trabaje
con Bootstrap (la paginación es cuando en una tabla se muestra en una página web con
varios registros y estos registros por su volumen se divide en varias páginas). Cabe
mencionar que Laravel 8 de forma predeterminada trabaja con Tailwind.
Este ejercicio se basada en previamente haber

 creado un nuevo proyecto con Laravel 9 (proyecto desde cero),
 instalado jetstream
 Crear una nueva base de datos
 Configurar el proyecto de Laravel para que se conecte a esa base de datos.
instalación en Laravel 8
Como primer paso vamos a buscar en Google la palabra “jetstrap” el cual nos redirige a la
página del repositorio
https://github.com/nascent-africa/jetstrap
Nos dirigimos a la sección Install Jetstrap y copiamos el siguiente comando para ejecutarlo
en línea de comandos de visual code de nuestro proyecto, esto va a iniciar la instalación
del paquete
composer require nascent-africa/jetstrap --dev
La siguiente instrucción que hay que instalar en línea de comando es

php artisan jetstrap:swap livewire
en caso de que queramos instalar con inertia sustituimos la palabra livewire por inertia.
Esta instrucción lo que hace es sustituir en el proyecto todos los archivos que pertenecían
a livewire e instala todos los archivos necesarios para trabajar con Bootstrap (por ejemplo
en la carpeta resource/sass/_variables.scss encontramos el archivo _variables.scss que on
las variables de configuración de Bootstrap)
(opcional) Si tenemos instalado JetStream para trabajar con equipo de personas (teams)
utilizar
php artisan jetstrap:swap livewire --teams
Para finalizar la instalación debemos correr las siguientes instrucciones en ese orden
npm install
npm run dev
php artisan migrate
Listo ya solo queda correr el servidor de php (php artisan serve) y probar Jetstream
trabajando con Bootstrap
Usar Bootstrap con JetStream (metodo2 -correcto-) Laravel 9
Este método es tomado de youtube Como instalar Bootstrap 5 en Laravel 9 con Jetstream
y Vite js, "PROCEDIMIENTO CORRECTO"
https://www.youtube.com/watch?v=tdJ3-gUQxSU&t=16s
Se debe haber creado ya el proyecto (laravel 9) e instalado jetstream con todo y base de
datos ya funcional
Lo primero es instalar bootstrap 5 en nuestro proyecto (en la carpeta de nuestro

proyecto) escribimos
Esto instala bootstrap 5 y a remover tailwind
composer require nascent-africa/jetstrap --dev
El siguiente código es (si usaste inercia sustituye livewire por inercia)

php artisan jetstrap:swap livewire
Ahora abrimos el proyecto en visual code. Abrimos los archivos que necesitamos
configurar (carpeta resource/views/layouts) son los archivos app.blade.app y
guest.blade.php
-- En el archivo guest.blade.php buscamos el código

<script src="{{mix('js/app.js')}}" defer></script>
y lo sustituimos por
@vite(['resources/sass/app.scss','resources/js/app.js'])
Eliminamos el código de Styles

<link rel="stylesheet" href="{{ asset('css/app.css')}}">
-- En el archivo app.blade.php hacemos lo mismo

Eliminamos el link de Styles
<link rel="stylesheet" href="{{ mix('css/app.css')}}">
En el código de scripts
<script src="{{mix('js/app.js')}}" defer></script>
Lo sustituimos por
En este mismo archivo buscamos y eliminamos el código
@stack ('scripts')
--Buscamos el archivo welcome.blade.php (carpeta view/)

Buscamos el código 
<link href="{{ asset('css/app.css') }}" rel="stylesheet">
y sustituimos su código por el siguiente
--Buscamos el archivo app.js (carpeta resources/js)
y sustituimos el código (actualmente ya no se utiliza require se usa import)
require('./bootstrap');
por el siguiente código
--Buscamos el archivo bootstrap.js (carpeta resources/js)

y sustituimos el código
window._= require('lodash');
por las dos siguientes líneas de código
import _ from 'lodash';
window._ = _;
buscamos el código
const bootsrap = require ('bootstrap')
window.bootstrap = bootstrap
por el siguiente código
import * as bootstrap from 'bootstrap'
window.bootstrap = bootstrap
--Buscamos el archivo vite.config.js (carpeta raíz del proyecto)

agregamos un import como está el siguiente código
import {resolve} from 'path';
buscamos el código (en la sección de pluggins en la parte de input debemos cambiar la
ruta) ya que bootstrap trabaja con archivos sass
sustituimos el código
'resources/css/app.css',
por el siguiento código
'resources/sass/app.scss',
--Buscamos el archivo app.scss(carpeta resources/sass)

y buscamos el siguiente código (en la sección de bootstrap)
@import '~bootstrap/scss/bootstrap';
y lo sustituimos por el siguiente código
@import 'node_modules/bootstrap/scss/bootstrap';
--Buscamos el archivo postcss.config.js(carpeta raíz del proyecto)

Buscamos (en la parte de plugin) y eliminamos el código
tailwindcss: {},
Realizado los cambios anteriores al código nos vamos línea de comando y escribimos el
siguiente comando
npm install
npm install sass
npm run build
npm run dev
php artisan migrate
Como extra que no se nos debe olvidar al instalar bootstrap en nuestro proyecto de
laravel con jetstream
es que debemos también actualizar la configuración para la paginación
--Buscamos el archivo AppServiceProvider.php (carpeta app/providers)

agregamos la librería
use Illuminate\Pagination\Paginator;
y en la función boot() le agregamos el siguiente código

la función completa quedaría de la siguiente forma
{
}
28 – Laravel ahora usa Vite ¿Qué ocurrió con Webpack?

A partir de la versión 9 de Laravel ya instala por defecto Vite dejando a un lado a Laravel
Mix.
Laravel Mix era un envoltorio entorno a Webpack. Y WebPack era el paquete con el que
solía trabajar Laravel el cual nos permitía poder modularizar nuestro código JavaScript,
CSS e imágenes.
El problema con WebPack es que si hacíamos cualquier modificación en el código por mas
pequeña que sea, para que Webpack pueda compilar tena que leer todos los módulos que
teníamos para compilar (es decir tenia que leer el código completo del proyecto por un
cambio así sea el mas pequeño).
Por el contrario Vite si hacemos una pequeña modificación este solo compila la
modificación que se realizo, evitando así tener que leer el código completo. Por lo que el
tiempo de compilación es “mil veces” mas rápido.
Si tenemos un nuevo proyecto de Laravel 9 con Jetstream y ejecutamos el comando (en la

consola de visual code)
“npm run dev”
Este comando lo que hace es crear un nuevo servidor (Pero este servidor solo es de Vite y
no tiene nada que ver con el servidor de php – por ejemplo, el servidor que se crea al
ejecutar “php artisan serve” -. Este servidor (Vite) se mantiene a la escucha de cualquier
cambio que realicemos en el código Javascript y CSS y va a crear los assets que la final se
va a incluir dentro de nuestras paginas para poder mostrar esos estilos o las
funcionalidades que nosotros vayamos agregando. Es decir, los assets se compilan y alojan
en el servidor de Vite.
En nuestro proyecto tenemos un archivo (en la raíz del proyecto) llamado vite.config.js. En
este archivo nosotros indicamos cuales son los archivos que queremos se compile
plugins: [
laravel({
input: [
'resources/sass/app.scss',
'resources/js/app.js',
],
En este ejemplo indicamos son 2 archivos los que va a compilar app.css y app.js
El archivo app.css contiene

@tailwind base;
@tailwind components;
@tailwind utilities;
Aquí se esta inicializando Tailwind es decir que cuando inicie el proceso de compilación o
cuando tengamos prendido el servidor de Vite, vamos a tener cargado de manera
predeterminada Tailwind
El archivo app.js contiene

import Alpine from 'alpinejs';
window.Alpine = Alpine;
Alpine.start();
Aquí esta inicializando Alpine y al mismo tiempo esta importando un archivo Bootstrap.js
La pregunta es: ¿una vez que se compilen estos archivos como los incluimos en nuestras
páginas? Esto se hace a través de la directiva @vite que lo tiene los archivos .blade
Por ejemplo, en el archivo app.blade.php (ruta views/layouts/) dentro del head vemos la
directiva



Esta directiva lo que hace es incluir 2 etiquetas:
Una etiqueta link donde incluye app.css y
Una etiqueta script donde incluye app.js.
Por ejemplo, si nuestro proyecto iniciamos el servidor de Vite (npm run dev) y luego
iniciamos el servidor de php (php artisan serve) luego en el navegador web abrimos el
proyecto y nos vamos en la parte de login y la mantenemos abierta.
En la página login.blade.php (carpeta view/auth) antes de la etiqueta form agrego una
etiqueta <h1> hola Mundo</h1> y gurdamos vamos a ver que este cambio se ve reflejado
en el navegador web sin haber refrescado la página, esto es por que tenemos corriendo
tanto el servidor de php pero sobre todo por que tenemos corriendo el servidor de Vite y
este se mantiene a la escucha de cualquier cambio y lo compila de manera automática
mostrando los resultados en el navegador web de forma automática.
Ahora en producción cuando subamos nuestro proyecto no es necesario tener corriendo

un servidor de Vite a la escucha. Aquí lo que sucede es que cuando nosotros ya nos
encontramos en producción Vite no va a esperar que nosotros tengamos encendido el
servidor de Vite, si no que va a esperar que tengamos los Assets empaquetados, es decir
que tengamos los archivos ya compilados. Para lograr esto nosotros debemos correr el
comando antes de pasar nuestro proyecto a producción.
npm run build
Al ejecutar este archivo lo que va a hacer es crear una carpeta build dentro de la carpeta
public y dentro de la carpeta build creará unos archivos, entre ellos el archivo
manifest.json . Este archivo se va a leer cuando estemos en producción. En modo local
siempre va a esperar que el servidor de Vite este encendido.
29 – Componentes blade (de clase y anónimos)

Que son los componentes
Los componentes son extensiones de código los cuales se repiten varias veces en todo el
proyecto. Por ejemplo, el código que utilizamos para mostrar las alertas, los textbox, los
botones, las tarjetas, etc.
Si no utilizáramos componentes cada que quisiéramos definir por ejemplo un botón,
tendríamos que definir todo el código cada que lo necesitemos, la estructura del botón,
generar todos los estilos, etc.
El problema sería que, si hacemos una modificación por ejemplo el diseño del botón,
tendríamos que dirigirnos a cada uno de los lugares donde has colocado esos elementos y
modificarlos.
Cuando usamos componentes nos permite extraer todo el código necesario para mostrar
el botón en un documento (archivo blade) aparte y posteriormente, cuando necesitemos
utilizar el botón, simplemente hacemos referencia pasándole ciertos parámetros (como
por ejemplo el texto y/o título) a ese componente y tendríamos el botón completo.
Como definir (crear) componentes

Para crear componente debemos como primer paso:
 Dentro de la carpeta view crear una carpeta llamada components
Dentro de esta carpeta se crearán documentos .blade con nombres que queramos que
tenga cada uno de nuestros componentes.
 Creamos y asignamos un nombre a un archivo, por ejemplo, para crear un
componente para una alerta lo nombramos alert.blade.php. Creamos el archivo
alert.blade.php (dentro de la carpeta components).
 Para obtener un código base del componente, en Google escribimos alert tailwind
y entramos a un enlace que queramos (nosotros entramos al primer enlace (
https://v1.tailwindcss.com/components/alerts ). Buscamos una alerta que nos
guste y copiamos el código y lo pegamos en nuestro archivo alert.blade.php
Por ejemplo, nosotros usamos el siguiente código
<div class="bg-orange-100 border-l-4 border-orange-500 text-orange-700 p-4"
role="alert">
<p class="font-bold">Be Warned</p>
<p>Something not ideal might be happening.</p>
</div>
¿Como se utiliza (llamar) el componente?

Para llamar un componente se llama a la etiqueta
<x – NombreComponente/>
 Me voy a la vista donde quiero utilizar el componente (en este ejemplo
“dashboard.blade.php – en la raíz de la carpeta view) y en la parte donde la quiero
utilizar escribo lo siguiente:
<x-alert/>
Modificar el contenido de un componente

Esto se realiza en el código fuente del componente (recuerde que los archivos
componentes están almacenados en la carpeta components).
Es importante resaltar que esto lleva dos definiciones.
1. Donde se llama el componente
2. Donde está el código fuente del componente.
Es decir, aunque se defina el atributo en donde se llama el componente <x-alert artibuto>,
si no lo declaramos de forma explícita en el archivo donde está el código fuente del
componente este no se utilizara.
Modificar el contenido principal

Para esto usamos una variable llamada slot.
La variable slot es una variable que almacena el contenido que se ingresa en el
componente (en el archivo donde se llama el componente).
El componente puede tener n cantidad de variables slot. Estas variables slot se identifican
porque todas tienen que llevar el atributo name y su etiqueta (a excepción del slot
principal)
<x-slot name='titulo'>
Titulo Slot
</x-slot>
Solo la variable slot principal no lleva el atributo name y esta se identifica porque es lo que
esta entre la apertura y cierre del llamado del componente
<x-alert2>
Titulo Slot
</x-slot>
<p>Mensaje del cuadro</p>  Contenido slot principal

</x-alert2>
En este ejemplo la variable slot principal contiene <p>Mensaje del cuadro</p>
Para modificar el contenido de los componentes realizaríamos lo siguiente:

 definimos una variable llamada slot en el archivo que tiene el código fuente del
componente donde queremos que se imprima ese contenido en el componente.
o Abrimos el código fuente del componente (por ejemplo alert.blade.php)
o Eliminamos el mensaje principal que tiene de ejemplo el componente y la
sustituimos por una variable que se llama $slot
{{ $slot }}
 Nos dirigimos a la vista donde utilizamos el componente y modificamos la forma
de llamar al componente por una etiqueta de apertura y una de cierra (todo lo que
pongamos dentro de la llamada del componente se almacenara en la variable $slot
<x-alert>
<p> texto principal </p>
</x-alert>
Entonces para modificar el contenido de los componentes
Lo que coloquemos dentro de estas etiquetas lo va a almacenar en la variable $slot (la
variable definida en el código fuente del componente) y esto será lo que se muestre como
texto principal.
Modificar el título del componente.

En el archivo del código fuente del componente podemos modificar las etiquetas HTML
donde está definido el título, por ejemplo, podríamos sustituimos la etiqueta <p> por una
etiqueta <h1>.
Para modificar el titulo lo podemos hacer de 2 formas:

 La primera es pasándolo como atributo/propiedad (title) directamente del
componente
<x-alert title=”Titulo prueba”>
Este atributo lo tenemos que recibir en el archivo código fuente donde se definió el
componente a través de la directiva @props y dentro de esta directiva especificar
el atributo que quiero recibir, por ejemplo:
@props([‘title’])
Con esto ya podemos usar dentro del archivo código fuente del componente la
propiedad title para imprimir su valor. Por consiguiente, en este mismo archivo el
siguiente paso a realizar es sustituir el texto del título que tiene de ejemplo por
{{ $title }}
Por ejemplo:
<h1 class=”Font-bold”>{{ $title }}</h1>
 La segunda forma para pasar valores mucho más grandes o pasar una estructura
HTML (por ejemplo, alguna etiqueta h1, alguna etiqueta p, algún enlace, etc). Esto
se logra con slots secundarios (recuerden que el mensaje principal lo pasamos
como una variable $slot que sería el slot primario). Es importante definir la
propiedad como name para identificar ese slot en específico (cualquier otra
etiqueta no la reconocerá)
Para esto definimos
<x-slot name=”IdentificadorName”>
Esto es el título desde el slot (o el texto que queramos como título)
</x-slot>
En el archivo código fuente del componente no necesitamos definir la directiva
@props únicamente sustituimos el texto del título que trae como ejemplo por
{{ $ IdentificadorName }}
En la versión laravel 9 se puede definir el segundo slot (en este caso el titulo) se
hace con la sintaxis x-slot:nombre (importante, los 2 puntos tienen que ir pegado a
slot sin espacios, de lo contrario marcara error)
<x-slot:Titulo>
Esto es el titulo de prueba
</x-slot>
Múltiples slots
Se puede definir múltiples slots con la propiedad name como se muestra a continuación
<x-alert>
<x-slot name="Titulo">
Esto es el titulo sin name2
</x-slot>
<x-slot name="valor">
Titulo 2
</x-slot>
<x-slot name="valor2">
Titulo 4
</x-slot>
<p>Cuerpo de texto</p>
</x-alert>
Importante la propiedad name del slot no se necesita definir dentro del código fuente con
la directiva @props.
<div class="bg-orange-100 border-l-4 border-orange-500 text-orange-700 p-4"
role="alert">
<p class="font-bold">{{ $valor2 }}</p>
{{ $slot }}
{{$valor}}
<br>
{{$Titulo}}
</div>
Modificar el tipo de alerta (info, succes, danger)

Estas alertas cambian el color de acuerdo con el tipo que especificamos y se logra
agregando el atributo (propiedad) type al llamado del componente en la vista (no en el
archivo donde se definió el código fuete del componente).
<x-alert type=”info”>
Importante si especificamos un atributo hay que pasarlo al archivo código fuente del
componente donde se definió a través de la directiva @props
@props([‘type’])
Ahora para cambiar el estilo de acuerdo con el tipo de alerta (valor de type) del
componente lo podemos hacer con una condicional (entre código php) de acuerdo al valor
que trae la variable $type será el estilo CSS que se mostrará.
Para poner código php dentro del archivo blade se hace con la directiva @php @endphp
Entonces el código quedaría
@php
switch($type){
case ‘info’:
$clases = “bg-blue-100 borde-blue-500 text-blue-700”;
break;
case ‘danger’:
$clases = “bg-red-100 borde-red-500 text-red-700”;
break;
default:
$clases = “bg-green-100 borde-green-500 text-green-700”;
break;
}
@endphp
Ahora dentro de la etiqueta HTML imprimimos el valor de $clases.
<article class=”border-1-4 p-4 {{$clases}}” role=”alert”>
El código anterior lo que hará será concatenar lo que ya trae el atributo class con lo que
tiene la variable $clases.
Si no definimos el type al llamar al componente. Es decir, solo declaramos <x-alert>. En el

archivo donde se define el código fuente del componente debemos declara la directiva
props con un valor predeterminado
@props([‘type’ => ‘info’])
Variable $attributes
Si en el llamado del componente definimos un atributo por ejemplo id ( <x-alert
id=”alerta”> ), pero no lo definimos en la directiva @props (en el archivo donde se define
el código fuente del componente) el atributo id por defecto queda almacenado en la
variable $attribute. Solo aquellos atributos que se definieron en el llamado del
componente, pero no fueron declarados en el código fuente del componente con la
directiva @props serán los que se almacenan en la variable @attibutes
Esta variable al imprimir por ejemplo id=”alerta”, la podemos sustituir en el lugar que le
corresponde dentro de la una etiqueta HTML en el código fuente del componente. Por
ejemplo
<div {{$attributes}} class=”clase1”> </div>
Esto imprimiría <div id=”alerta” class=”clase1”> </div>
Combinar atributo clase (merge)

Si en la llamada del componente definimos un atributo clase
<x-alert :type=”$type” id=”Alerta” class=”mb-4”>
Pero también lo hacemos en el archivo del código fuente del componente
(alert.blade.php) - definimos entre corchetes class y su valor -
<div {{$atributes->merge([‘class’ => “border-1-4 p-4 bg-blue-100 border-blue-500 text-

blue-700”]) }}>
Aquí lo que hace el atributo clase es que los combina. Es decir, utiliza el valor definido en
la llamada del componente y además utiliza el valor de class definido en archivo código
fuente del componente.
IMPORTATE solo el atributo class es el que combina, ya que cualquier otro atributo que
este definido en ambos lados (tanto en la llamada del atributo como en el archivo código
fuente del atributo) va a sustituir el valor, predominando únicamente el valor del atributo
definido en la llama del componente.
Es decir si de define el atributo role=”prueba” en la llamada del componente y también se
define el atributo role=”alerta” en el archivo código fuente del componente. El valor que
predomina será role=”prueba”.
Separar código php de la vista (componente de clase)
Para esto tenemos que crear un componente de clase.
Para crear un componente de clase se hace con el comando
php artisan make:component Alert2
Esto crea 2 archivos
El primer archivo lo crea dentro de app/views/Components (aquí se ubica el archivo
Alert2.php). Nota no confunda la carpeta components (ruta resource/views/components)
El segundo archivo es la vista del componente. Archivo alert2.blade.php creado en la

carpeta “components” (ruta resource/views/components). En este archivo se pone todo el
código HTML.
En el primer archivo vamos a poner toda la logia de php. Dentro de este archivo, en el
método constructor vamos a pasar como parámetro lo que tenía la directiva @props y
dentro del método constructor vamos a pegar el código php
public function __construct($type='info')
{

switch ($type) {
case 'info':
$class="bg-blue-100 border-blue-500 text-blue-700 ";
break;

case 'danger':
$class="bg-red-100 border-red-500 text-red-700 ";
break;

default:
$class="bg-green-100 border-green-500 text-green-700 ";
break;
}
}
Es importante declarar una propiedad publica

public $clases;
para acceder a las variables definidas dentro del constructor, después del código php
dentro del constructor definimos
$this->clases = $class;
Con esto la vista va a poder acceder a las variables.
El código completo del archivo alert2.php (ruta app/view/components/)
<?php
namespace App\View\Components;
use Illuminate\View\Component;
class Alert2 extends Component
{
public $clases; <- propiedad publica
/**
* Create a new component instance.
*
* @return void
*/
public function __construct($type='info') <- metodo constructor
{
switch ($type) {
case 'info':
$class= "bg-blue-100 border-blue-500 text-blue-700";
# code...
break;

case 'danger':
$class= "bg-red-100 border-red-500 text-red-700";
# code...
break;

default:
$class= "bg-green-100 border-green-500 text-green-700";
# code...
break;
}
$this->clases = $class;
}
/**
* Get the view / contents that represent the component.
*
* @return \Illuminate\Contracts\View\View|\Closure|string
*/
public function render()
{
return view('components.alert2');
}
}
Componentes de Breeze y Jetstream

Componentes Breeze
Una vez instalado Breeze puedes encontrar los componentes de la carpeta components
(resource/view/components) y estos son llamados como se explicaron anteriormente.
Componentes JetStream
Una vez instalado JetStream en nuestro proyecto los componentes que usa este kit de
inicio están ocultos.
Para poder acceder a ellos se tiene que ejecutar la siguiente instrucción en línea de
comandos (instrucción para LiveWire).
php artisan vendor:publish --tag=jetstream-views
Esta instrucción hará visible la carpeta vendor (resource/views/vendor/) y dentro de esta

carpeta estará la carpeta components la cual contiene los componentes de JetStream
Llamada de componentes JetStream

Para llamar un componente jetstream se usa el prefijo “jet” en el llamado del componente
como se muestra en el siguiente ejemplo
<x-jet-welcome/>
Lo anterior lo que hace es que busca el componente en la ruta

“resource/views/vendor/components”.
Si en la llamada al componente omitimos el prefijo jet (por ejemplo <x-welcomer/> ) esto

lo que hace es buscar el componente en la ruta “resource/views/components”.
Llamada de plantillas en JetStream

Jetstream llama a las plantillas como si fueran componentes.
Es decir, en vez de llamar a las plantillas blade con la directiva @extends(‘rutaPlantilla’). La
plantilla se llama como si fuera un componente.
Por ejemplo en el archivo dashboard.blade.php en vez de usar @extends(‘rutaPlantilla’)

para llamar a la plantilla, el archivo usa <x-app-layout> … </x-app-layout> como se
muestra en el siguiente código
<x-app-layout>
<x-slot name="header">
<h2 class="font-semibold text-xl text-gray-800 leading-tight">
{{ __('Dashboard') }}
</h2>
</x-slot>
<div class="py-12">
<div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
{{-- @php
$type = 'danger';
@endphp
<x-alert2 :type="$type" id='alerta' class="mb-4">

Titulo Slot
</x-slot>
<p>Mensaje del cuadro</p>

</x-alert2>
<p>Prueba de linea</p> --}}
<x-jet-welcome/>
</div>
</div>
</x-app-layout>
Lo que hace el componente es llamar a la vista AppLayout.php ubicado en la ruta

“app/view”
El código de la vista AppLayout.php llama a la vista “layouts.app” (archivo app.blade.php)

ubicado en la ruta “resources/views/layouts”
<?php
class AppLayout extends Component

{
/**
* Get the view / contents that represents the component.
*
* @return \Illuminate\View\View
*/
{
return view('layouts.app');
}
}
El punto importate a resaltar es que jetstream llama a sus plantillas como si fueran
componentes y no a través de la directiva @extends(‘rutaPlantilla’).
30.- Modificando la plantilla de JetStream
Lo que vamos a editar es la vista dashboard que aparece una vez que el usuario se ha
logueado.
Ruta de la plantilla
Primero es identificar los archivos que intervienen. Para identificar el archivo vista
dashboard, nos vamos al archivo web.php dende se definen las rutas (carpera
“routes/web.php”
En este archivo encontraremos dos routes:

});
Route::middleware(['auth:sanctum',
config('jetstream.auth_session'),'verified'])->group(function ()
{
Route::get('/dashboard', function () {
return view('dashboard');
})->name('dashboard');
});
El primero nos dice que en la raíz del sitio web nos va a dirigir a la vista welcome.
El segundo route tiene un middleware
El middleware es como un filtro de la futa, es decir si se cumple la condición del
middleware, entonces nos dirigirá a la vista dashboard, de lo contrario nos dirigira al URL
de login. En este caso el middleware nos indica que la condición a cumplirse es el
logueado exitoso del usuario.
Si nos dirigimos a la vista dashboard, esta nos llevara al archivo dashboard.blade.php

(ubicado en “resources/views/vendor”) con el siguiente código
<x-app-layout>
<x-slot name="header">
<h2 class="font-semibold text-xl text-gray-800 leading-tight">
</h2>
</x-slot>
<div class="py-12">
<div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
{{-- @php
$type = 'danger';
@endphp
<x-alert2 :type="$type" id='alerta' class="mb-4">

Titulo Slot
</x-slot>
<p>Mensaje del cuadro</p>

</x-alert2>
<p>Prueba de linea</p> --}}
<x-jet-welcome/>
</div>
</div>
</x-app-layout>
En este código lo importante a resaltar es en la primera línea de código <x-app-layout>. A

partir de laravel 8 el llamado a las plantillas se hace de la misma manera como llamamos a
los componentes y como como una extensión de la plantilla @extends(‘rutaPlantilla’). Por
lo tanto <x-app-layout> es el llamado de una plantilla.
<x-app-layout> indica que se esta llamado un componente (en este caso plantilla). La
instrucción indica lo siguiente:
 El llamado de x indica que es un componente
 App indica que esta en la carpeta app
 layout indica el nombre de componente (nombre del archivo)
Por lo que nos dirigiremos a la carpeta “app/AppLayout.php” el cual nos muestra el
siguiente código:
<?php
class AppLayout extends Component

{
/**
* Get the view / contents that represents the component.
*
* @return \Illuminate\View\View
*/
{
return view('layouts.app');
}
}
Lo importante en este código es que llama a la vista “layouts.app”. esta vista esta ubicada
en la ruta “resources/views/layouts”. Este archivo es la plantilla base que se usaría en las
otras vistas. analizando su código encontramos los siguiente:
<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="csrf-token" content="{{ csrf_token() }}">
<title>{{ config('app.name', 'Laravel') }}</title>


<link rel="stylesheet" href="https://fonts.bunny.net/css2?
family=Nunito:wght@400;600;700&display=swap">




@livewireStyles
</head>
<body class="font-sans antialiased">
<x-jet-banner />
<div class="min-h-screen bg-gray-100">

@livewire('navigation-menu')


@if (isset($header))
<header class="bg-white shadow">
<div class="max-w-7xl mx-auto py-6 px-4 sm:px-6 lg:px-
8">
{{ $header }}
</div>
</header>
@endif


<main>
{{ $slot }}
</main>
</div>
@stack('modals')
@livewireScripts
</body>
</html>
El primero código por analizar es el siguiente

<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
El método str_replace tomando el valor que tiene la variable “locate” para asignarlo al
atributo “lang”.
El valor de la variable en este ejemplo tiene valor “en”.
'locale' => 'en',
Esta variable se encuentra en el archivo app.php (en la ruta “config/”).
El segundo código por resaltar es el siguiente:

<title>{{ config('app.name', 'Laravel') }}</title>
El método config toma el valor que tiene la variable y lo imprime como titulo.
APP_NAME=Laravel
Esta variable esta en el archivo “.env” de la raíz del proyecto
En caso de que tengamos el siguiente código


<link rel=”stylesheet” href=”{{ asset(‘css/app.css’) }}”>
Lo que se tiene que resaltar es que el método assaet lo que hace es posicionarse en la
carpeta public del proyecto y a partir de ahí buscar la ruta que tiene indicada (en este
ejemplo ‘css/app,css’).
Este código

@livewireStyles
Incorpora los estilos de livewire
Defer
En el siguiente código es importante resaltar defer

<script src=https://cdn.jsdelivr.net/gh/alpinejs/alpine@v2.7.0/dist/alpine.js
defer></script>
Lo que hace defer es que el código <script src=…> lo pasa al final de justo antes del cierre
de <body>. Con esto permite se ejecute todo el código antes de ejecutarse el script.
Defer lo que indica al navegador es que no espere por el script. En lugar de ello, debe
seguir procesando el HTML, en otras palabras:
 los scripts con defer nunca bloquean la página.
 Los scripts con defer siempre se ejecutan cuando el DOM esta listo (pero antes del
evento DOMContentLoaded).
Recapitulando lo principal a resaltar es como se llama la plantilla. Ya no se usa la directiva

@extends(‘rutaPlantilla’) si no que ahora lo llama como un componente. Por lo que para
cambiar el contenido de la plantilla ya no lo hace definiendo @yield(‘contenido’) y
@content() si no que esta haciendo uso de las variables slots.
Cambiar el contenido principal de la vista Dashboard

Lo que vamos a hacer es cambiar el contenido que está en el recuadro naranja
Para ello nos vamos al archivo dashboard.blade.php (ubicado en la ruta
“resources/views/”) y eliminamos el llamado al componente
<x-jet-welcome/>
Este componente engloba todo el contenido que esta en el recuadro naranja de la imagen
anterior. Lo vamos a sustituir por texto de relleno.
Para crear automáticamente 5 parrafos con texto de relleno uso la siguiente instrucción
P*5>lorem + tab.
Esto nos dejara una imagen como la siguiente

Agregar link al menú de navegación en la vista Dashboard
En la plantilla app.blade.php (ruta “resource/views/layouts”) se encuentra el menú de
navegación en la siguiente línea de código
Cabe destacar que le código anterior es la forma de llamar a un componente, pero no
como un componente blade si no como un componente livewire.
El código fuente de este componente se encuentra en “resources/views/navigation-
menu.blade.php”
Abrimos el archivo y buscamos el siguiente código que es donde se encuentran los links de
navegación.

<div class="hidden space-x-8 sm:-my-px sm:ml-10 sm:flex">
<x-jet-nav-link href="{{ route('dashboard') }}"
:active="request()->routeIs('dashboard')">
</x-jet-nav-link>
</div>
</div>
Este menú se imprime a través del componente <x-jet-nav-link>. El componente se llama

nav-link pero como tiene antes el prefijo jet. Laravel sabe que no es un componente
creado por el usuario si no un componente creado por JetStream por lo que este
componente se encuentra en la ruta “resources/views/ventor/components” (si no ve la
carpeta ventor tiene que ejecutar la instrucción que permita hacer visible los
componentes jetstream
php artisan vendor:publish --tag=jetstream-views). Nota también se encuentra
dentro de la carpeta “vendor/laravel/jetstream/resource/components”).
@props(['active'])
@php
$classes = ($active ?? false)
? 'inline-flex items-center px-1 pt-1 border-b-2 border-indigo-
400 text-sm font-medium leading-5 text-gray-900 focus:outline-none
focus:border-indigo-700 transition'
: 'inline-flex items-center px-1 pt-1 border-b-2 border-
transparent text-sm font-medium leading-5 text-gray-500 hover:text-gray-700
hover:border-gray-300 focus:outline-none focus:text-gray-700 focus:border-
gray-300 transition';
@endphp
<a {{ $attributes->merge(['class' => $classes]) }}>

{{ $slot }}
</a>
Analizando el código vemos que recibe un atributo active. Este atributo pasaría un true o
false.
En una variable $classes almacenar una cadena dependiendo si el valor de active es true o
false.
Posteriormente a través de $attribute->merge va a combinar lo que tenga la clase con lo
que se almaceno en la variable @classes.
Posteriormente imprime la variable slot.
Regresamos al archivo navigation-menu.blade.php (ruta “resources/views/”) y escribismo

el siguiente código justo de bajo del cierre del componente <x-jet-nav-link>

</x-jet-nav-link>
</div>

Lo que vamos a hacer es lo siguiente:

1. Llamar nuevamente al componente (y su cierre)
2. En su llamada vamos de declarar el atributo acive con valor false
3. Como slot principal escribimos “Blog” (recuerde que el slot principal es lo que esta
entre la apertura del componente y el cierre).
IMPORTANTE Si pasamos el valor de la siguiente manera active=”false”. Se esta pasando
false como una cadena (como si fuera una cadena cualquiera – aunque diga false). Y por
ende cuando analiza una cadena en una condicional identifica que tiene un valor (que no
esta vacia) por lo que le da un valor de true.
Para evitar esto y el valor de active asignado sea considerado un booleano y no un cadena,
igual que cuando le asignavamos una variable debemos de anteponer : (2 puntos) al active
</x-jet-nav-link>
<x-jet-nav-link :active="false">
Blog
</x-jet-nav-link>
</div>
No obstante el valor de true o false del atributo active debería de asignarse

dinámicamente para ello usamos el código
"request()->routeIs(nombreMenu)">
Por lo que el componente con su atributo quedaría de la siguiente manera

<x-jet-nav-link :active="request()->routeIs('blog')">
Le agregamos la propiedad href para redireccionar a otra pagina (el código fuente del
componente tiene el tag <a> y al imprimir la variable $attribute->merge concatenara la
propiedad href com las demás propiedades que se hayan declarado)
Hay que hacer lo mismo en modo responsivo (mobiles) por lo que buscamos el siguiente
código (esta vez el componente es <x-jet-responsible-nav-link>)

<div :class="{'block': open, 'hidden': ! open}" class="hidden
sm:hidden">
<div class="pt-2 pb-3 space-y-1">
<x-jet-responsive-nav-link href="{{ route('dashboard') }}"
</x-jet-responsive-nav-link>
</div>
Lo cual agregamos el componente nuevamente para el link Blog quedando el código de la

siguiente manera:
sm:hidden">
<x-jet-responsive-nav-link href="{{ route('dashboard') }}"
<x-jet-responsive-nav-link href="" :active="request()-
>routeIs('blog')">
Blog
</div>
Modificando el logo de la plantilla Dashboard

En el archivo navigation-menu.blade.php (ubicado en la ruta “resources/views/”) bucamos
el siguiente código

<div class="shrink-0 flex items-center">
<a href="{{ route('dashboard') }}">
<x-jet-application-mark class="block h-9 w-auto" />
</a>
</div>
Si observamos el componente <x-jet-application-mark> (ubicado en la ruta

“resources/views/vendor/components”) es el que define el logo. Si código fuente es el
siguiente:
<svg viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg" {{
$attributes }}>
<path d="M11.395 44.428C4.557 40.198 0 32.632 0 24 0 10.745 10.745 0 24
0a23.891 23.891 0 0113.997 4.502c-.2 17.907-11.097 33.245-26.602 39.926z"
fill="#6875F5"/>
<path d="M14.134 45.885A23.914 23.914 0 0024 48c13.255 0 24-10.745 24-24
0-3.516-.756-6.856-2.115-9.866-4.659 15.143-16.608 27.092-31.75 31.751z"
fill="#6875F5"/>
</svg>
Podemos observar que tiene las etiquetas html svg que maneja gráficos.
Para modificar el logo hay que editar el código entre las etiquetas svg.
Como reutilizar la plantilla JetStream

En este capitulo vamos a ver como convertir la plantilla de JetStream en nuestra plantilla
principal y poder extenderlo en todas las vistas de nuestro proyecto. La plantilla es
app.blade.php (ruta “resources/views/layouts”).
En el código de esta plantilla buscamos la sección body y Explicaremos unas de sus
secciones.
 Primero observemos el componente navigation-menu. Este es un componente de
livewire
Este código llama al archivo que se encuentra en la ruta

“resources/views/navigation-menu.blade.php”. Este archivo tiene el código fuente
el cual es el menú de navegación.
 Como segundo paso buscamos la sección “Page Heading”.


@if (isset($header))
<header class="bg-white shadow">
<div class="max-w-7xl mx-auto py-6 px-4 sm:px-6 lg:px-8">
{{ $header }}
</div>
</header>
@endif
En la imagen de abajo se muestra encerrado en un cuadro azul lo que el código

anterior realiza. Comentamos el código anterior para eliminar el heading.
Esto va a crear un cambio “brusco” entre el menú de navegación y el body como lo

muentra la imagen de abajo.
Para suavizar la división entre el menú de navegación y el body vamos a agregar la clase
shadow. La clase shadow es una clase de tailwind.
Esto lo agregamos en el código fuente del componente navigation-menu.blade.php
(ubicado en la ruta “resources/views/”).
Buscamos el siguiente código (línea 1 del archivo navigation-menu.blade.php).
<nav x-data="{ open: false }" class="bg-white border-b border-gray-100">
Y agregamos al final del class la palabra shadow quedando de la siguiente manera
<nav x-data="{ open: false }" class="bg-white border-b border-gray-100
shadow">
Esto dibujara una sombra entre el menú de navegación y el body.
Los siguientes pasos son en el archivo navegation-menu.blade.php
Este código está dividido en 2 secciones:
 Primary navigations menú.- Esta pantalla se mostrara para pantallas mas haya de
648px
 Responsive navigaions Menu. Es para pantallas móviles o tables cuya resolución
sea menor o igual a 648px
Por lo tanto, agregar un nuevo link en el menú de navegación se tiene que realizar en las
dos secciones.
Analizamos la sección Primary navigation Menu.

Como primera instancia vemos que tiene la sección logo:

<div class="shrink-0 flex items-center">
<x-jet-application-mark class="block h-9 w-auto" />
</a>
</div>
Esta sección llama al componente <x-jet-application-mark>, el código fuene de este

componente es el archivo application-markblade.php el cual se encuentra en la ruta
“resources/views/ventor”.
<svg viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg" {{

$attributes }}>
<path d="M11.395 44.428C4.557 40.198 0 32.632 0 24 0 10.745 10.745 0 24
0a23.891 23.891 0 0113.997 4.502c-.2 17.907-11.097 33.245-26.602 39.926z"
fill="#6875F5"/>
<path d="M14.134 45.885A23.914 23.914 0 0024 48c13.255 0 24-10.745 24-24
0-3.516-.756-6.856-2.115-9.866-4.659 15.143-16.608 27.092-31.75 31.751z"
fill="#6875F5"/>
</svg>
Modificando este código modificaríamos el logotipo.
Bajando más en el código del componente navigation-menu.blade.php podemos

encontrar
</x-jet-nav-link>
<x-jet-nav-link :active="request()->routeIs('blog')">
Blog
</x-jet-nav-link>
</div>
</div>
Aquí es donde se crean los links de navegación. Estos links se crean a través del
componente <x-jet-nav-link>
Agregar link al menú de navegación

La idea no es agregar link por link en cada una de las secciones (menú principal y menú
responsivo).
Por lo que vamos a crear un arreglo en el que vamos a ir metiendo todos los links. Cada
arreglo tendrá los datos de cada link y luego únicamente en cada sección (menú principal
y menu responsivo) vamos a llamar a los componentes correspondientes y estos
componentes harán referencia al arreglo. Así si necesitamos meter un nuevo link lo
metemos al arreglo y este se reflejará en automático en ambas secciones a través de sus
coponentes.
Para ello vamos a ingresar el siguiente código

@php
$nav_links=[
[
'name' => 'Dashboard',
'route' => route('dashboard'),
'active' => request()->routeIs('dashboard')
],
[
'name' => 'Prueba',
'route' => '#',
'active' => false
]
];
@endphp
En este códigoes un arreglo general, que tiene 2 arreglos. Cada arreglo es un link (cada
arreglo tiene su name, su route y su active). En el segundo arreglo (link Prueba) en route
se puso # por que aun no está creada la ruta y lo mismo para active se puse
predeterminado el valor de False ya que no existe aun esa pagina web.
Para el llamado de este componente lo vamos a realizar dentro de un foreach para que
vaya recorriendo arreglo por arreglo y así ir “pintando” cada link.
Este es el código para el menú en pantalla normal
@foreach ($nav_links as $nav_link)
<x-jet-nav-link href="{{ $nav_link['route'] }}"
:active="$nav_link['active']">
{{ $nav_link['name'] }}
</x-jet-nav-link>
@endforeach

</div>
Este es el código para pantallas móviles

sm:hidden">

@foreach ($nav_links as $nav_link)
<x-jet-responsive-nav-link href="{{ $nav_link['route'] }}"

:active="$nav_link['active']">
{{ $nav_link['name'] }}
@endforeach

</div>
Redireccionando a la página principal al dar clic al logo

Primero abrimos el archivo de rutas “web.php” (ubicado en la carpera “routes/web.php”
A la ruta principal le vamos a asignar un alias “home”, quedando el código de la siguiente
manera:
})->name('home');
Regresamos al archivo navigation_menu.blade.php y buscamos el comentario logo y

buscamos el código
Cambiamos “dashboard” por “home”

<a href="{{ route('home') }}">
El siguiente paso es extender la plantilla dashboard (app.blade.php) como la plantilla

home (actualmente la vista home es la vista welcome.blade.php). Por lo que en el archivo
welcome.blade.php es donde se hará la redirección.
Para ello abrimos el archivo welcome.blade.php y comentamos todo el código que tiene.
Posterior a eso llamamos al componente que hace uso de la vista app.blade.php. Este
componente está en la ruta “app/view/AppLayout.php” y se llama AppLayout.php. El
componente se llama escribiendo <x-app-layout>
Por lo tanto, el código del archivo welcome.blade.php quedaría de la siguiente manera

IMPORTANTE. Todavía que da un bug por arreglar, ya que si cerramos sesión buscara un
usuario registrado y mostrara un error. Para solucionar esto usamos la directiva @auth
que lo que hace es que el código que este dentro de esta directiva se va a leer solo si el
usuario este logueado.
Esta directiva la vamos a agregar tanto en la sección de menú navegador “normal” y la

sección de menú responsivo
En la sección de menú “normal” buscamos el comentario


En esta sección agregamos el siguiente código:
Este código comprimimos el componente y lo metemos dentro de la directiva @auth.

Dentro de la directiva @else es lo que se mostrara en caso que el usuario no este
logueado (es decir que no se lea el código dentro de @auth).
Lo que este dentro de la directiva @auth va a ir el código que solo se va a leer solo si el
usuario esta registrado. En caso que el usuario no este registrado se leerá lo que este
dentro de la directiva @else.
En la sección del menú Responsive buscamos el comentario

Ingresamos el siguiente código
En este código comprimido el tag <div> lo ponemos dentro de la directiva @auth y dentro
de la directiva @else ponemos los links que nos van a redireccionar al login y register. Solo
que para mantener la estética los links se crean con sus componentes <x-jet-responsive-
nav-link>
31.- que son los middlewares

Los middlewares son filtradores de URL. Es decir que cuando llega un URL a nuestro
sistema, el middleware lo toma y evalua, si cumple lo estableido en el middleware permite
visitar ese middleware en caso contrario lo redirije a otro URL.
Un ejemplo de esto es el middleware de autentificación que permite avanzar al URL

Dashboard solo si el usuario esta logueado en caso contrario si alguien intentara visitar
directamente la URL del Dashboard sin estar logueado, el middleware lo reirecciona al URL
de login.
Exisen varios middleware incluidos en el framework de Laravel, incluidos el middleware

para autentificación y el del toquen necesario para formularios (el token CSRF que hay que
pasar a los formularios para su validación o nos redirecciona a una pagina 404).
Todos estos middleware se encuentran en la ruta “app/Http/Middleware”.
Creación y asignación de un middleware

Para efectos de prueba, primero vamos a crear la ruta, por lo que nos vamos al archivo
web.php (ubicado en la carpeta “routes” de la raíz del proyecto).
 Creamos la ruta de tipo get con el nombre de prueba, no recibirá ningún
parámetro (en la función anónima) y que retorne una cadena “has accedido
correctamente a esta ruta”.
Route::get('prueba', function () {
return "Has accedido correctamente a esta ruta.";
});
Para crear un middleware se hace desde la línea de comandos (en la carperta del proyecto
– presionando control + ñ en visual studio code) y escribiendo la siguiente instrucción.
php artisan make:middleware NombreMiddleware
Esto va a crear un archivo en la carpeta “app/Http/Middleware”. Este archivo lo que

contiene es una clase y esta clase lo que contiene es un método. Este método es el que se
encarga de filtrar las solicitudes HTTP. El código completo es:
<?php
namespace App\Http\Middleware;
use Closure;
class CheckAge
{
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure(\Illuminate\Http\Request): (\Illuminate\Http\
Response|\Illuminate\Http\RedirectResponse) $next
* @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
*/
public function handle(Request $request, Closure $next) //<-- Metodo
encargado de filtrar las solicitudes
{
return $next($request);//<--codigo que permite acceda URL solicitado
}
}
El código return $next($request) es el importate ya que es el que permite que la solicitud

Http continue. Si comentamos este return la solicitud HTTP seria siempre declinada.
Lo que es importante aquí es resaltar que lo que se ponga (codifique) dentro de la función
es lo que será la condicionándote para saber si se toma una acción u otra acción (con un if
por ejemplo). Aquí mostramos un código que tiene 2 returns pero el primero esta
comentado. Se podría usar un if para determinar que return tomar
public function handle(Request $request, Closure $next)
{
// return $next($request);//<-- Este es el que permite acceda al URL
solicitado
return redirect('/');
}
Registrar el middleware
Una vez creado el middleware es obligatorio registrarlo para poder usarlo. Esto es para
que Laravel reconozca que esta clase en particular (en el ejemplo CheckAge) su trabajo
será filtrar las solicitudes HTTP.
Esto se registra en la parte final del archivo “kernel.php” (ubicado en la ruta “app/Http”).
Ahí buscamos el siguiente código
protected $routeMiddleware = [
'auth' => \App\Http\Middleware\Authenticate::class,
'auth.basic' => \Illuminate\Auth\Middleware\
AuthenticateWithBasicAuth::class,
'auth.session' => \Illuminate\Session\Middleware\
AuthenticateSession::class,
'cache.headers' => \Illuminate\Http\Middleware\
SetCacheHeaders::class,
'can' => \Illuminate\Auth\Middleware\Authorize::class,
'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
'password.confirm' => \Illuminate\Auth\Middleware\
RequirePassword::class,
'signed' => \App\Http\Middleware\ValidateSignature::class,
'throttle' => \Illuminate\Routing\Middleware\
ThrottleRequests::class,
'verified' => \Illuminate\Auth\Middleware\
EnsureEmailIsVerified::class,
];
En esta propiedad $routeMiddleware están todos los middleware definidos en Laravel.

Para registrarlo debemos de cumplir lo siguiente:
1. Darle un nombre identificativo
2. Pasarle la ruta donde se encuentra mi Middleware. Esta ruta la podemos tomar del
archivo (código fuente) del middleware en el namespace. Debemos iniciar la ruta
con una barra invertida \
3. Le pasamos el nombre de la clase y le paso el método class ejemplo
NombreClase::class.
4. Cerramos con una coma
El código seria:
protected $routeMiddleware = [
'auth' => \App\Http\Middleware\Authenticate::class,
'auth.basic' => \Illuminate\Auth\Middleware\
AuthenticateWithBasicAuth::class,
'auth.session' => \Illuminate\Session\Middleware\
AuthenticateSession::class,
'cache.headers' => \Illuminate\Http\Middleware\
SetCacheHeaders::class,
'can' => \Illuminate\Auth\Middleware\Authorize::class,
'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
'password.confirm' => \Illuminate\Auth\Middleware\
RequirePassword::class,
'signed' => \App\Http\Middleware\ValidateSignature::class,
'throttle' => \Illuminate\Routing\Middleware\
ThrottleRequests::class,
'verified' => \Illuminate\Auth\Middleware\
EnsureEmailIsVerified::class,
'age' => \App\Http\Middleware\CheckAge::class,
];
Asignar el middleware a una ruta en especifico

Una vez creado y registrado el middleware ahora se lo vamos a asignar a una ruta en
específico. Para ello vamos al archivo web.php (ubicado en la carperta “routes”). De la
misma manera como asignamos un alias a una ruta ->name(), de la misma manera es
como vamos a asignar el método middleware. Al final del Route antes del ; escribo
->middleware(parametro1). Como parámetro1 (dentro de los paréntesis) va el alias que
hayamos asignado al middleware (en este caso “age”.
Ahora ya asignado el middleware a un Route, cada que accedamos a ese URL el

middleware interceptara esa solicitud y de acuerdo a lo que tenga dentro de su función
“handle “(esto en el código fuente del middleware) es el trabajo que realizara el
middleware permitiendo o no acceder a ese URL.
{
// return $next($request);//<-- Este es el que permite acceda al URL
solicitado
return redirect('/');
}
Este método lo que hace es interceptar la solicitud Http (URL) y de acuerdo a lo que
definamos dentro del método realiza una acción o realiza otra acción. Por ejemplo el
siguiente código
{
if ($request->age >=18) {
return $next($request);
} else {
return redirect(no-autorizado);
}

}
Es importante señalar el código del route en el archivo web.php que se le asigno el

middelware. En caso que permita el URL se ejecutara el route ‘prueba’ en caso contrario
se ejecutara el route ‘no-autorizado’.
return "<strong>Has accedido correctamente a esta ruta.</strong>";
})->middleware('age');
Route::get('no-autorizado', function () {
return "Usuario no autorizado";
});
Por lo tanto si ingresamos la URL http://localhost/jetlayer/public/prueba?age=20 nos

permitirá acceder a la URL prueba, en caso contrario nos redireccionara a la URL no-
autorizado.
El pasar parámetros solo es a modo de prueba, normalmente no hacemos esa

comparación pasando parámetros a partir de la URL. Por lo general se hace esa
comprobación de lo que tengamos almacenado en la base de datos acerca del usuario que
se encuentra actualmente queriendo ingresar. Para acceder a la información del usuario
que se quiere loguear hacemos lo siguiente:

{

if (auth()->user()->email == 'jacgms@hotmail.com') {
return $next($request);
} else {
return redirect('denegado1');
}

}
Este código lo que hace en el if es: a través del método “auth()” y le voy a pedir que
acceda a la información del usuario autentificado a través del método “user()” y le
pedimos que recupere la información de su email y que esta sea igual a
“jacgms@hotmail.com”.
Esto funciona solo si el usuario esta registrado. Si se cierra la sesión e ingresa

directamente a la URL le aparece un error donde dice que esta tratando de recuperar el
email pero su valor es nulo. Esto ocurre por que como el usuario no esta autentificado no
puede acceder a ningún atributo.
Para solucionar lo anterior. En el archivo web.php en la Route que asignamos el
middleware y el alias también le vamos a pasar el middleware auth esto se logra
agregando todos los middleware dentro de un arreglo como se muestra en el siguiente
código.
})->middleware(['auth:sanctum','age']);
De esta manera esta ruta tiene que cumplir con los 2 middleware para que se muestre el
return “Has accedido correctamente a esta ruta”. De esta manera si el usuario no esta
registrado ya no sale el error de querer leer un atributo de un usuario que no esta
registrado, lo que hace en cambio es redireccionar a la URL de login y si inicio sesión ahora
si me redirecciona al URL prueba y me muestra el contenido de return.
Diseño de base de datos (Modelo conceptual)

Reglas de negocio
Antes de crear una base de datos hay que definir las reglas de negocio. Las reglas del
negocio son definir por puntos todo lo que debe hacer la aplicación que esta por
desarrollarse.
Esta definición debería ser realizada por el cliente pero en la realidad es el mismo
programador el que la realiza. Esto se obtiene a partir de una serie de preguntas.
Usaremos las reglas de negocio de un sistema de blog.
Reglas de Negocio para sistema de Blog

 Los usuarios de mi pagina pueden registrarse y hacer login.
La información de los usuarios que necesitamos almacenar son nombre, correo y
dirección.
 Va a haber usuarios que van a tener el perfil de creadores. En el perfil de creadores
debemos almacenar título, biografía y sitio web.
 Los creadores pueden escribir uno o más Post.
 Los Post solo pueden ser escritos por un único autor.
 Los Post deben tener portada, titulo, descripción, categoría y pueden tener uno o
más etiquetas.
 Los Post van a poder ser comentado por los usuarios.
Usualmente para diseñar una base de datos pasamos por 3 etapas.

1. El modelo conceptual. Esto consiste en llevar todos los puntos del modelo del
negocio y convertirlos a un esquema (sin preocuparnos por la parte técnica). La
idea del modelo conceptual es poder mostrar las reglas de negocio de una manera
visual y que el cliente pueda comprender.
Para poder representar el modelo conceptual lo podemos hacer basándonos en el
diagrama entidadrelación.
El diagrama entidad-relacion indica que dentro de las reglas del negocio debo
encontrar entidades. Entiéndase entidades como objetos ya sean reales o
conceptuales que tengan atributos.
En nuestro ejemplo de reglas de negocio las entidades serian:

 Usuarios y sus atributos son nombre, correo, dirección.
 Creadores y sus atributos son título, biografía y sitio web.
 Post y sus atributos son: portada, titulo, descripción, categoría.
 Comentarios sus atributos son mensaje y la persona que los escribió.
Para desarrollar digitalmente el diagrama usaremos el programa DIA DIAGRAM EDITOR

http://dia-installer.de/ El cual es código libre.
Creando el diagrama DIAGRAM EDITOR

Como primer paso en el menú izquierdo donde dice otras hojas seleccionamos “otras
hojas/ER”
Crear entidades en DIAGRAM EDITOR
Lo primero que hay que hacer es colocar las entidades como se muestra a continuación:
1. Damos clic al icono situado en el menú izquierdo.

2. Damos clic sobre el lienzo y nos saldrá un submenú.
3. Los nombres se escriben en plural.
Creación de la relación entre las entidades
La creación de relaciones se hace en una especie de rombo
Para este ejemplo si las entidades son:
 Usuarios
 Creadores
 Post
 Comentarios
Entonces se busca la relación que existe entre las entidades. Por ejemplo,
 un usuario puede ser creador
 Un creador escribe Post
 Y un Post contiene comentarios
Estas relaciones las especificamos en una especie de rombo dando clic al icono y lo
colocamos entra las entidades como se muestra a continuación.
Luego lo unimos con una pequeña línea con el icono. Dando clic en el centro de la entidad
hacia el centro de la relación (rombo) quedando como se muestra a continuación.

Nota en caso de que aparezca una fleca y no una línea, dar doble clic sobre la línea para
que aparezca su submenú y ahí en la opción de flecha de finalización o flecha de inicio lo
cambiamos por la línea
Creación de la cardinalidad (relación de uno a muchos o combinaciones)
Para calcular la cardinalidad debemos centrarnos en las relaciones y le damos doble clic
para abrir el submenú.
Nos vamos a centrar en las opciones Cardinalidad a izquierda y cardinalidad a derecha.

Para ello nos enfocamos en las entidades que están de lado izquierdo y derecho de la
relación.
En esta imagen tenemos 2 entidades entre una relación. De lado izquierdo tenemos la
entidad Users y de lado derecho tenemos la entidad Creadores.
La cardinalidad izquierda es la relación que existe entre la entidad creadores en relación
con la entidad Users.
La cardinalidad Derecha es la relación que existe entre la entidad Users en relación con la
entidad Creadores.
Se inicia con la cardinalidad a derecha y terminado se continua (mismo procedimiento)

cardinalidad izquierda.
Para poder identificar la cardinalidad tenemos que hacernos las siguientes preguntas.
1. La entidad izquierda como mínimo cuantas entidades derechas pudieran tener.
2. La entidad izquierda como máximo cuantas entidades derechas puede tener.
En este ejemplo seria la entidad Users como mínimo puede tener 0 perfiles de creadores,
ya que puede existir el caso que ningún usuario sea creador y como máximo la entidad
Users tendría 1 perfil de creador ya que un usuario si puede tener un perfil de creador.
En modo inverso (cardinalidad a izquierda) seria un creador puede estar asignado mínimo
a un usuario y un creador solo puede estar asignado máximo a N usuarios
Teniendo las cardinalidades ahora damos clic en el icono texto y escribimos arriba
del rombo (la relación) el máximo de cada lado de la cardinalidad
Atributos de las entidades

De acuerdo a las reglas de negocio de nuestro ejemplo, lo que debería de almacenar de
Uses es nombre, email y una dirección
Para ello damos clic en el icono . Hay atributos que tienen varios valores internos. Por
ejemplo el atributo dirección tiene otros valores como calle, colonia, código postal,
ciudad. Etc
Para señalar que una entidad es multivalor, en el submenú ponemos en si la opción
multivalor y este se representa por la palabra encerrada en doble circulo. Debajo de este
doble circulo se pondrían los valores de ese atributo
Y ahora con el icono unimos los atributos con la entidad quedando de la siguiente
manera
Clave primaria
Esto es uno de esos atributos de esta entidad va a ser una clave primaria. Con esto quiere
decir que esa entidad tiene que ser única e irrepetible entre los atributos. Como por
ejemplo el Email. Sin embargo, algunas ocasiones será imposible encontrar un atributo de
valor único e irrepetible por lo que podemos usar un nuevo atributo de nombre ID y se le
conoce como clave primaria sintética.
El atributo etiquetas es doble por que la reglas de negocio indica los siguiente
Los Post deben tener portada, titulo, descripción, categoría y pueden tener uno o más
etiquetas. Es decir que pueden tener varias etiquetas y por ende tiene sub valores. Como
que etiqueta es (color y definición).
Diseño de Base de Datos (Modelo lógico).

En este ejercicio se modificó las reglas del negocio (modelo conceptual) para poder
abarcar ciertas relaciones que no aparecían en el modelo anterior.
Como primer paso es que leas las reglas de negocio y que puedas modificar lo que se hizo
en el capítulo anterior.
Reglas de Negocio (modelo conceptual) actualizado.

1. Los usuarios van a poder Registrarse en la plataforma, y necesitamos almacenar su
nombre, email y dirección.
2. La plataforma nos debe permitir asignar un rol a los usuarios registrados.
3. Los usuarios con un rol deben poder guardar información sobre su biografía, titulo
y sitio web en un perfil de creadores.
4. Los usuarios con el rol de editor van a poder escribir post.
5. La información que debemos almacenar sobre los posts es categoría, titulo, body y
uno o más etiquetas.
6. Los Post van a poder ser comentados, y debemos poder almacenar el mensaje, así
como el nombre de la persona que lo escribió.
7. Las personas con el rol de player van a poder subir videos.
8. Lo que debemos almacenar del video es el título del video, descripción, la URL
donde esta almacenada y etiquetas las cuales pueden ser uno o más.
9. Los videos van a poder ser comentados, y debemos poder almacenar tanto los
mensajes como el nombre de la persona que los escribió.
10. Las etiquetas que se utilicen tanto para los Post como para los videos deben
sacarlo de una lista de etiquetas ya definidas.
11. El usuario debe poder subir una imagen como foto de perfil de manera opcional.
12. Se puede subir una imagen de portada de manera opcional.
Entidades detectadas
Usuarios – Atributos: nombre, email, dirección.
Rol -Atributos: Id, Nombre.
Perfil – Atributos: Biografía, titulo, sitio web.
Post – Atributos: Categoría, titulo, body.
Comentarios – Atributos: Mensaje, usuario que lo escribió.
Video – Atributos: Titulo, descripción, URL.
Etiquetas – Atributos: Id, Nombre.
Imágenes – Atributos: Tipo de imagen
Con lo anterior tendríamos un modelo conceptual como el siguiente:

Con esto nuestro siguiente paso es crear el modelo lógico. Para ello vamos a usar el
programa MySQL Workbench 8.0
Pasos iniciales Diagrama MySQL Workbech.

Pasos para crear un Diagrama En MySQL Workbech.
1. Para ello nos vamos al icono situado en el menú izquierdo.

2. En la siguiente ventana damos clic en el icono situado en el menú superior
3. En la siguiente ventana damos clic al icono para ahora si poder crear

nuestro diagrama.
Esto nos desplegara una ventana como la siguiente

De lado izquierdo tenemos un menú el cual nos permitirá crear una tabla y las
relaciones
Para crear una tabla damos clic en el icono y damos clic sobre el lienzo para crear
nuestra primera tabla
Edicion de la tabla en MySQLWorkbech

Para editar la información de la tabla, desde el nombre así como agregar nuevos
campos con sus respectivos atributos como tipo de dato, si permite valores, nulo,
valores únicos, etc debemos dar doble clic sobre la tabla
Para desplegar una nueva ventana.
En el campo Table Name podemos cambiar el nombre de la tabla.

En la columna Column Name podemos agregar nuevos campos a la tabla solo hay que
dar clic debajo de Column Name.
PK = primary Key
NN = Not Null
UQ = Unique
B= Binary
UN = Unsigned
ZF = Zero Fill
AI= Auto Increment
G = generate.
Al activar cualquiera de estos check box se activaran o no los valores para esta
columna en particular, por ejemplo si queremos que esta columna no tenga valores
nulos y también tenga datos únicos activamos los check Box NN y UQ.
Relación 1 a 1
Tenemos el siguiente diagrama
Para crear una relación de 1 a 1 en MySQL WorkBench debemos primero crear las dos
entidades (usuarios y perfiles) con sus respectivos atributos.
Para poder crear la relación de uno a uno hay que agregarle un campo más a la tabla
Profiles. Este nuevo campo tendrá como característica que será una llave foránea de la
tabla Users.
Con para explicar la llave foránea veamos las siguientes tablas
Para poder hacer la relación a la tabla Profiles se le agrego un nuevo campo (user_id). Este
nuevo campo tendrá 2 condiciones, será una llave foránea de la tabla Users y además
tendrá se definirá como valor único (es decir que no puede repetir su valor).
La llave foránea en un campo sirve para que ese campo pueda ingresar valores que han
sido definidos como llave (id) de una tabla. Es decir, la tabla User tiene como llave los
valores 1,2,3 por lo que si en el campo User_id de la tabla Profiles trataran de poner un
valor 4 este no lo permitiría. En otras palabras, una restricción de llave foránea significa
que los únicos valores que puede ingresar corresponde a los valores de la llave primaria de
otra tabla.
Para crear la relación de 1 a 1 en MySQL WorkBench damos clic en el icono situado

en el menú izquierdo.
Primero damos clic primero a la tabla que llevara la llave foranea y luego damos clic a la
tabla que deseamos sea referencia de la llave foránea (por ejemplo, primero damos clic en
la tabla profiles y luego damos clic en la tabla Users)
Esto creará automáticamente el nuevo campo (users_id) y ya tendrá la restricción de llave
foránea usando como referencia la tabla users. Damos doble clic sobre la tabla profiles
para activar la casilla de selección de valor único (UQ =unique).
La convención de Laravel dicta que los Id deberán de ser en singular por lo que
deberíamos de editar el nombre users_id por user_id.
Relación 1 a muchos
Esta relación es exactamente igual a la relación 1 a 1 explicada en el capítulo anterior
(relación 1 a 1), la diferencia es que el campo adicional requerido (user_id) para hacer la
relación únicamente se le asignará la llave foránea y permitir que se puedan repetir
registros, es decir no se activara la casilla UQ (unique).
Para crear la relación de 1 a muchos en MySQL WorkBench damos clic en el icono

situado en el menú izquierdo.
Primero damos clic primero a la tabla que deseamos crear el campo nuevo (la que tendrá
la llave foránea) y luego damos clic a la tabla que deseamos sea referencia de la llave
foránea (por ejemplo, primero damos clic en la tabla post y luego damos clic en la tabla
Users)
Esto creará automáticamente el nuevo campo (users_id) y ya tendrá la restricción de llave
foránea usando como referencia la tabla users. También mencionar que este campo
(user_id) permitirá registros duplicados.
La convención de Laravel dicta que los Id deberán de ser en singular por lo que
deberíamos de editar el nombre users_id por user_id.
Relación de muchos a muchos

Para esta relación se tienen primero que crear las dos tablas y para poder hacer la relación
se tiene que crear una tercera tabla. Esta tabla servirá como pivote y tendrá como primer
campo id_taba1 e id_tabla2.
El campo id_tabla1 tendrá la restricción de llave foránea con respecto a la tabla 1.
El campo id_tabla2 tendrá la restricción de llave foránea con respecto a la tabla2.
Usando la convención de Laravel, indica que deberá usarse ambos nombres (el nombre de
cada tabla) y combinarlos, además de ir en singular. Esta combinación deberá ser en
orden alfabético. Por ejemplo si tenemos la tabla Users y la tabla Roles el nombre de la
tercera tabla deberá ser Role_User.
Para crear la relación de muchos a muchos en MySQL WorkBench damos clic en el icono
situado en el menú izquierdo.
Para ello primero damos clic en la tercera tabla y luego en la tabla que deseamos hacer la
relación (tabla1) con esto se crea el primer campo como llave foránea (id_tabla1).
Repetimos la operación, dar clic en la tabla 3 para luego dar clic en segunda tabla que
hacemos la relación (tabla 2) y con esto se crea el segundo campo (id_tabla2)
Relación polimórfica 1 a 1
Las relaciones polimórficas son aquellas donde 3 tablas se relacionan. Por ejemplo, en el
siguiente diagrama conceptual se tienen 3 entidades (tablas que se van a relacionar):
Usuarios, Imagen y Post.
La relación de usuarios a imagen es de 1 a 1.
La relación de Post a Imagen también es de 1 a 1.
Para poder relacionar estas 3 tablas, vamos a utilizar la tabla que tienen en común estas 3
tablas. En este ejemplo la tabla en común es la tabla imagen.
Para poder hacer la relación necesitamos realizar 3 pasos.
1. A la tabla Imagen además de sus campos (id, URL) le agregamos 2 campos más:
a. Imageable_id . este campo hará la relación de esa fila ya sea con la tabla
usuarios o la tabla Post. Por ejemplo, asumiendo que el primer y segundo
registro de esta tabla tengan el valor 1
b. Imageable_type. En este campo lleva por valor el nombre del modelo
encargado de administrar la tabla, ya sea la tabla1 o la tabla2. En este
campo es el que indica de quien es el id de imageable_id.
En esta última imagen indicamos que el registro 1 de la tabla IMAGES en el campo
imageable_id pertenece a la tabla User y el segundo registro de la tabla Images pertenece
a la tabla Post.
2. Se realizará las siguientes configuraciones a las dos columnas.

a. Las 2 nuevas columnas (imageable_id e imageable_type) se definirán
ambas como llave primaria. Es decir, la llave primaria será la combinación
de las columnas imageable_id e imageable_type. A esto se la le conoce
como llave primaria compuesta
b. Como saben las llaves primarias no se pueden repetir por ende ambas
columnas se configurarán automáticamente (al marcarlas como llave
primaria) para que los valores de cada registro sean únicos (no se repitan).
3. Al tener la llave primaria como combinación de las columnas imageable_id e
imageable_type no es necesario ya la columna Id de la tabla Images por lo que la
eliminaremos.
Cabe mencionar que dejar la columna ID en la tabla sirve únicamente para cuando
es una relación de uno a muchos o muchos a muchos ya que la se permitiría tener
valores repetidos entre la combinación entre ambas columnas (imageable_id e
imageable_type).
Quedaría entonces para la tabla Images las siguientes columnas:
a. URL
b. Imageable_id
c. Imageable_type
Para crear este diagrama en MySQL WorkBech primero necesitamos crear las 3 entidades.
En el caso de la entidad (tabla 3) que es la tabla en común cuando se creen los campos
imageable_id e imageable_type se marcan ambas se marcan como llave primaria y listo.
Lo que nos queda como un registro
Cabe señalar que en esta tabla no se hizo la conexión ya que la columna

imageable_id no se puede configurar como llave foránea de una tabla porque necesita
aceptar valores (los id) tanto de la tabla user como de la tabla Post. Es decir, la relación de
uno a uno para que el campo se configure como llave foránea dejaría fuera a la otra tabla
esto debido a que un campo solo se puede definir como llave foránea de una sola tabla.
Relaciones polimórficas uno a muchos

La forma como se define esta relación es muy similar a la anterior. Tenemos 3 tablas
donde una de las tablas sirve de pivote (o relación) entre las 2 tablas. En este ejemplo
tenemos las tablas Post, Videos y Comments, donde Comments hace la relación entre la
tabla Post y la tabla Videos por lo tanto será la tabla pivote.
Como podrá observar la tabla Comments se le agregaron 2 campos más: commentable_id
y el de commentable_type. Como vemos en el ejemplo es requerido tener registros
repetidos en la combinación de los campos commentable_id y comentable_type. Por lo
que en este caso si es requerido el campo ID como llave primaria (cabe recordar que la
llave primaria no permite que existan registros repetidos).
Para crear el diagrama modelo lógico en Mysql Workbench es primero creamos las dos
tablas principales y posteriormente creamos la tabla que será la que hará la relación. Esta
tabla que es la relación se crean los campos commnetable_id y Commentable_type
En este caso tampoco se utilizan los iconos del menú de la izquierda ya que no
podemos crear una llave foránea puesto que el campo commentable_id tiene que
permitir valores tanto de la tabla Post como de la tabla videos.
Relaciones polimórficas muchos a muchos.

En este ejemplo se va a realizar una relación simultanea entre 3 tablas de muchos a
muchos. Para poder llevar a cabo esta relación se requiere la creación de una cuarta tabla.
El nombre que llevara esta cuarta tabla tiene que ser un nombre significativo. Por
ejemplo, si la tabla se llama tags (etiquetas) el nombre que llevaría la cuarta tabla seria
taggables.
En esta cuarta tabla va a tener 3 columnas.

La primera columna se va a relacionar los id de la tabla tags.
La segunda columna tendrá el valor del id ya sea de la tabla Post o la tabla videos.
La tercera columna (taggable_type) definirá si el valor de la columna taggable_id hace
referencia a la tabla Post o a la tabla videos.
Como la columna tag_id (de la tabla taggables) hace relación únicamente a la columna id
de la tabla Tags, entonces si podemos definir la columna tag_id (tabla taggables) como
llave foránea de la tabla Tags.
Para crear el diagrama modelo en MySQL WorkBench primero creamos las 4 tablas
requeridas. Recuerde que la cuarta tabla será la que la que hará de pivote entre las 3
tablas por lo que tendrá los campos id – llave primaria, taggable_id y taggable_type.
Creada las tablas damos clic en el icono para crear la relación de uno a muchos entre
la tabla Tags y la tabla Taggables. Primero damos clic donde ira el campo que tendrá la
llave primaria y posteriormente damos clic en la tabla que será la referencia.
En el siguiente capitulo vamos a ver un paso más que es el de normalización.
Normalización de la base de datos.

La normalización nos permite poder extraer registros de nuestra base de datos de una
manera mucho más optima y al mismo tiempo evitar que haya redundancia de
información
Nos basáremos en 3 formas normales para la normalización de la base de datos
1ra forma normal.

Esta forma indica que los datos que almacenemos en la BD deben ser datos atómicos.
Un dato atómico significa llegar hasta el último nivel, es decir que ese nivel ya no se podrá
poder dividir en más partes.
Por ejemplo, si tenemos el campo dirección como se muestra a continuación.
Aquí el campo dirección lo tenemos como un solo campo (sin embargo, es un campo
compuesto) y por ende en este mismo campo estaría la calle, la colonia, el municipio,
ciudad, estado, código postal, etc. Y por supuesto que cada usuario va a escribir su
dirección sin ninguna estandarización. Unos usuarios solo pondrán calle sin número, otros
no pondrán la ciudad o su código postal, etc. Lo que nos impide conocer por ejemplo
todos aquellos que pertenecieran a una ciudad en especifico.
Entonces cuando tengamos un campo compuesto, la primera forma normal nos indica que
debemos desdoblarlo como se muestra en la siguiente imagen.
En vez del campo dirección, este se dividió en más campos como calle, numero, distrito,
ciudad.
Otra opción es que el campo dirección lo hubiéramos creado en otra tabla (como un
catálogo) y en la tabla users le pongamos el campo id_direccion como llave primaria de la
tabla dirección y que sea una relación de uno a uno.
2da forma normal
Esta segunda forma normal no indica que
1. Nuestras tablas ya deben tener la 1ra forma normal
2. Debe existir una dependencia funcional completa de todos los campos de una
tabla con su clave primaria. Este punto vigila que no haya redundancia de
información.
Para explicar el punto 2 observemos las siguientes tablas
Enfocándonos en la tabla Comments, entonces el punto 2 nos indica que el campo

mensaje, nombre, comentable_id y comentable_type deben de tener una dependencia
funcional del campo id.
Si yo elimino el registro que tiene el id 1 todos los otros registros de esta fila igual
deberían de eliminarse de toda la base de datos los registros como tales ya no deben de
estar en ninguna tabla de toda la base de datos. Sin embargo, el registro “Victor Arana”
del campo nombre no se elimina de la base de datos ya que este registro igual aparece en
la tabla USERS. Es decir, hay redundancia de información.
Por lo tanto, se puede decir que el campo nombre de la tabla Comments no tiene una
dependencia funcional completa con respecto al campo id de esta misma tabla, no se
cumple la condición 2.
Para solucionar esto el campo nombre de la tabla Comments lo cambiamos por el campo
id_user
De esta forma aun sabremos que mensaje le pertenece a que usuario, además no
tenemos redundancia de información y lo mas importante ahora si todos los campos (sus
registros) tienen una dependencia funcional completa con respecto a la llave primaria
(campo id).
En MySQL Workbench quedaría de la siguiente forma.
3ra Forma normal.

Esta nos indica lo siguiente:
1. Nuestras tablas deben tener la 2da forma normal.
2. En nuestras tablas no debe existir una dependencia funcional transitiva con
respecto a la llave primaria
Veamos la siguiente tabla
El punto 2 de la tercera forma normal nos dice que cada campo debe depender
enteramente del campo id (llave primaria). Es decir, el campo name (el articulo) ese
registro únicamente depende del campo id. Pero si observamos el campo categoría
depende directamente de que articulo se haya puesto (es decir depende del campo name
y el campo body) ya que si el articulo habla de muebles no podría llevar una categoría
desarrollo web o diseño web.
Explicado de otra manera el campo categoría si tiene una relación con el campo id pero no
es una relación directa. La relación directa del campo categoría es con el campo name y el
campo body.
Para solucionar la existencia de una dependencia funcional transitiva (punto 2 de la

tercera forma normal).
1. Creamos una tabla categoría
2. El campo categoría de la tabla Post lo cambiamos a categoría id
En MySQL Workbench su representación seria de uno a mucho como se muestra a

continuación.
Diseño Físico Relación 1 a 1

Esto consiste en pasar el diagrama realizado en MySQL Wrokbench a código SQL a través
de la creacion de mgraciones en Laravel.
Empecemos por abrir nuestro proyecto en visual Studio code ( o podemos crear uno
nuevo con Jetstream)
El siguiente paso es crear estas dos entidades:

Tipos de entidades
¿La pregunta es cuál de estas dos entidades debemos crear inicialmente?, La respuesta es:
la entidad fuerte, ¿pero que es una entidad fuerte? Para esto debemos saber que existen
entidades dos tipos de entidades:
Las entidades fuertes son aquellas que no dependen de otra entidad.
Las entidades débiles son aquellas entidades que depende de otra entidad.
Para entender mejor en el diagrama tenemos la entidad users y la entidad profiles. La

entidad users puede existir sin la necesidad de la entidad profiles, es decir pueden existir
todos los usuarios sin importar si existen la tabla de profiles. Pero la tabla profiles su
existencia es debido a que se le esignaran a los usuarios, por lo que la tabla profiles no
puede existir si no existir si no existiera una tabla de usuarios. En otras palabras, la
existencia de un perfil esta amarrado con la existencia de un usuario pero un usuario
puede existir sin la existencia de un perfil.
Creando el archivo migrate

Podemos crear el archivo migrate y model en una sola línea creando el archivo model de
la siguiente manera con un sufijo que el que va a crear el archivo migrate.
php artisan make:model profile -m
Para crearlo de manera manual hacemos los siguiente:

Procedemos a crear la tabla de usuarios en nuestro proyecto de laravel (migración)
Si observamos nuestro proyecto en la ruta “database/migration” observamos que ya
contamos con un archivo migración users, es decir ya contamos con la migración para
crear la tabla users. Entonces procedemos a crear la tabla profile.
Para crear la tabla de profiles se abre la terminal de visual code (esto en nuestro proyecto
laravel) y escribimos el siguiente comando
php artisan make:migration create_profiles_table

al crear la migración se anexa el archivo create_profiles_table dentro de la carpeta
“database/migrations”
Ingresamos al archivo create_profiles_table.php y empezamos a codificar parra anexar los

campos de la tabla title, biografía, website y user_id. Cabe señalar que este ultimo campo
user_id tiene que ser llave foránea de la tabla users.
Entonces el código para definir los campos seria.

{
Schema::create('profiles', function (Blueprint $table) {
$table->id();
$table->string('title', 45);
$table->text('biografia');
$table->string('website', 45);
$table->unsignedBigInteger('user_id')->unique();
$table->foreign('user_id')->references('id')->on('users');
});
}
En el siguiente capitulo se explica insignedBigIntener() y el método foreing()
Llave foránea en archivos migrate de laravel

Para crear un campo de llave foránea en Laravel es necesario ponerlo del mismo tipo del
campo al que queremos haga la referencia, en este ejemplo deberá de ser del mismo tipo
del campo id de la tabla Users.
Si observamos los campos de la tabla Users (archivo migration) observamos el siguiente

código
{
Schema::create('users', function (Blueprint $table) {
$table->id();
$table->string('email')->unique();
$table->timestamp('email_verified_at')->nullable();
$table->string('password');
$table->rememberToken();
$table->foreignId('current_team_id')->nullable();
$table->string('profile_photo_path', 2048)->nullable();
});
}
Como podrán observar el campo id se crea con el método id(). Este método di() establecer
por defecto los valores como entero grande sin signo y ende el campo user_id que vamos
a crear deberá de llevar la restricciones de bigInteger, unsigned y solo permita valores
únicos (no repetidos). Recuerde que es una relación de uno a uno.
$table->unsignedBigInteger('user_id')->unique();
Definido el campo user_id el siguiente paso es decirle que este campo tendrá una
restricción de llave foránea de la siguiente manera:
$table->foreign('user_id')->references('id')->on('users')-
>onDelete('cascade');
De esta manera se especifica que user_id será llave foránea (foreing) en referencia al
campo id (references) de la tabla users (on).
El método onDelete(). Se establece para definir que acción tomar en caso que se elimine
un registro de la tabla users y este relacionado con un registro de la tabla profile. Este
metdoTiene dos funciones:
 cascade, si se borra un registro de la tabla users y este usuario tiene un registro
(esta relacionado) con un regstro de la tabla profiles, al borrar al usuario (registro
de la tabla users) también se borraría el registro que tiene relación con este
usuario en la tabla profles.
 set null: Al eliminar un registro de la tabla users (eliminar un usuario) el o los
registros que tengas relación con este usuario en la tabla profile se definirían como
valor nulo. Para este registro hay que definir que este campo permita valores nulos
con el método nullable()
$table->unsignedBigInteger('user_id')->unique()->nullable();
Un ejemplo de cuando usar set null es por ejemplo que si se elimina un usuario de
la base de datos y este usuario a escrito artículos, al eliminar el usuario quisiera se
sigan conservando sus escritos y mostrándolos en la sección de los artículos, por
ende debería de establecer este valor como set null, así al eliminar el usuario sus
escritos seguirán conservándose en la base de datos.
Creando el archivo model
Podemos crear el archivo migrate y model en una sola línea creando el archivo model de
la siguiente manera con un sufijo que el que va a crear el archivo migrate.
php artisan make:model profile -m
Para crear el archivo modelo de manera manual hacemos lo siguiente:

Vamos a crear el modelo que se va a encargar de administrar esta tabla con el siguiente
comando (en línea de comando de visual code)
php artisan make:model Profle
Note que se puede escribir el nombre del modelo en Mayúscula la primera letra. Esto va a
crear el archivo Profile.exe en la carpeta “app/Models”.
Una vez creado el archivo artisan migrate lo ejecutamos para que se cree la tabla en la
base de datos con el siguiente comando en línea de comando de visual Code
php artisan migrate
En caso de error de conexión es importante que haya definido las credenciales de acceso
así como el nombre de la base de datos en el archivo .env en la raíz del proyecto.
¿cómo puedo hacer para que cuando recupere el registro de un usuario también
tenga acceso al registro de la tabla profiles relacionado con ese usuario?
Como recordaran se hizo una relación de uno a uno de la tabla usuarios a la tabla profiles,
donde la tabla profiles tiene un campo llamado user_id la cual es una llave foránea de la
tabla user_id.
Para poder acceder a al registro que esta relacionado con el usuario que acabamos de
obtener su registro debemos recordar que eloquen trata cada registro como si fuera un
objeto. Un objeto que es instanciado de su modelo.
Recuperando los registros de la tabla 2 al acceder a un registro de la tabla1

En este ejemplo la tabla 1 será la tabla users y la tabla 2 será la tabla profiles. Lo que
deseamos hacer es que al consultar (obtener) un registro de un usuario de la tabla users,
al mismo tiempo podamos acceder al registro de la tabla profiles relacionado con ese
usuario.
Primero hay que recordar que “eloquen” trata cada registro (consulta) como si fuera un
objeto y este objeto es una instancia de su modelo (el modelo designado para trabajar la
una tabla en específico). Por lo tanto:
Abrimos el modelo de la tabla 1 el cual en este ejemplo es el modelo User y al final del
código (dentro de la clase) le vamos a agregar un nuevo método el cual vamos a darle el
nombre de profile
public function profile()
{

}
Este método es el que se va a encargar de recuperar el registro (tabla profile-tabla2) que

le corresponde al usuario del cual obtuvimos su registro en la tabla users (tabla1).
Como ejemplo dentro del método vamos a meter manualmente el código para recuperar
el registro.

{
$profile=Profile::where('user_id', $this->id)->first();
return $profile;
}
En una variable llamada profile recuperamos el registro de la siguiente manera, llamamos

al modelo Profile y le pasamos el método where. En el método where le voy a indicar l
osiguiente: quiero que filtres los registros cuyo user_id (primer parámetro) coincida con el
id del registro actual (segundo parámetro) (recuerde que estamos accediendo a los
registros de la tabla Users) y finalmente le indico que me devuelva el primer registro
(método first) que coincida con estos parámetros que le hemos especificado. Como último
paso le pedimos que regrese el valor de la variable profile en el return.
Otra forma de acceder al registro con menos código es la siguiente:

{
return $this->hasOne(Profile::class);
}
Dentro del método hasOne llevaría como parámetro el modelo que maneja la clase
(Profile) y su método class.
Como parámetro del modelo hasOne podimos haber puesto
return $this->hasOne('App\Models\Profile');
Esto es por que si ponemos como parámetro Profile::class regresa la ruta ‘App\Models\
Profile’. Es importante destacar que si ponemos Profile:class como parámetro del método
“hasONE” debemos indicar que vamos a usar ese modelo poniendo el código después del
namespace (al principio del código).
use App\Models\Profile;
Entonces recapitulando el código

$profile=Profile::where('user_id', $this->id)->first();
Es exactamente lo mismo que
return $this->hasOne(Profile::class);
Pero con mucho menos código.
Importante el método hasOne() está considerando que seguiste la convención de laravel

por lo tanto, da por echo que la llave primaria de la tabla Users se llama id y la llave
foranea de la tabla Profile es user_id
En caso que no se haya seguido la convención de laravel se tiene que especificar

explícitamente en los parámetros del método “hasOne” los nombres de la llave foranea y
el nombre del campo id de la siguiente manera:
return $this->hasOne('App\Models\Profile', 'foreing_key', 'local_key');
donde foreing_key es el nombre del campo que es la llave foranea (tabla profiles) y el
local_key es el nombre del campo id(tabla Users).
Recuperando los registros de la tabla 1 al acceder a un registro de la tabla2

En este ejemplo la tabla 1 será la tabla profiles y la tabla 2 será la tabla Users. Lo que
deseamos hacer es que al consultar (obtener) un registro de un Profile de la tabla Profile,
al mismo tiempo podamos acceder al registro de la tabla Users relacionado con ese
usuario. Es decir es el proceso inverso del subcapítulo anterior.
En este caso se trabajara en el archivo modelo Profile.

Creamos el nuevo método que obtendrá los registros de la tabla Users relacionado con
ese profile de la siguiente manera:
class Profile extends Model
{
use HasFactory;
public function user()

{

}
}
Si recuperamos de manera manual el registro tendríamos el siguiente código:

{
$user= User::find($this->user_id);
return $user;
}
Donde en la variable user vamos a llamar al modelo User y a su método find. En esta
ocasión podemos usar el método find ya que vamos a realizar la búsqueda por el id y le
pasamos como parámetro justamente ese id que en este caso lo esta almacenando
user_id.
Como se menciono el anterior código es el proceso Manuel para recuperar el registro de

la tabla users al obtener el registro de la tabla profiles.
Existe un código mas simplificado para obtener un registro uno a uno en el proceso
inverso (es decir al acceder al registro de la tabla profiles obtenemos simultáneamente los
registros de la tabla users).
Por lo tanto este código

$user= User::find($this->user_id);
Es lo mismo que el siguiente código
return $this->belongsTo('App\Models\User');

{
return $this->belongsTo('App\Models\User');
}
}
El método belongsTo() da por echo que la llave foranea es user_id y la llave priemara de la
tabla users se llama Id. En caso contrario hay que pasar como segundo parámetro el
nombre de la llave foranea y como tercer parámetro el nombre del campo llave (tabla
Users).
Haciendo pruebas para recuperar los registros en línea de código.

Para ello vamos a usar tinker. En línea de comando de visual Code escribimos
php artisan tinker + enter
luego le decimos que queremos usar el modelo user
use App\Models\User; + enter
recatamos al usuario cuyo id es 1 con la siguiente instrucción:
$user = User::find(1); + enter
Ahora para acceder a la información del perfil (tabla profiles) se hace de la siguiente
manera:
$user->profile + enter (no lleva ; )
Haciendo el proceso contrario ahora obteniendo primero el registro de la tabla Profile y
luego accediendo al registro de la tabla Users relacionado con el registro profile
Le decimos que vamos a usar el modelo profile
use App\Models\Profile; + enter
ahora obtenemos el perfil con el id 1
$profile = Profile::find(1); + enter
Ahora obtenemos el registro de la tabla users relacionado con este perfil (tabla Profile)
$profile->user + enter (sin ; )
Es importante comentar que accedemos al registro como una propiedad de ese objeto (al
escribir $profile->user es como si fuera una propiedad) sin embargo user se definió como
un método dentro de la clase del modelo.
Esto ocurre ya que el método belongTo() y el método hasOne() al ejecutarse genera
propiedades dinámicas. Es decir, le está agregando de manera dinámica la propiedad user
al modelo Profile y la propiedad profile al modelo user. Esto lo hace así por un tema de
eficiencia ya que al recuperar el registro automáticamente se carga la información de
todas sus relaciones en forma de propiedades y de esa manera no tenemos que esperar a
ejecutar un método para que empiece a obtener esos registros.
Por eso es importante usar los métodos que nos proporciona Laravel para generar las
relaciones y no hacerlo con las consultas “manuales”.
Diseño Físico Relación 1 a muchos.

Esta relación es exactamente igual a la relación 1 a 1 explicada en el capítulo anterior
(relación 1 a 1), la diferencia es que el campo adicional requerido (user_id) para hacer la
relación únicamente se le asignará la llave foránea y permitir que se puedan repetir
registros, es decir no se activara la casilla UQ (unique).
En este ejercicio vamos a crear el siguiente diagrama. En este diagrama es una relación de
uno a muchos, de la cual la tabla users y la tabla categorías son entidades fuertes y la tabla
post es una entidad débil. Es decir 2 tablas van a conectarse con una tercera tabla.
Primero se van a crear las entidades fuertes (tabla users y tabla categorías)
Creamos la entidad débil (tabla post), en esta entidad como observamos en el diagrama se
crean dos campos user_id y categorías_id que servirán como llaves foráneas.
Por ultimo creamos las relaciones
Creando archivos migration y model en una sola línea de comando

Teniendo en cuenta la relación hacemos lo siguiente:
Para crear la tabla categorías se debe crear los archivos migration y los archivos models (la
tabla migration crear la tabla física en la base de datos y el archivo model es el encargado
de administrar la tabla).
Para crear los archivos en una sola línea de comando se escribe lo siguiente (recuerde que
el archivo model se crea en singular.
php artisan:make model Categoria -m
Esto creará el archivo modelo y al mismo tiempo creará el archivo migrate con el siguiente
nombre create_categorias_table
Creacion del archivo model y al mismo tiempo otros archivos (factory, seeder, controller,
etc)
Si además de la migración necesitamos que se cree un controlador escribimos
php artisan:make model Categoria -mc
Si además de la migración necesitamos que se cree un controlador y un seeder

php artisan:make model Categoria -mcs
Si además de la migración necesitamos que se cree un controlador, un seeder, un factory
php artisan:make model Categoria -mcsf
Si quisiéramos que nos cree todos los anteriores (model, migrate, controlador,seede,
factory) poneos a de all.
php artisan:make model Categoria -a
Contenido del archivo migrate

El código del archivo migrate de acuerdo con el diagrama que se subió quedaría de la
siguiente manera:
{
Schema::create('categorias', function (Blueprint $table) {
$table->id();
$table->string('name',45);
});
}
Creamos el archivo modelo y migrate para la tabla Post.
php artisan make:model Post -m
El código del archivo migrate quedaría de la siguiente manera,

Para definir un campo como llave foránea se realiza en dos pasos:
 Se define el tipo de datos del mismo tipo que tiene el campo id de la tabla donde
se hará la relación. En este caso se tienen que crear con
“unsignedBigInteger(‘nombre_campo’)”. Esto es porque cuando definimos un
campo como $table->id(); este campo le pone de nombre id y lo configura como
sin signo, y big integer. Recuerde que una llave foránea tiene que definirse de la
misma manera como está definido el campo llave de la tabla donde se hará la
relación.
 Como segundo paso se hace la relación con los siguientes métodos
foreing(‘nombre_campo’)->references(‘id’)->on(‘tabla’).
 Definir la acción a realizar, es decir que acción realizara si en la tabla relación (tabla
users por ejemplo) se elimina un registro que está relacionado con el registro de
otra tabla (tabla post). Esto se logra con el método onDelete(‘opcion’), el cual tiene
2 opciones
o cascade.- este elimina automaticamente el registro de la tabla Post al
borrarse un registro de la tabla users.
o set null.- Este establece en nulo el valor del campo user_id en caso de
eliminar un registro de la tabla users. Importante que si se usa esta opción
se defina como nullable el campo user_id
El código completo del archivo migrate seria de la siguiente manera:

{
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->text('body');
$table->unsignedBigInteger('user_id')->nullable();
$table->unsignedBigInteger('categoria_id')->nullable();
$table->foreign('user_id')->references('id')->on('users')
->onDelete('set null');
$table->foreign('categoria_id')->references('id')
->on('categorias')->onDelete('set null');
});
}
Recuperar registro de tabla 1 al consultar registro de tabla 2.

Esto se refiere que si consultamos a un usuario en la tabla users también recuperemos los
registros del Post relacionados con este usuario.
Para ello abrimos el archivo modelo de la tabla 2 (ejemplo users.php ubicado en la ruta
app/Models/user.php) y creamos el método post (dentro de la misma clase). Para
recuperar todos los registros de este usuario usamos el método “hasMany”
//Relacion de uno a muchos

public function posts(){
return $this->hasMany('App\Models\Post');
}
Recuperar registros de forma inversa de tabla 2 al consultar registros de la tabla1

(Relación Inversa de Post a User)
En este proceso consultamos un registro del Post y al mismo tiempo obtenemos el registro
del usuario al que pertenece el Post. Para ello en el archivo modelo de la tabla 1 (en este
ejemplo el archivo post.php ubicado en app/models/post.php) y creamos el método user.
Dentro de este método vamos a usar el método “belongsTo” para recuperar los registros.
public function user(){
return $this->belongsTo('App\Models\user');
}
Haciendo pruebas para acceder a los registros en línea de comando

Nota: recuerde que cuando se hace la consulta accedemos a los métodos belongsto y
hasMany como si fueran propiedades. Por ejemplo
En línea de comando usamos tinker

php artisan tinker
definimos que vamos a usar el modelo user.php

use App\Models\User;
recuperamos un registro para pruebas (en este ejemplo el registro cuyo id es 1)

$user = User::find(1);
Recuperamos los registros de la tabla Post que estén relacionados con el usuario cuyo id
es 1. Recuerde que aunque el Posts es un método accedemos a este como si fuera una
propiedad. (en el capitulo anterior se explico el por que se crean estas propiedades
dinámicas por tema de eficiencia)
$user->posts:
Diseño Físico Relación muchos a muchos

Una relación de muchos a muchos son 2 tablas las cuales necesitan de una tercera tabla
para poder hacer la relación
La convención dicta que para la creación de la tabla que hace la relación entre las otras 2
tablas tiene que llevar por nombre las siguientes reglas:
 singular,
 minúsculas,
 orden alfabético.
Es decir, si la tabla 1 se llama users y la tabla 2 se llama roles, la creación de la tabla 3
debe llevar por nombre role_user (la r esta antes de la s). Esta tercera tabla tiene dos
campos: user_id y role_id
El campo user_id debe ser llave foránea de la tabla Users (campo id) y el campo role_id
debe ser llave foránea de la tabla roles (campo id). Ambos campos (user_id y role_id)
permiten duplicidad de datos.
En caso de que aún no se haya creado la tabla 2 (roles) creamos su archivo modelo y su
archivo migración
php artisan make:model Role -m
El archivo migration tendrá el siguiente código en su método up()

{
Schema::create('roles', function (Blueprint $table) {
$table->id();
$table->string('name',45);
});
}
Algo por resaltar es que al crear una tabla se crea su migración y su archivo modelo, pero
cuando es una tabla intermedia entre 2 tablas, la tercera tabla no se crea el archivo
modelo solo su archivo migración. Solo se usaran los archivos modelos de las tablas 1 y 2.
Por ende solo se crear el archivo migrate de la tabla 3
php artisan make:migrate create_role_user_table
El archivo migration para esta tercera tabla tendrá el siguiente código en su función up()
{
Schema::create('role_user', function (Blueprint $table) {
$table->id();
$table->unsignedBigInteger('role_id');
$table->unsignedBigInteger('user_id');
$table->foreign('role_id')->references('id')->on('roles')-
$table->foreign('user_id')->references('id')->on('users')-
});
}
El método foreing indica que el parámetro que se le pase será una llave foránea
El método reference indica que será llave foranera del campo llamado “id”
El método on, indica en su parámetro la tabla a la que pertenece el campo que se indica
en el método reference.
El método onDelete, indica que acción se realizara en caso de que se borre un registro de
la tabla externa donde se hace referencia. Tiene dos posibles valores
 Cascade indica eliminar igual este registro
 set null indica que se ponga como valor null. Si se esoje esta opción se debe indicar
que este campo aceptara valores nulos con el método nullable()
$table->unsignedBigInteger('role_id')->nullable();
Creando la relación a nivel de modelos

En el modelo user.php creamos el método roles() y para obtener los registros de la tabla
roles al consultar los registros de la tabla users usamos el método belongsToMany()
//relacion muchos a muchos
public function roles(){
return $this->belongsToMany('App\Models\Role');
}
Ahora hacemos lo mismo, pero en el modelo de la tabla roles (archivo role.php)

//relacion muchos a muchos
public function users(){
return $this->belongsToMany('App\Models\User');
}

Apuntes Laravel

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

Apuntes Laravel

Cargado por

Copyright:

Formatos disponibles

CURSO LARAVEL 8

Apuntes del curso en CodersFree

05.- GRUPO DE RUTAS DE CONTROLADORES.................................................................20

07.- Introducción al manejo de base de datos con Laravel.............................................25

09.- Como crear migraciones en Laravel........................................................................31

12.-Creacion de datos de “prueba” en las tablas...........................................................44

17 - Como agregar o actualizar registros desde un formulario.......................................75

18 – Validar formularios en Laravel...............................................................................87

25 – Como enviar emails con Laravel...........................................................................122

28 – Laravel ahora usa Vite ¿Qué ocurrió con Webpack?.............................................158

Diseño de base de datos (Modelo conceptual).............................................................192

Diseño de Base de Datos (Modelo lógico)....................................................................202

Diseño Físico Relación 1 a muchos...............................................................................230

En las propiedades de sistema abrimos la opción Variables de entorno… (de la sección

En la ventana editar variable de entorno buscamos la ruta que tiene xampp.

Es importante escribirlo en minúsculas el nombre de proyecto

02. INSTALACIÓN DE EXTENSIONES

Laravel Blade Snippets

Laravel goto view

Spanish Languaje Pack for Visual Studio

Tailwind CSS IntelliSense

Definir una ruta

Definir una segunda ruta (URL )

Usar variables en las rutas

Definir más de una variable en la ruta

Nota: el if que evalúa la variable $categoria, es la variable que se denifio en la función

04.- CONTROLADORES EN LARAVEL QUE SON Y PARA

Es importante resaltar que: en “web.php” definimos la ruta y en el controlador definimos

Asignar el control de una ruta a un controlador

Llamar controladores versión 8 Laravel

Ya definido el “use” podemos hacer uso del controlador de la siguiente manera:

Ahora dentro del controlador (archivo “HomeController.php”) definimos el método que va

class HomeController extends Controller

Definiendo controlador para rutas diferentes a la raíz del proyecto

Por ejemplo, si tenemos el siguiente código (archivo “web.php”):

Route::get('cursos/{id}', function ($id) {

18. En el archivo “web.php” definimos el uso de ese controlador con el código:

Route::get('cursos', [CursoController::class, 'index']);

Route::get('cursos/create', [CursoController::class, 'create']);

Route::get('cursos/{id}', [CursoController::class, 'show']);

public function show($id){} //archivo CursoController.php

Llamar controladores versión 7 Laravel

Para definir una ruta diferente a raíz en la versión 7 es de la siguiente manera:

protected $namespace = 'App\Http\Controllers';

En el mismo archivo en la siguiente función se agrega el siguiente código:

En la versión 8 de Laravel esta propiedad namespace ya no viene definida dentro del

05.- GRUPO DE RUTAS DE CONTROLADORES.

Existen 3 rutas que utilizan la misma clase “CursoController::class” y estas se pueden

06.- VISTAS EN LARAVEL.

“Home.php” está en raíz de la carpeta “view”. “Index.php”, “créate.php” y “show.php”

Método View pasando parámetro ruta raíz

Método view pasando parámetro ruta diferente a raíz

Método View pasando parámetro ruta con variable

public function show($id){

“view(‘ruta’, [‘nombreCualquiera’ => $parámetro]);”

en el ejemplo, la variable $parámetro es el parámetro que recibe el método “show()”.

<h1>Página curso de: <?php echo $ NombreCualquiera; ?>desde el view</h1>

La sintaxis de arriba se puede abreviar usando el método compact(‘NombreCurso’), este

compact('NombreCurso'); //este se traduce en ['NombreCurso'=>$NombreCurso]

por lo que el método View se puede simplificar como se muestra a continuación

//Código sin Simplificar

Uso de plantillas en Vistas (Blade)

En HTML si tenemos la misma estructura podemos definir una plantilla.