Creamos un nuevo proyecto laravel
composer create-project laravel/laravel colegio

Vamos a crear la BD colegio que va a tener la tabla Alumno
image.png
En el fichero .env
image.png
Migraciones
Creamos la migración de la tabla
php artisan make:migration create_alumnos_table
Si queremos hacer la migración y el modelo a la vez ( tened en cuenta que se va a crear siguiendo las convenciones de laravel: nombre del modelo.- en nuestro caso será Alumno y la tabla asociada a ese modelo sera alumnos)
php artisan make:Model Alumno -m
image.png

Vamos a las migraciones, donde se ha creado una nueva para alumnos (la tabla es alumnos)
image.png
Que contiene
una clave de identificación (por defecto autoincrementable)
dos columnas ( created_at y updated_at ) creadas por el método de marcas de tiempo .
image.png
Vamos a modificar la tabla con los campos que queremos
$table->string('nombre_apellido', 75);
$table->integer('edad');
$table->string('telefono', 35)->nullable();
$table->string('direccion', 75)->nullable();
image.png
Para ejecutar la migración creada
php artisan migrate
image.png
En la BD
image.png
image.png
La tabla alumnos
image.png
Seeder Alumno
php artisan make:seeder AlumnoSeeder
image.png
Añadimos la referencia de la clase Alumno:
use App\Models\Alumno;
image.png
Creamos la variable $alumno, llenamos sus propiedades y finalmente utilizamos el método save(); igualmente llenamos con tres registros nuestra tabla alumnos.
image.png
Cuando ejecutamos los Seeders desde Artisan, este llama a la única clase que es DatabaseSeeder. Por lo tanto para ejecutar los demás Seeders creados debemos instanciar a esta clase con el método call().
$this->call(AlumnoSeeder::class);
image.png
Ejecutar Seeders
Ya podemos cargar de datos la tabla de nuestra base de datos Ejecutamos la siguiente línea de código que llenará las tablas con datos.
php artisan db:seed
Para verificar los cambios en la base de datos, me voy a lo que es phpMyAdmin desde mi navegador, actualizo la página, abrimos la tabla y podemos verificar que los datos que definimos en los Seeders se encuentran cargados.
image.png
En la BD la tabla alumnos
image.png
Factories en Laravel
Con los Seeders que nos proporciona Laravel ya podemos llenar la tablas de nuestra base de datos. Sin embargo, es limitado ya que, si queremos llenar más de 10, 100 registros sería prácticamente un ejerció en sufrimiento. Porque se crea una variable por cada registro de la tabla.
Por esta razón Laravel cuenta con los Factories que es otra forma de llenar los datos de una forma más automatizada, y generar gran cantidad de datos.
Los Factories son sencillos de utilizar, solo se debe especificar en cada campo de la tabla que tipo de dato se quiere llenar, posteriormente la cantidad de registros que se quiere generar en la tabla.
Factory Alumnos
Ahora lo primero que aremos es crear nuestra clase AlumnoFactory con Artisan escribimos la siguiente línea de código.
php artisan make:factory AlumnoFactory
image.png
image.png
Y cambiamos en el DatabaseSeeder
image.png
Ejecutamos seeders
php artisan db:seed
image.png
image.png
Modelo
Si solo hacemos el modelo
php artisan make:model Alumno
Si usamos el modelo con –a (para que cree modelo, migración, seeder, Factory y controlador resource
php artisan make:model Alumno -a
Con la instrucción utilizada en el ejercicio
php artisan make:Model Alumno -m
Ha creado el modelo Alumno
image.png
Con el código:
image.png
Registramos las configuraciones de la tabla Alumnos.
protected $table = "alumnos";
protected $primaryKey = "id";
protected $fillable = ['nombre_apellido', 'edad', 'telefono', 'direccion'];
protected $hidden = ['id'];
Lo modificamos
image.png
Si es necesario podemos hacer public $timestamps = false;
Podemos crear funciones . Ejemplo
La función “Obteneralumnos” utiliza el método all() para obtener todo el listado de los alumnos de la tabla.
public function obtenerAlumnos()
{
return Alumno::all();
}
La función “ObtenerAlumnoPorId” utiliza el método find() pasando un parámetro Id para obtener a un determinado alumno.
public function obtenerAlumnoPorId($id)
{
return Alumno::find($id);
}
que podrían estar en el modelo
image.png
Controladores
Crear Controlador alumnos
php artisan make:controller AlumnoController
Si queremos que se creen todas las funciones necesarias para un CRUD
php artisan make:controller AlumnoController --resource
image.png
image.png
Se creará todos los métodos que necesitamos
image.png
Lo primero que haremos es llamar a la referencia del modeloAlumno .
use App\Models\Alumno;
Dentro de la función index escribimos la siguiente consulta.
$alumnos = Alumno::all();
return view('alumnos.index', ['alumnos' => $alumnos]);
image.png
De igual forma obtendremos todos los datos de la tabla alumnos. Seguidamente, retornaremos en la variable $alumnos a la vista alumnos.
Crear ruta
Seguidamente, vamos a crear la ruta, trabajaremos con el archivo web.php que se encuentra en el directorio routes.
En primer lugar, se debe hacer referencia al controlador:
use App\Http\Controllers\AlumnoController;
En segundo lugar, crearemos las rutas de tipo get que harán la referencia al método index de nuestro controlador. Por último, le asignamos un nombre a nuestra ruta.
Route::get('/alumnos', [AlumnoController::class, 'index'])
->name('alumnos.index');
image.png
Plantillas Blade
Crear vista alumnos
Crear la carpeta alumnos y dentro de este creamos el archivo index.blade.php , introducimos el código de la vista alumnos finalizar también añadimos el código css para mejorar un poco el diseño de la vista.
image.png
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Curso de laravel</title>
<style>
body {
margin: auto;
padding: 50px;
}
table {
border-collapse:collapse;
width: 100%;
}
table, td, th {
border: 1px solid black;
}
</style>
</head>
<body>
<h2>Listado de Alumnos</h2>
<table>
<tr>
<th>Nombre y Apellido</th>
<th>Edad</th>
<th>Teléfono</th>
<th>Dirección</th>
</tr>
@foreach ($alumnos as $alumno)
<tr>
<td>{{ $alumno- >nombre_apellido }}</td>
<td>{{ $alumno->edad }}</td>
<td>{{ $alumno->telefono }}</td>
<td>{{ $alumno->direccion }}</td>
</tr>
@endforeach
</table>
</body>
</html>
Si vamos a http://localhost/nombreproyecto/public/alumnos nos muestra el resultado
image.png
Paginación
Vamos a paginar esta vista
En el controlador, aquí también ponemos otra forma de pasar datos (compact)
image.png
y en la vista ponemos el enlace
{{ $alumnos->links() }}
image.png
Ahora la vista será
image.png
Nota
Posible Error de visualización→ del botón de la paginación sale inmenso
image.png
Es debido a que Laravel usa la paginación Tailwind para cambiar esto dirígete a:
App\Providers\AppServiceProvider
image.png
Y agrega el siguiente use
use Illuminate\Pagination\Paginator;
Y dentro de la parte de la función boot
Paginator::useBootstrap();
Quedaría
use Illuminate\Pagination\Paginator;

/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
Paginator::useBootstrap();
}

