Laravel-Controlador
Los controladores son un mecanismo que nos permite agrupar la lógica de peticiones HTTP relacionadas y de esta forma organizar mejor nuestro código.
Generar un controlador
Generamos un nuevo controlador con el comando de Artisan make:controller pasándole el nombre que queremos darle. En el ejemplo el nombre es UserController:
php artisan make:controller UserController
Hecho esto, en el directorio app/Http/Controllers tendremos nuestro controlador UserController.
Métodos en el controlador
Un controlador no es más que un archivo .php con una clase que extiende de la clase App\Http\Controllers\Controller:
<?php
namespace App\Http\Controllers;
class UserController extends Controller {
// ...
}
Dentro de esta clase (en nuestro caso UserController) agregamos nuestros métodos públicos (llamados acciones), que después podemos enlazar a una ruta:
public function index()
{
return 'Usuarios';
}
Una acción de un controlador no es más que un simple método de PHP. Este método debe ser público, por ejemplo:
<?php
namespace App\Http\Controllers;
class NoteController
{
public function create()
{
return view('add-note');
}
}
Enlazar una ruta a un controlador
Para enlazar una ruta a un controlador pasamos como argumento el nombre del controlador y del método que queremos enlazar, separados por un @. En este caso queremos enlazar la ruta /usuarios al método index del controlador UserController:
Route::get('/usuarios', 'UserController@index');
Controlador de un solo método
Si quieres tener un controlador que solo tenga una acción, puedes hacerlo llamando al método __invoke, por ejemplo:
public function __invoke($name, $nickname = null)
{
// ...
}
En nuestra ruta ahora podemos enlazar directamente al controlador:
Route::get('/saludo/{name}/{nickname}', 'WelcomeUserController');
Inyección de dependencias
Laravel permite la inyección de dependencias. En el controlador las dependencias son declaradas e inyectadas dentro de un constructor para ser llamadas desde cualquier método de la clase.
Lo primero que haremos es llamar a la referencia del modelo que creamos en la anterior clase.
use App\Models\Alumno;
Creamos el constructor para inyectar la dependencia de la clase Alumno para utilizarlo en los métodos de la clase AlumnoController
protected $alumnos;
public function __construct(Alumno $alumnos)
{
$this->alumnos = $alumnos;
}
Controlador de recursos
Ahora trabajaremos con las funciones básicas que nos ofrece el comando resource para las peticiones http.
Método index
El método index es el inicio de las rutas, es donde mostraremos el listado de todos los alumnos.
Con la inyección de dependencias podemos acceder a los métodos de la clase Alumno del modelo, al llamar el método obtenerAlumnos retorna un listado con todos los alumnos que se encuentran en la base de datos, para mostrarlos en la vista.
public function index()
{
$alumnos = $this->alumnos->obtenerAlumnos();
return view('alumnos.lista', ['alumnos' => $alumnos]);
}
Método create
El método create redirecciona a una vista donde crearemos un formulario para crear un nuevo alumno.
public function create()
{
return view('alumnos.crear');
}
Método store
El método store almacena un nuevo alumno, la variable $request contiene todos los datos del formulario en la petición http. El método all() carga los datos al objeto $alumno. El método save() se encarga de guardar los datos en la base de datos, por último retorna a la vista del listado de alumnos.
public function store(Request $request)
{
$alumno = new Alumno($request->all());
$alumno->save();
return redirect()->action([AlumnoController::class, 'index']);
}
Método show
El método show obtiene un alumno específico y redirecciona a un formulario de la vista. El método obtenerAlumnoPorId retorna un registro de la base de datos que cumpla con un identificador único ID que es pasado desde la vista.
public function show($id)
{
$alumno = $this->alumnos->obtenerAlumnoPorId($id);
return view('alumnos.ver', ['alumno' => $alumno]);
}
Método edit
El método edit retorna un alumno específico en el formulario de la vista para para poder editarlo. El método obtenerAlumnoPorId retorna un registro de la base de datos que cumpla con un identificador único ID.
public function edit($id)
{
$alumno = $this->alumnos->obtenerAlumnoPorId($id);
return view('alumnos.editar', ['alumno' => $alumno]);
}
Método update
El método update actualiza los datos de un alumno específico por su ID, la variable $request contiene los campos ya modificados. El método Fill() actualiza los datos del objeto alumno. Por último el método Save() se encarga de guardar en la base de datos, para finalizar retorna a la vista del listado de alumnos.
public function update(Request $request, $id)
{
$alumno = Alumno::find($id);
$alumno->fill($request->all());
$alumno->save();
return redirect()->action([AlumnoController::class, 'index']);
}
Método destroy
El método destroy elimina un alumno específico por su ID. El método find() se encarga de buscar un registro en específico. El método delete() se encarga de eliminar el registro de la base de datos.
public function destroy($id)
{
$alumno = Alumno::find($id);
$alumno->delete();
return redirect()->action([AlumnoController::class, 'index']);
}
En la siguiente clase empezaremos a visualizar los datos en nuestro navegador, utilizar y verificar todos los métodos creados en nuestro controlador y llamarlos desde las vistas y rutas en Laravel 8.
Controladores
En lugar de definir en su totalidad la lógica de las peticiones en el archivo routes.php, es posible que desee organizar este comportamiento usando clases tipo Controller. Los Controladores puede agrupar las peticiones HTTP relacionada con la manipulación lógica en una clase. Los Controladores normalmente se almacenan en el directorio de aplicación app/Http/Controllers/.
Un controller usualmente trabaja con las peticiones:
GET.
POST.
PUT.
DELETE.
PATCH.
Asociando los métodos de la siguiente forma:
GET: index, create, show, edit.
POST: store.
PUT: update.
DELETE: destroy.
PATCH: update.
Los controladores nos ayudan a agrupar estas peticiones en una clase que se liga a las rutas, en el archivo app/Http/routes.php, para esto usamos un tipo de ruta llamana resource:
Route::resource('pasteles', 'PastelesController');
Esta ruta nos creara un grupo de rutas de recursos con las peticiones que estas mencionadas arriba: index, create, show, edit, store, update, destroy. Estas son las operaciones mas usadas en una clase y para no tener que crear una ruta para cada método es que Laravel agrupa todo esto con una ruta de tipo resource que se liga a un controlador.
Estos métodos significan:
index: Es el método inicial de las rutas resource, usualmente lo usamos para mostrar una vista como página principal que puede contener un catalogo o resumen de la información del modelo al cual pertenece o bien no mostrar información y solo tener la función de página de inicio.
create: Este método lo podemos usar para direccionar el sistema a la vista donde se van a recolectar los datos(probablemente con un formulario) para después almacenarlos en un registro nuevo, usualmente redirige al index.
show: Aqui podemos hacer unna consulta de un elemento de la base de datos o de todos los elementos o registros por medio del modelo para realizar una descripcion.
edit: Este método es similar al de create porque lo podemos usar para mostrar una vista que recolecta los datos pero a diferencia de create es con el fin de actualizar un registro.
store: Aqui es donde se actualiza un registro en especifico que proviene del método create y normalmente redirige al index.
update: Al igual que el store, solo que en vez de provenir de create proviene de edit y en vez de crear un nuevo registro, busca un existente y lo modifica, tambien suele redirigir al index.
destroy: En este método usualmente se destruye o elimina un registro y la petición puede provenir de donde sea siempre y cuando sea llamado con el método DELETE, después puede redirigir al index o a otro sitio dependiendo si logro eliminar o no.
Ahora esto no quiere decir que un controlador necesariamente debe ejecutar estas peticiones obligatoriamente, podemos omitirlas o incluso agregar mas.
Para crear controladores en Laravel usamos artisan con el siguiente comando:
php artisan make:controller NameController
El comando anterior creara un controlador en la carpeta app/Http/Controllers/ que por defecto va a tener todos estos métodos dentro de si, entonces agregaremos la ruta de tipo resourse anterior al archivo de rutas y correremos el siguiente comando en la consola:
php artisan make:controller PastelesController
Con esto vamos a poder trabajar para cada método del controlador una ruta y las funciones internas son las que se van a ejecutar, el archivo creado se verá de la siguiente manera:
En la linea de comandos podemos ver todas las rutas que nuestro proyecto tiene registradas:
php artisan route:list
Este comando nos va a mostrar en la consola un resultado similar a esto:
aqui podemos ver el nombre de nuestras rutas, de que tipo son, si es que reciben parametros y como se llaman, esta información es muy util para poder asociar los métodos del controlador con las rutas y tambien como es que las vamos a usar en el navegador.
Comentarios
Publicar un comentario