Documentación
Otra forma puede ser:
laravel para paginar utiliza el Tailwind CSS y debes cambiarlo a Bootstrap, para esto utiliza el comando
php artisan vendor:publish --tag=laravel-pagination
Y luego puedes personalizar las vistas generadas en resources/views/vendor/pagination/ o cambiar la vista por defecto a una que prefieras de Bootstrap en tu vista seria así:
{{$categorias->links('vendor.pagination.bootstrap-4)}}
Nota :Versión 9
Bootstrap 5 Pagination Views
Laravel ahora incluye vistas de paginación creadas con Bootstrap 5. Para usar estas vistas en lugar de las vistas predeterminadas de Tailwind, puede llamar al método useBootstrapFive del paginador dentro del método boot de su clase App\Providers\AppServiceProvider:
use Illuminate\Pagination\Paginator;
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
Paginator::useBootstrapFive();
}
image.png
Método create y store
Vamos con los métodos de create() y store() del controlador AlumnoController.
En el método create() escribimos el siguiente código:
image.png
En el método store() el siguiente código:
image.png
Rutas web (create y store)
Ahora crearemos las rutas de tipo de create() y store() que harán la referencia al método get() y post() de nuestro controlador.
Primero abrimos nuestro archivo web.php, las funciones get() y post() se encargaran de realizar las peticiones a los métodos de nuestro controlador Alumno.
image.png
Formularios Blade (crear alumno)
Ahora crearemos los formularios en las vistas, utilizaremos las plantillas Blade que te ofrece Laravel.
Para la navegabilidad entre ventanas en los archivos index de Alumnos y añadiremos un enlace que cuando hagamos clic redireccione al formulario de crear, en mi caso yo le colocaré antes del título de la vista.

image.png
Quedando
image.png
Formulario crear Alumnos
Laravel te exige un @csrf Token con el propósito de prevenir posibles ataques a las peticiones solicitadas en formularios HTML.
Realizamos los mismos pasos al crear el formulario de la vista alumnos. Primero creamos el archivo crear.blade.php en la ruta resources/views/alumnos y escribimos el siguiente código:
image.png
vamos a poner el css de momento en la misma vista
<style>
body {
margin: auto;
padding: 50px;
}
input[type=text], select {
width: 100%;
padding: 12px 20px;
margin: 8px 0;
display: inline-block;
border: 1px solid #ccc;
border-radius: 4px;
box-sizing: border-box;
}
input[type=submit] {
width: 100%;
background-color: #4CAF50;
color: white;
padding: 14px 20px;
margin: 8px 0;
border: none;
border-radius: 4px;
cursor: pointer;
}
input[type=submit]:hover {
background-color: #45a049;
}
div {
border-radius: 5px;
background-color: #f2f2f2;
padding: 20px;
}
</style>
nos quedará
image.png
Actualizar registros en Laravel
Método edit y update
En el método edit() del controlador AlumnoController haremos lo siguiente. Primeramente, con el método findOrFail($id) recuperamos un determinado registro con un identificador $Id que le pasamos como parámetro, seguidamente retornaremos a nuestra vista del formulario alumno con el variable $alumno
En el método Edit() introducimos el siguiente código:
$alumno = Alumno::findOrFail($id);
return view('alumnos.editar', ['alumno' => $alumno]);
image.png
En el método update() el siguiente código:
$alumno = Alumno::findOrFail($id);
$alumno->nombre_apellido = $request->nombre_apellido;
$alumno->edad = $request->edad;
$alumno->telefono = $request->telefono;
$alumno->direccion = $request->direccion;
$alumno->save();
return redirect()->action([AlumnoController::class, 'index']);
image.png
Rutas para actualizar
Ahora crearemos las rutas para actualizar registros de nuestra base de datos, similar como lo realizamos al crear un nuevo registro.
En el archivo web.php utilizaremos las funciones get() y put() escribimos el siguiente código:
Route::get('/alumnos/{id}/editar', [AlumnoController::class, 'edit'])->name('alumnos.edit');
Route::put('/alumnos/{id}', [AlumnoController::class, 'update'])->name('alumnos.update');

image.png
Formulario Actualizar
Para actualizar los datos de las tablas de nuestra base de datos. Primeramente, agregamos la navegabilidad en nuestras vistas del listado Alumnos.
En el archivo index de la vista alumnos, en la cabecera de la tabla añadimos el siguiente código:
<th>Acción</th>
Dentro del bucle foreach lo siguiente:
<td>
<a href="{{ route('alumnos.edit', $alumno->id) }}">Editar</a>
</td>
image.png
Formulario actualizar alumnos
En el formulario de edición de alumnos realizamos los mismo pasos. De igual forma, crearemos el archivo editar.blade.php en el directorio resources/views/alumnos, y escribimos el siguiente código:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Curso de laravel</title>
</head>
<body>
<a href="{{ route('alumnos.index') }}"> Ver listado Alumnos</a>
<h2>Editar Alumno</h2>
<form action="{{ route('alumnos.update', $alumno->id) }}" method ="POST">
@csrf
{{ method_field('PUT') }}
<label>Nombres y Apellidos:</label>
<input type="text" name="nombre_apellido" placeholder="Nombres y Apellidos" value="{{ $alumno->nombre_apellido }}">
<label>Edad:</label>
<input type="text" name="edad" placeholder="Edad" value="{{ $alumno->edad }}">
<label>Teléfono:</label>
<input type="text" name="telefono" placeholder="Teléfono" value="{{ $alumno->telefono }}">
<label>Dirección:</label>
<input type="text" name="direccion" placeholder="Dirección" value="{{ $alumno->direccion }}">
<input type="submit" value="Guardar">
</form>
</body>
</html>
image.png
Ponemos css
image.png
Validar formularios
Laravel ya viene integrado funciones que podemos utilizar para validar nuestros formularios antes de guardar en nuestra base de datos.
Antes de crear nuestras validaciones, primero abriremos las migraciones creadas anteriormente. Por ello, verificaremos en los campos el tipo de dato si es entero, cadena o fecha, seguidamente observamos que campos son obligatorios y que campos son opcionales.
image.png
Ahora abriremos nuestro controlador AlumnoController, en el método store() es donde se controlan los errores de validación de nuestro formulario, es aquí donde añadiremos código a las validaciones, antes de crear una nueva instancia de alumnos.
Utilizaremos la variable request que es pasado como parámetro de la función store que contiene todos los campos del formulario, al método validate() le pasamos un array con los campos del formulario y sus validaciones respectivas.
Laravel nos indica en caso de que algunas de las validaciones realizadas no cumplen con la condición retorna a la vista un error de validación y no pasa a la siguiente línea de código del programa. Sin embargo, si todas las validación hechas se cumplen entonces pasa a la siguiente línea de código, en nuestros ejemplo crea la nueva instancia alumno, carga los datos y posteriormente guarda los datos en nuestra base de datos.
$request->validate([
'nombre_apellido' => 'required|max:75',
'edad' => 'required|integer',
]);
image.png
Impresión de errores de validación en formularios
Ahora pasamos a la vista de nuestros formularios, es aquí donde vamos a imprimir mensajes en los campos del formulario cuando existan errores de validación que definimos en nuestros controladores.
Antes de comenzar con la validación de los formularios añadiremos código css a todas nuestras vistas, con el fin de dar estilo a los mensajes de error.
p { color: red; }
Validación del formulario en la vista alumnos
Empecemos a validar el formulario alumnos, abrimos el archivo crear.blade.php que se encuentra en la ruta resources/views/alumnos, donde iremos integrando todas nuestras validaciones.
En el campo Nombre y Apellidos por debajo del elemento input añadimos el código de validación de este campo con la directiva que nos ofrece Blade, @error nos permite imprimir el mensaje de error que corresponde a este campo.
@error('nombre_apellido')
<p class="error-message">{{ $message }}</p>
@enderror
Ahora vamos a añadir el método old() (Es una directiva de Blade) en las etiquetas input de nuestro formulario, este método lo que hace es mantener en los campos el texto escrito por el usuario en caso de error de validación en uno de ellos.
<input type="text" name="nombre_apellido" placeholder="Nombres y Apellidos" value="{{ old('nombre_apellido') }}">
Ahora en el campo edad añadimos las validaciones.
@error('edad')
<br>
<p class="error-message">{{ $message }}</p><br>
@enderror
Igualmente, el método old() a la etiqueta input del campo edad
<input type="text" name="edad" placeholder="Edad" value="{{ old('edad') }}">
En el campo teléfono escribiremos lo siguiente:
<input type="text" name="telefono" placeholder="Teléfono" value="{{ old('telefono') }}">
En el campo dirección escribiremos lo siguiente:
<input type="text" name="direccion" placeholder="Dirección" value="{{ old('direccion') }}">

image.png
image.png
Traducir al español los mensajes de validación en Laravel
Si observamos al momento de probar nuestro código los mensajes de error de validación en los formularios están en inglés, debido a que la configuración de Laravel viene por defecto en inglés.
Para poder configurar nuestra aplicación en español tenemos que realizar los siguiente:
Primeramente en la ruta resources/lang creamos una carpeta llamada es, ahora copiamos todos los archivos que se encuentran en la carpeta en y lo pegamos en la carpeta creada es.
image.png
La comunidad de Laravel ya cuenta con un repositorio en esta donde tiene traducido los mensajes en varios idiomas entre ellos el español.
Si queremos mas idiomas
Configuración del archivo config
Por último debemos indicar a Laravel que utilizaremos las configuración de lenguaje en español, en la carpeta config abrimos el archivo app.php, buscamos la siguiente línea de código ‘locale’ => ‘es’ y reemplazamos es por en.
image.png
Cambiamos y queda
image.png

Actualizamos nuestro navegador y probamos las validaciones con la nueva configuración, todos los mensajes por defecto estarán ahora en español.
image.png
Traducción de variables en Laravel
Ya solucionamos parte de los mensajes de error de validaciones, si observamos con más detalle los mensajes de error, El campo nombre apellido es obligatorio y lo correcto debe ser El campo Nombre y Apellido es obligatorio.
Este caso nos ocurrirá bastante si las variables que declaremos estén en inglés que generalmente se declaran de esta manera, para solucionar este problema nos dirigimos al directorio creado que está en resources/lang/en abrimos el archivo validation.php y dentro de la variable attributes declaramos las variables de nuestro formulario que queremos corregir.
image.png
modificamos:
'attributes' => [
'nombre_apellido' => 'Nombre y Apellido',

],
Queda
image.png
image.png

Visualizar registros
Cuando necesitamos ver una gran cantidad de información de un registro en específico nos viene muy bien tener una ventana independiente donde poder visualizar todos estos datos.
Método ver en controlador alumnos
Iniciamos abriendo el controlador AlumnoController, dentro del método show() iniciamos una variable $alumno que obtendrá un objeto de tipo Alumno, al método findOrFail le pasamos un parámetro Id para recuperar un registro en particular, finalmente retornamos a la vista ver el alumno con los datos recuperados.
$alumno = Alumno::findOrFail($id);
return view('alumnos.ver', ['alumno' => $alumno]);
image.png
Ruta web de la vista ver
Route::get('/alumnos/{id}/ver', [AlumnoController::class, 'show'])
->name('alumnos.show');
image.png
Vista Blade show
Finalmente pasamos a las vistas de visualización de datos de un determinado registro de nuestra base de datos, para la navegabilidad entre ventanas en los archivos index
En el archivo index de la vista alumnos igual añadimos el siguiente código:
<a href="{{ route('alumnos.show', $alumno->id) }}">Ver</a>
image.png
Formulario ver alumnos
En la ruta resources/views/alumnos creamos un nuevo archivo ver.blade.php y dentro definimos la vista ver donde visualizamos todos los datos de un registro en específico.
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Curso de laravel</title>
</head>
<body>
<a href="{{ route('alumnos.index') }}"> Ver listado Alumnos</a>
<h2>Ver Alumno</h2>
<label><strong>Nombres y Apellidos:</strong> {{ $alumno->nombre_apellido }}</label><br>
<label><strong>Edad:</strong> {{ $alumno->edad }}</label><br>
<label><strong>Teléfono:</strong> {{ $alumno->telefono }}</label><br>
<label><strong>Dirección:</strong> {{ $alumno->direccion }}</label><br>
</body>
</html>
image.png
image.png
image.png
Método destroy
Abrimos el controlador AlumnoController, dentro del método destroy() , llamó al método delete() del objeto $profesor para eliminar el registro de nuestra base de datos.
$alumno = Alumno::findOrFail($id);
$alumno->delete();
return redirect()-> action([AlumnoController::class, 'index']);
image.png
Ruta web de la vista eliminar
Route::delete('/alumnos/{id}', [AlumnoController::class, 'destroy'])->name('alumnos.destroy');
image.png
Eliminar registros en Laravel
Finalmente pasamos a la funcionalidad de eliminar, utilizaremos la vista ver creada anteriormente donde iremos añadiendo código que nos permita eliminar un registro seleccionado con algunos controles y validaciones que se tiene que tomar en cuenta.
En el caso tener mas tablas tendremos que realizar las validaciones que tomaremos en cuenta que son por ejemplo un alumno no puede ser eliminado si está inscrito en uno o varios cursos.
Vista eliminar alumnos
En el archivo index.blade.php de la ruta resources/views/alumnos
<form action="{{ route('alumnos.destroy',$alumno->id) }}" method="POST">
@csrf
@method('DELETE')
<button class="btn btn-danger" type="submit"> Borrar</button>
</form>

Vamos a ponerlo en orden todas las opciones
image.png
y voy a meter el css en el fichero style.css que esta en resources/css
image.png
image.png
y utilizo bootstrap para usar en enlaces y botones
<meta charset="utf-8">
<title>Curso de laravel</title>
<script src= "https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
<link rel="stylesheet" href= "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
<link href='http://fonts.googleapis.com/css?family=Holtwood+One+SC' rel='stylesheet' type='text/css'>
<link rel="stylesheet" href="{{ asset('css/style.css') }}">

</head>
image.png
image.png
Rutas resource
Si en este momento web.php tiene las siguientes rutas que hemos creado para hacer un crud de nuestra tabla alumnos
image.png
Cada una de estas rutas nos manda al método correspondiente en el controlador AlumnoController.
También podemos ver las rutas mediante el comando artisan
php artisan route:list
image.png
Podemos cambiar todas estas rutas por las que nos da la siguiente
Route::resource('alumnos', AlumnoController::class);
image.png
Podemos comprobar que nuestro sitio sigue funcionando como antes
Esto se hace cuando al crear el controlador hemos creado todas las rutas necesarias para hacer el CRUD de la tabla
php artisan make:controller AlumnoController --resource
image.png
Variaciones
Cuando creamos el Controlador
image.png
Me crea algunos de los métodos pasando el modelo, en vez de el Request
image.png

Blade

Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.