Laravel 9.*

• Laravel se ha convertido en el framework php más utilizado para desarrollo web.

• En septiembre/2019 se publicón la versión 6.0

• Desde entonces usa versionado semántico.

  • Febrero y agosto: versiones mayores: 6 (LTS), 7, ... (febrero 2022: v9)

  • Semanalmente pueden aparecer versiones menores (segundo dígito) y de parcheo (tercero).

  • Las versiones mayores pueden incluír cambios de ruptura, el resto no.

• Usa arquitectura MVC (Modelo Vista Controlador) y mucho más:

• Sistema de enrutamiento potente

• Usa Blade como gestor de plantillas

• Su propio ORM: Eloquent (¿Adios SQL en nuestros proyectos?, para el 99% de las situaciones, sí)

• Y muchos otros componentes que lo hacen muy interesante: Query Builder, Database Migrations, Seeders, Passport, Dusk, Socialite, ... y muchos otros componentes brindados por terceras partes.

• Enlaces:

  • Wikipedia mejor en inglés.

  • Sitio oficial

  • Documentacion

  • Laracast: videotutoriales oficiales

  • Styde.net: numerosos videotutoriales, cursos y publicaciones

  • Código fuente. Se puede clonar para iniciar proyecto.

Instalación

• https://laravel.com/docs/9.x/installation

• Requisitos: https://laravel.com/docs/9.x/deployment

  • php8.0 y algunos complementos

  • Composer (v2) como gestor de dependencias

• Podemos desarrollar sin servidor o con él (Apache o Nginx)

• Podemos dockerizar el entorno de desarrollo. Usando docker podríamos obviar estas dependencias en el anfitrión pero las vamos a instalar. Facilitará nuestra tarea.

Instalación via composer (directorio laravelpruebas):

#proyecto de ejemplo: laravelpruebas
#última versión
composer create-project --prefer-dist laravel/laravel laravelpruebas
#versión 8
composer create-project --prefer-dist laravel/laravel:^8.0 laravelpruebas

• Esto implica:

  • Descargar fremwork original

  • Ejecutra composer install

  • Crear fichero de entorno (.env)

  • Generar clave de cifrado

Instalación via git

• Partimos del código de GitHub o de otro proyecto Laravel. Vamos a usar este ejemplo para iniciar el proyecto en nuestro entornods. Aquí todas las fases son manuales:

  • Antes de nada, vamos a la rama correcta de "entornods"

    cd ~/entornods
    git fetch
    git checkout --track origin/laravel

  • Descarga

  git clone https://github.com/laravel/laravel.git nombreProyecto
  cd nombreProyecto

  • Instalación de dependencias. Ojo, si no tenemos la versión correcta de php y composer entramos dentro del contenedor.

  docker exec -it -u devuser laravel bash
  composer install

  • Crear fichero de entorno a partir del de ejemplo:

  cp .env.example .env

  • Creación de la clave de cifrado (ver .env).

  php artisan key:generate

NOTA

• artisan se usa de forma generalizada. Por ejemplo, todas las clases deben crearse con ese comando.

• Podemos desarrollar sin servidor ejecutando:

php artisan serve  # para iniciar el servicio
chrl+C             # para cerrar

Laravel en nuestro entornods:

• Descargamos nuestro entornods y nos ponemos en la rama laravel

  git checkout --track origin/laravel

• Añadimos al fichero hosts:

  127.0.0.1   laravel.local

• Colocamos el directorio del proyecto dentro de data

• Levantamos nuestro servicio:

  cd entornods 
  docker-compose up -d

OJO!!!

• El entornods viene configurado para una aplicación ubicada en data/laravel (o data/laravel9)

• El resto de instrucciones también

• Si usamos otro nombre deberemos ajustar alguno de estos comados y el contenido del fichero docker-compose.yml

• El uso de la consola va a ser importante en el desarrollo con Laravel

• Puede ser interesante definir aliases de comandos

• Editamos el fichero ~/.bashrc

  #añadir lo siguiente al final: de  ~/.bashrc
  alias laraa='docker exec --user devuser laravel  php artisan '
  alias larac='docker exec --user devuser laravel  composer '
  alias larai='docker exec -it --user devuser laravel bash'

• ejecutar lo siguiente si no queremos reiniciar:

  source ~/.bashrc

• El fichero .env

  • El fichero .env define variables utilizadas únicamente en el entorno de desarrollo.

  • Cada sitio de desarrollo o producción mantiene su propio .env

  • Este fichero debe excluirse de git. Compruébalo en el fichero .gitignore.

  • Debemos ajustar la parte de BBDD y el APP_URL=http://laravel.local

• El directorio de configuración es config. Buena parte de la configuración es condicionada al contenido del fichero .env

Repositorio de clase

• Vamos a usar el repositorio: laravel20

• Recomendación: hacer un fork del mismo:

• Una vez hecho esto:

• • Ve a bitbucket y realiza un fork

  • Clona dentro de entornods/data tu repositorio

  • Instala dependencias

  • Obten una copia del fichero .env

  • Genera la clave de cifrado

    git clone ....
    cd laravel
    cp .env.example .env
    composer install
    php artisan key:generate

• Es interesante poder descargar el código de clase. Para hacerlo añade el repositorio del profesor:

cd data/laravel
git remote add rafa [e-mail]:rafacabeza/laravel20.git

• Cuando quieras descargar la última clase:

git fetch rafa
git checkout --track rafa/claseXX #la rama que corresponda

Arquitectura

• Configuramos nuestro servidor para que todas las peticiones lleguen a index.php (var https://laravel.com/docs/6.x/installation)

• index.php sólo crea un objeto $app a partir del script bootstrap/app.php.

• Tras esto la petición o request se pasa al kernel (nucleo) http o de consola:

• Kernel Http:

  class Kernel extends HttpKernel

  • Carga clases bootstrapers que preparan la aplicación (heredado)

  • Define una serie de middlewares (filtros) que se ejecutan antes de tratar el request, es decir, antes de ejecutar un método del controlador correspondiente.

  • Por fin, el kernel trata el request y devuelve un response (heredado)

• Todas las clases dentro de Iluminate están dentro de vendor, son parte del framework y no debemos modificarlas en absoluto. Todo lo "heredado" está ahí.

• La respuesta

  • Tras preparar la aplicación, la petición se pasa al router

  • De acuerdo a las rutas definidas se genera una respuesta o se delega en un controlador.

  • A las rutas y controladores se les puede asignar middlewares.

• Los Service Providers

  • Son el elemento clave en el arrange (bootstraping) de la aplicación.

  • Definen los componentes disponibles en la aplicación.

  • El fichero config/app.php cuenta con un array donde definimos cuales otros queremos usar

    • Muchos de ellos están en el frameword (empiezan por Illuminate)

    • Otros están en app/Providers

    • Si añadimos librerías o creamos los nuestros propios (avanzado) deberemos añadir elementos a este array.

Rutas

• https://laravel.com/docs/9.x/routing

• En nuestro framework mvc "casero", un controlador era responsable de una tarea concreta, o conjunto de tareas relacionadas entre sí (CRUD sobre una tabla, por ejemplo).

• Para nosotros el path o ruta de nuestra url representaba /controlador/metodo/arg1/arg2/argN.

• Laravel tiene un sistema de enrutado mucho más flexible y potente.

• Las rutas se definien en el directorio routes:

  • web.php define todas las rutas de la aplicación web

  • api.php define las rutas asociadas a un servicio web

  • console.php define rutas usadas desde la consola con php artisan

  • channels.php se usa en aplicaciones en tiempo real y websockets. No toca...

• Para definir una ruta usamos una clase llamada Route.

• Usamos una función que define el tipo de petición (get, post, ...)

• Definimos una ruta

• Definimos una función de callback o como veremos un controlador y un método

Route::get('user', function () {
 return 'hola mundo. Estamos en user';
});

• Veamos algunos ejemplos ilustrativos:

Route::get('user', function () {
 return 'hola mundo. Estamos en user';
});

//prueba esta ruta creando un formulario.
Route::post('user', function () {
 return 'hola mundo. Estamos en user, por el método POST';
});

//podemos usar parámetros
Route::get('user/{id}', function ($id) {
 return 'Preguntando por user' . $id;
});

//podemos usar parámetros opcionales
Route::get('book/{id?}', function ($id = "desconocido") {
 return 'Preguntando por el libro ' . $id;
});

Route::get('user/delete/{id}', function ($id) {
 return 'Baja de usuario, argumento id:' . $id;
});

//Podemos filtrar los argumentos con expresiones regulares
Route::get('user/{name}', function ($name) { 
    // name debe ser texto
}) ->where('name', '[A-Za-z]+'); 

Route::get('user/{id}', function ($id) { 
    //  id debe ser un nº. natural
}) ->where('id', '[0-9]+')

Rutas y controladores

• Las rutas anónimas son útiles para pequeñas tareas y pruebas.

• Pero un trabajo serio necesita el uso de controladores (MVC)

use App\Http\Controllers\UserController;

//ruta prueba gestionada por el método "index" de PruebaController
Route::get('/photos', [PhotosController::class, 'index']);

Ojo! Esto cambió en la versión 8. Anteriormente la sintáxis era:

Route::get('foo', 'Photos\AdminController@method');

Rutas resource: REST

• Un CRUD necesita definir 7 rutas para 7 acciones.

  • Lectura: ruta de listado y de detalle

  • Creación: mostrar formulario de alta y procesarlo

  • Update: mostrar formulario de edición y procesarlo

  • Borrado

Route::get('photos/create', 'Photos\AdminController@create');
Route::post('photos', 'Photos\AdminController@store');
Route::get('photos', 'Photos\AdminController@index');
Route::get('photos/{id}', 'Photos\AdminController@show');
Route::get('photos/{id}/edit', 'Photos\AdminController@edit');
Route::put('photos/{id}', 'Photos\AdminController@update');
Route::delete('photos/{id}', 'Photos\AdminController@destroy');

• Si definimos rutas de tipo resource se mapearán estas 7 rutas.

• En la medida de lo posible estas rutas siguen el paradigma REST.

• Son las acciones necesarias para un CRUD completo y usando los distintos verbos HTTP: get, post, put y delete.

• Para ver como gestionar estas rutas y este tipo de controladores: https://laravel.com/docs/9.x/controllers#resource-controllers

• Definición de una ruta

Route::resource('photos', 'PhotoController');

• Creación de un controlador resource:

php artisan make:controller PhotoController --resource

• Lista de rutas:

Verb	URI	Action	Route Name
GET	/photos	index	photos.index
GET	/photos/create	create	photos.create
POST	/photos	store	photos.store
GET	/photos/{photo}	show	photos.show
GET	/photos/{photo}/edit	edit	photos.edit
PUT/PATCH	/photos/{photo}	update	photos.update
DELETE	/photos/{photo}	destroy	photos.destroy

MVC: Controladores & vistas

• Laravel es mucho más que una arquitectura MVC

• No obstante esta es una parte fundamental del framework

• Veamos de momento como tratar controladores y vistas

Controladores

• Su ubican en app/Http/Controllers

• Para crear un controlador usaremos:

php artisan make:controller ControllerName

- Deberemos definir los métodos que necesitemos y asociarlos a una ruta del fichero de rutas (de momento, web.php).

• Si queremos usar rutas de tipo resource:

php artisan make:controller ControllerName --resource

- Ya nos vendrá con los 7 métodos asociados a una ruta resource

- OJO! Los formularios HTML no pueden usar PUT, PATCH ni DELETE. Podemos usar campos ocultos para falsear los verbos. El metodo helper `method_field` lo puede hacer por nosotros:

{{ method_field('PUT') }}
{{ method_field('DELETE') }}

• Si en un método necesitamos hacer uso del objeto $request debemos incluírlo en su cabecera con type hinting:

    public function foo(Request $request)
    {
        //
    }

• Podemos acceder a los parámetros GET y POST así:

    public function foo(Request $request)
    {
        $code = $request->code;
        $all = $request->all();
        dd($code);
    }

Vistas: Blade

• Las vistas en php: php + html ==> código poco claro.

• Mejor motores de plantillas que facilitan la inclusión de contenido variable en nuestro html.

• Motores de plantillas son:

  • Blade, usado por Laravel

  • Smarty, muy habitual, no ceñido a ningún framework

  • Twig, usado por Simphony.

• Código más limpio.

plantilla + compilación transparente = html + php

• En laravel se devuelven con la función helper view()

• Desde un controlador o ruta:

  return view('grupo.vista'); //estilo habitual
  return view('grupo/vista'); //también válido

  • Buscará una vista en el directorio resources/views/grupo

  • El fichero se llamará vista.blade.php o vista.php

• Para llevar variables a la vista debemos hacer lo siguiente:

  return view('grupo.vista', $arrayAsociativo);

• Ejemplos:

  return view('user.index', ['name' => 'James']);

  return view('blog.history', [
          'mes' => $mes,
          'ano' => $ano,
          'posts' => $posts
  ]);

• Existen otras variantes:

  • Con with:

  return view('greeting')->with('name', 'Victoria');

  • Y por último usando compact.

  return view('users', compact('mes', 'ano', 'posts'));
  //equivale a:
  return view('blog.history', [
          'mes' => $mes,
          'ano' => $ano,
          'posts' => $posts
  ]);

Modelos y Bases de datos.

• Un modelo se crea así:

  php artisan make:model Study

• Pero para hablar de modelos debemos entender como gestionar las BBDD.

• Para hacerlo Laravel nos brinda:

  • Migraciones

  • Seeders

  • Model Factrories

Migraciones

• Laravel provee un sistema llamado "migraciones" que permite elaborar la estructura de la base de datos de un modo paulatino.

• Las migraciones se asemejan a un control de versiones para la base de datos. Cada migración puede desplegarse o deshacerse según se precise.

• Facilitan enormemente el trabajo en equipo y mediante SCV (git u otro).

• Facilitan la migración de SGBD (Mysql, PostGres, ...).

• Facilitan la implantación en nuevos equipos de desarrollo o en producción.

• Debemos crear una migración por cada tabla.

• Debemos crearla con artisan y editarla después.

• Nota, en la versión 6 podemos crearla a la vez que el modelo:

php artisan make:migration create_studies_table  //crear migración
php artisan make:model -m Study //crear modelo y migración en un comando

• Para modificar una tabla tenemos dos opciones:

  • Modificar la migración de creación. NO SIEMPRE POSIBLE

  • Crear una migración de modificación. Ejemplo:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class ModifyUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->bigInteger('role_id')->unsigned()->default(1)->after('id');
            $table->foreign('role_id')->references('id')->on('roles');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropForeign('users_role_id_foreign');
            $table->dropColumn('role_id');
        });        
    }
}

Creación de migraciones

• Se usa artisan make:migration:

  // ej. comando base.
  php artisan make:migration create_users_table
  // ej. comando para creación de tabla. Añade código de creación.
  php artisan make:migration create_users_table --create=users

• El resultado es una clase hija guardada database/migrations

• El fichero se nombra usando el timestamp de creación para que sea ejecutado en el orden correcto.

Métodos de una migración

• up() sirve para modificar la base de datos. Típicamente crear una tabla.

• down() sirve para devolver la base de datos a su estado previo. Típicamente borrar una tabla.

<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateStudiesTable extends Migration
{
    /**
     * Run the migrations.
     * Ejecutar migración
     * @return void
     */
    public function up()
    {
        //code
    }

    /**
     * Reverse the migrations.
     * Deshacer
     * @return void
     */
    public function down()
    {
        //code
    }
}

Código de las migraciones

• Dentro de las funciones up y down usamos las funciones de la clase esquema para:

• Crear tablas:

Schema::create('studies', function (Blueprint $table) {
    $table->id();
    ...
    $table->timestamps();
});

• Modificar tablas.:

Schema::table('studies', function (Blueprint $table) {
    $table->string('name', 50)->change();
    $table->bigInteger('role_id')->unsigned()->default(1)->after('id');
    $table->string('description', 100)->after('name');
}

• Borrar tablas:

public function down()
{
    Schema::dropIfExists('studies');
}

• En las funciones anónimas (closure) de creación y modificación podemos hacer prácticamente cualquier cosa que soporte SQL. Debemos usar los métodos de la clase Blueprint aplicados a la variable $table:

  $table->string('email');  //añadir columna de texto VARCHAR(100). Hay métodos para muchos tipos de datos. Ver documentación.
  $table->string('name', 20);
  $table->tinyInteger('numbers');
  $table->float('amount');
  $table->double('column', 15, 8);
  $table->integer('votes');
  
  //podemos añadir modificadores e índices:
  $table->id();  //Clave principal, autoincremental, big integer.
  $table->char('codigo', 25)->primary(); //Otras claves principales
  $table->primary(['area', 'bloque']); // o así...
  $table->string('email')->nullable(); //añadir columna y permitir nulos.
  $table->timestamps(); //añade columnas create_at, update_at
  $table->string('email')->unique();  // columna con indice único
  $table->index(['account_id', 'created_at']); //índice multicolumna
  
  //claves ajenas: columna del tipo adecuado más f.k.
  $table->integer('user_id')->unsigned();
  $table->foreign('user_id')->references('id')->on('users');
  //podríamos añadir ->onDelete(cascade) ...

  • Los posibles modificadores son:

    ->first() | Place the column “first” in the table (MySQL Only)
    ->after('column') | Place the column “after” another column (MySQL Only)
    ->nullable() | Allow NULL values to be inserted into the column
    ->default($value) | Specify a “default” value for the column
    ->unsigned() | Set integer columns to UNSIGNED
    ->comment('my comment') | Add a comment to a column

• Para otras operaciones consultar la documentación oficial.

Seeders (o sembradores)

• Los seeders son clases usadas para:

• Rellenar las tablas con datos de prueba

• Cargar las tablas con datos iniciales.

• Creación con artisan:

php artisan make:seeder StudySeeder

• Los seeders tienen un método run() donde se registra el contenido de los registros a insertar. Puede usarse sintáxis de Query Builder o de Eloquent

• Ejemplo:

use Illuminate\Database\Seeder;
use App\Review;
class StudiesSeeder extends Seeder
{
    public function run()
    {
        //con eloquent
        Study::create([
        'code' => 'IFC303',
        'name' => 'Desarrollo de Aplicaciones Web',
        'abreviation' => 'DAW'
        ]);

        //lo mismo con query builder
        DB::table('studies')->insert([
        'code' => 'IFC303',
        'name' => 'Desarrollo de Aplicaciones Web',
        'abreviation' => 'DAW
        ]);
    }
}

• El orden en que se ejecutan los seeders se establece manualmente. Debe rellenarse el método run() de la clase DatabaseSeeder ubicada en database/seeds

public function run()
{
    $this->call(StudySeeder::class);
    $this->call(ModuleSeeder::class);
}

• Su ejecución es desde artisan:

  • Modo general php artisan db:seed

  • Junto a las migraciones: php artisan migrate:refresh --seed

  • De forma individual php artisan db:seed --class=ModuleSeeder

Model Factories

• Un factory es una clase usada principalmente para desarrollo

• Permite llenar nuestra base de datos con registros de prueba

• Crear un factory:

php artisan make:factory PostFactory

• Codificar un factory:

use Faker\Generator as Faker;

$factory->define(App\User::class, function (Faker $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'password' => '$2y$10$TKh8H1.PfQx37YgCzwiKb.KjNyWgaHb9cbcoQgdIVFlYg7B77UdFm', // secret
        'remember_token' => str_random(10),
    ];
});

• Usar el factory:

  • Crear un objeto con make() o con create(), el primero crea una variable, el segundo además la guarda en base de datos:

      $user = factory(App\User::class)->make();
      $user = factory(App\User::class)->create();

  • Podemos crear más de un registro en la misma orden:

  $users = factory(App\User::class, 3)->create();

  • Además podemos fijar o sobreescribir el valor de los campos:

$user = factory(App\User::class)->create([
    'name' => 'Abigail',
]);

Modelo

Bases de datos

• Para acceder a bases de datos podemos (por orden):

• ORM: Eloquent. Usado por Laravel y que usa una arquitectura Active Record.

• Fluent Query Builder. Un sistema de creación de consultas independiente del gestor de bbdd utilizado.

• SQL. Usar consultas de Raw Sql (sql en crudo o a pelo). Poco habitual

• Bases de datos compatibles:

• MySQL

• Postgres

• SQLite

• SQL Server

• https://laravel.com/docs/6.x/database

• Configuración:

• Fichero config/database.php.

• Pero basada en el .env.

• Podemos usar las bases de datos de forma convencional, creadas previamente.

• Más interesante usar migraciones como veremos.

Modelo

• Las clases modelo extienden una superclase llamada Model

• Heredan métodos muy interesantes.

• Permiten realizar multitud de operaciones sin escribir una sóla línea de código a través de Eloquent.

• Nomenclatura:

  • El nombre del modelo: tiene que ser en singular y mayúscula. P.ej. "User"

  • La la tabla asociada estará en plural y minúscula. P. ej. "users"

  • Clave primaria por defecho "id".

  • Eloquent usa las columnas created_at y updated_at para actualizar automáticamente esos valores de tiempo.

• Artisan nos ayuda a crear los modelos:

php artisan make:model Study    // sólo modelo
php artisan make:model Study -m // modelo y migración

• La migración es un fichero que nos permite ir creando a la BBDD a nuestra medida

  • Método up: crea o modifica una tabla

  • Método down: retrocede los cambios o borra la tabla

• Si queremos cambiar los parámetros por defecto respecto a nombre de tabla, clave primaria y uso de columnas temporales:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Study extends Model
{
  protected $table = 'estudio';
  $primaryKey = 'id_estudio';
  public $timestamps = false;
}

• Veamos un ejemplo de CRUD Study. Vamos a ver el código de las clases Study y de StudyController.

• Clase modelo. Muy sencillo porque Eloquent nos provee de los métodos que necesitamos.

<?php
namespace App;

use Illuminate\Database\Eloquent\Model;

class Study extends Model
{
    //$fillable indica que atributos se deben cargar en asignación masiva.
    protected $fillable = ['code', 'name', 'shortName', 'abreviation'];
}

• Clase modelo. Usamos los métodos que nos facilita Eloquent como son:

find($id) //Busca un registro
findOrFail($id) //Similar pero lanza excepción si falla. 
all() //Carga todos los registros.
paginate() //Carga una página de registros. Ver paginación.
save() //Guarda el objeto previamente cargado.
push() //Guarda el objeto y si hay objtetos relacionados modificados también lo hace.
delete() //Borra el objeto previamente cargado.
destroy($id) //Localiza y borra un registro (la variable tb. podría ser un array de ids).

• El controlador:

<?php
namespace App\Http\Controllers;

use Illuminate\Http\Request; 
use App\Http\Requests\StudyRequest; //usado para validación avanzada
use App\Study; //modelo Study

class StudyController extends Controller
{
    public function index()
    {
        $studies = \App\Study::all(); //toma todos los registros
        return view('study.index', ['studies' => $studies]);
    }
    
    public function create()
    {
        return view('study.create');
    }
    
    public function store(Request $request)
    {
        $this->validate($request, [
            'code' => 'required|unique:studies',
            'abreviation' => 'required|unique:studies',
            'name' => 'required',
            'shortName' => 'required'
            ]);
        $study = new Study($request->all());
        $study->save();
        return redirect('/study');
    }

    public function delete($id)
    {
        // modo 1
        // $study = Study::find($id);
        // $study->delete();
        // modo 2
        Study::destroy($id);
        return redirect('/study'); //redirigir
    }

    public function update($id)
    {
        $study = Study::find($id);
        return view('study.update', ['study' => $study]);
    }

    public function save(StudyRequest $request)
    {
        $study = Study::find($request->id);
        $study->code = $request->code;
        $study->name = $request->name;
        $study->shortName = $request->shortName;
        $study->abreviation = $request->abreviation;
        $study->save();
        return redirect('/study');
    }
}

Response

• Podemos reenviar la respuesta de diferentes modos:

• Reenvio a una ruta concreta:

//fichero de rutas:
//ruta destino con nombre definido
Route::get('destino/{sitio}', function ($sitio) {
    return "Destino: $sitio";
})->name('destino');

• Reenvío a rutas con nombre o con URL:

//código en el una fichero de rutas pero que podría ir en el controlador:
//reenvío ordinario por la URL
Route::get('teruel', function () {
    return redirect('/destino/Teruel');
});
//reenvío por nombre
Route::get('zaragoza', function () {
    return redirect()->route('destino', ['sitio' => 'Zaragoza']);
});

• Reenvío a la misma ruta de la que venimos, e incluso añadir mensajes de error:

//redirección simple:
return Redirect::back();

//igual pero con errores
return Redirect::back()->withErrors(['msg', 'The Message']);

//en la vista podríamos hacer:

@if($errors->any())
<h4>{{$errors->first()}}</h4>
@endif

• Reenviar a un método de un controlador:

  //a un método sin argumentos
  return redirect()->action('HomeController@index');
  //con argumentos
  return redirect()->action(
    'UserController@profile', ['id' => 1]
  );

Migraciones y Seeders

Migraciones

• Laravel provee un sistema llamado "migraciones" que permite elaborar la estructura de la base de datos de un modo paulatino.

• Las migraciones se asemejan a un control de versiones para la base de datos. Cada migración puede desplegarse o deshacerse según se precise.

• Facilitan enormemente el trabajo en equipo y mediante SCV (git u otro).

• Facilitan la migración de SGBD.

• Facilitan la implantación en nuevos equipos de desarrollo o en producción.

• Debemos crear una migración por cada tabla.

• Debemos crearla con artisan y editarla después.

• Nota, en la versión 6 podemos crearla a la vez que el modelo:

php artisan make:migration create_studies_table  //crear migración
php artisan make:model -m Study //crear modelo y migración en un comando

• Ejemplo de migración de la tabla studies:

<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateStudiesTable extends Migration
{
    /**
     * up crea la tabla
     * down la elimina
     */
    public function up()
    {
        Schema::create('studies', function (Blueprint $table) {
            $table->id();
            $table->string('code')->unique();
            $table->string('name');
            $table->string('shortName');
            $table->string('abreviation');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('studies');
    }
}

• Para modificar una tabla tenemos dos opciones:

  • Modificar la migración de creación. NO SIEMPRE POSIBLE

  • Crear una migración de modificación. Ejemplo:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class ModifyUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->bigInteger('role_id')->unsigned()->default(1)->after('id');
            $table->foreign('role_id')->references('id')->on('roles');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropForeign('users_role_id_foreign');
            $table->dropColumn('role_id');
        });        
    }
}

Ejecutar migraciones

• Las migraciones se gestionan desde la consola mediante comandos de artisan.

  • El comando base es php artisan migrate. En los siguientes apartados vamos a ver las variantes.

  migrate:install //Crea una tabla en la base de
    datos que sirve para llevar el control de las migraciones realizadas y su orden.
  migrate:reset //Realiza una marcha atrás de todas las migraciones en el sistema, volviendo el schema de la
    base de datos al estado inicial.
  migrate:refresh //Vuelve atrás el sistema de migraciones y las vuelve a ejecutar todas.
  migrate:rollback //Vuelve hacia atrás el último lote de  migraciones ejecutadas.
  * \ //hp artisan migrate:rollback --step=2 Vuelve atrás las últimas migraciones, en este ccaso los últimos dos lotes.
  migrate:status //Te informa de las migraciones presentes en el sistema y si están ejecutadas o no.

  Creación de migraciones

  • Se usa artisan make:migration:

    // ej. comando base.
    php artisan make:migration create_users_table
    // ej. comando para creación de tabla. Añade código de creación.
    php artisan make:migration create_users_table --create=users

• El resultado es una clase hija guardada database/migrations

• El fichero se nombra usando el timestamp de creación para que sea ejecutado en el orden correcto.

Métodos de una migración

• up() sirve para modificar la base de datos. Típicamente crear una tabla.

• down() sirve para devolver la base de datos a su estado previo. Típicamente borrar una tabla.

<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateStudiesTable extends Migration
{
    /**
     * Run the migrations.
     * Ejecutar migración
     * @return void
     */
    public function up()
    {
        Schema::create('studies', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     * Deshacer
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('studies');
    }
}

Código de las migraciones

• Dentro de las funciones up y down usamos las funciones de la clase esquema para:

  • Crear tablas: Schema::create('nommbreTabla', 'funcion_closure');

  • Renombrar tablas: Schema::rename\($original, $nuevo\);

  • Borrar tablas: Schema::drop('users'); o Schema::dropIfExists('users');

  • Modificación de tablas: Schema::table('nommbreTabla', 'funcion_closure');

• En las funciones anónimas (closure) de creación y modificación podemos hacer prácticamente cualquier cosa que soporte SQL. Debemos usar los métodos de la clase Blueprint aplicados a la variable $table:

  $table->string('email');  //añadir columna de texto VARCHAR(100). Hay métodos para muchos tipos de datos. Ver documentación.
  $table->string('name', 20);
  $table->tinyInteger('numbers');
  $table->float('amount');
  $table->double('column', 15, 8);
  $table->integer('votes');
  
  //podemos añadir modificadores e índices:
  $table->id();  //Clave principal autoincremental usado por defecto.
  $table->char('codigo', 25)->primary(); //Otras claves principales
  $table->primary(['area', 'bloque']); // o así...
  $table->string('email')->nullable(); //añadir columna y permitir nulos.
  $table->timestamps(); //añade columnas create_at, update_at
  $table->string('email')->unique();  // columna con indice único
  $table->index(['account_id', 'created_at']); //índice multicolumna
  
  //claves ajenas: columna del tipo adecuado más f.k.
  $table->integer('user_id')->unsigned();
  $table->foreign('user_id')->references('id')->on('users');
  //podríamos añadir ->onDelete(cascade) ...

  • Los posibles modificadores son:

    ->first() | Place the column “first” in the table (MySQL Only)
    ->after('column') | Place the column “after” another column (MySQL Only)
    ->nullable() | Allow NULL values to be inserted into the column
    ->default($value) | Specify a “default” value for the column
    ->unsigned() | Set integer columns to UNSIGNED
    ->comment('my comment') | Add a comment to a column

• Para otras operaciones consultar la documentación oficial.

Seeders (o sembradores)

• Los seeders son clases usadas para:

• Rellenar las tablas con datos de prueba

• Cargar las tablas con datos iniciales.

• Creación con artisan:

php artisan make:seeder StudySeeder

• Los seeders tienen un método run() donde se registra el contenido de los registros a insertar. Puede usarse sintáxis de Query Builder o de Eloquent

• Ejemplo:

use Illuminate\Database\Seeder;
use App\Review;
class StudiesSeeder extends Seeder
{
    public function run()
    {
        //con eloquent
        Study::create([
        'code' => 'IFC303',
        'name' => 'Desarrollo de Aplicaciones Web',
        'abreviation' => 'DAW'
        ]);

        //lo mismo con query builder
        DB::table('studies')->insert([
        'code' => 'IFC303',
        'name' => 'Desarrollo de Aplicaciones Web',
        'abreviation' => 'DAW
        ]);
    }
}

• El orden en que se ejecutan los seeders se establece manualmente. Debe rellenarse el método run() de la clase DatabaseSeeder ubicada en database/seeds

public function run()
{
    $this->call(StudySeeder::class);
    $this->call(ModuleSeeder::class);
}

• Su ejecución es desde artisan:

  • Modo general php artisan db:seed

  • Junto a las migraciones: php artisan migrate:refresh --seed

  • De forma individual php artisan db:seed --class=ModuleSeeder

Model Factories

• Crear un factory:

php artisan make:factory PostFactory

• Codificar un factory:

use Faker\Generator as Faker;

$factory->define(App\User::class, function (Faker $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'password' => '$2y$10$TKh8H1.PfQx37YgCzwiKb.KjNyWgaHb9cbcoQgdIVFlYg7B77UdFm', // secret
        'remember_token' => str_random(10),
    ];
});

• Usar el factory:

  • Crear un objeto con make() o con create(), el primero crea una variable, el segundo además la guarda en base de datos:

      $user = factory(App\User::class)->make();
      $user = factory(App\User::class)->create();

  • Podemos crear más de un registro en la misma orden:

  $users = factory(App\User::class, 3)->create();

  • Además podemos fijar o sobreescribir el valor de los campos:

$user = factory(App\User::class)->create([
    'name' => 'Abigail',
]);

Relaciones entre tablas/modelos

• El ORM Eloquent no pone fácil para tratar las relaciones entre tablas.

• Basta añadir algunos métodos a los modelos implicados.

• Vamos a ver únicamente las relaciones 1:N

• Para relaciones 1:1 y N:M ver la documentación

• Vamos a verlo con el ejemplo entre usuarios y roles: un Role puede tener varios Users y un User pertenece a un Role.

• Crear modelo Role (y migración, seeder y controlador)

  • -m añade la migración

  • -s añade el seeder

  • -cr añade el controlador (c) tipo resource (r)

php artisan make:model Role -mscr

• Métodos de la migración

    public function up()
    {
        Schema::create('roles', function (Blueprint $table) {
            $table->id();
            $table->string('name')->unique();
            $table->timestamps();
        });
    }
    public function down()
    {
        Schema::dropIfExists('roles');
    }

• Modificación de la tabla users.

  • Es habitual tener que modificar tablas que ya existen. Para eso usamos migraciones un poco diferentes:

    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->unsignedBigInteger('role_id')->default(1);        
            $table->foreign('role_id')->references('id')->on('roles');
        });
    }
    public function down()
    {
        //las fk se mombran así: tabla_columna_foreign
        //esto se usa para eliminar la clave en el down
        Schema::table('users', function (Blueprint $table) {
            $table->dropForeign('users_role_id_foreign');
            $table->dropColumn('role_id');
        });
    }

• Creamos o modificamos el RoleSeeder y el UserSeeder:

    public function run()
    {
        //con DB
        \DB::table('roles')->insert([
            'id' => '1',
            'name' => 'registrado'
        ]);
        
        \DB::table('roles')->insert([
            'id' => '2',
            'name' => 'usuario'
        ]);
        
        \DB::table('roles')->insert([
            'id' => '3',
            'name' => 'administrador'
        ]);
        
    }

    public function run()
    {
        //con DB
        \DB::table('users')->insert([
            'id' => '1',
            'name' => 'registrado',
            'email' => '[e-mail]',
            'password' => bcrypt('secret')
        ]);
    
        \DB::table('users')->insert([
            'id' => '2',
            'name' => 'usuario',
            'email' => '[e-mail]',
            'password' => bcrypt('secret'),
            'role_id' => 2
        ]);
    
        \DB::table('users')->insert([
            'id' => '3',
            'name' => 'admin',
            'email' => '[e-mail]',
            'password' => bcrypt('secret'),
            'role_id' => 3
        ]);
    }

• No debemos olvidar actualizar el DatabaseSeeder:

    public function run()
    {
        $this->call(RoleSeeder::class);
        $this->call(UserSeeder::class);
        $this->call(StudiesSeeder::class);
        // \App\Models\User::factory(10)->create();
    }

• Por fín los modelos: Vamos a tratar una relación 1:N

• Un Role tiene muchos Users asociados.

• La clase Role debe incluír el siguiente método:

class Role extends Model
{
    // resto del código
    //el método users nos devolverá una colección de usuarios
    //el nombre es significativo
    public function users()
    {
        return $this->hasMany(User::class);
    }
}

• Un User pertenece a un Role.

• La clase Role debe incluír el siguiente método:

    class User extends Authenticatable
    {
        // resto del código
        //el método role nos devolverá un objeto role
        // el nombre también es significativo
        public function role()
        {
            return $this->belongsTo(Role::class);
        }       
    }

• Ahora podemos usarla en nuestras vistas.

• Por ejemplo en "user/index.blade.php"

    @foreach($users as $user)
    <tr>
        <td>{{ $user->name }}</td>
        <td>{{ $user->role->name }}</td>
    </tr>
    @endforeach

• O en "role/show.blade.php"

{{ $role->name }}

<h2>Lista de usuarios</h2>

@foreach ($role->users as $user)
  <li>{{$user->name}}</li>
@endforeach

Middleware

• Los middleware son filtros que se ejecutan antes de que el control pase a una ruta o a un controlador.

• Podemos asciar un middleware a una ruta:

Route::get('profile', 'UserController@show')->middleware('auth');

• O a un controlador, en su constructor:

class UserController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth'); //aplicable a todos los métodos
        $this->middleware('log')->only('index');//solamente a ....
        $this->middleware('subscribed')->except('store');//todos excepto ...
    }
}

kernel.php

• En el kernel.php de la aplicación se definen varias cuestiones relativas a los middleware.

• Un grupo de middleware que se aplican a todas las peticiones. Atributo $middleware.

• Se asignan nombres a los middleware para ser usados en las rutas. Atributo $routeMiddleware.

• Dos grupos de middleware:

  • web que se aplica a todas las rutas definidas en el fichero de rutas web.php

  • api que se aplica a las rutas del fichero api.php

Ejemplos de middleware

• CheckForMaintenanceMode Se aplica a todas las rutas. Se activa su funcionalidad con los comandos:

php artisan down
php artisan up

• Después de down genera un error 503

• Comprueba la existencia del fichero /storage/framework/down

• Down crea el fichero, up lo borra.

• Vamos a ver los que se aplican a todas las peticiones web.

• EncryptCookies. Encripta las cookies

• AddQueuedCookiesToResponse. Añade las cookies creadas mediante el método Cookie::queue($micookie);

• StartSession. Inicia sesión de forma automática.

• ShareErrorsFromSession Hace visible el objeto errors tras la validación.

• VerifyCsrfToken. Verifica los token CSRF.

• SubstituteBindings ¿?

• Además, dispondemos de los siguientes definidos en route:

• auth. Pasa el filtro si estás autenticado.

• guest. Pasa el filtro si no has hecho login

• can. Filtro usado para autorización.

• throttle. Limita el número de peticiones por minuto aceptadas desde un host determinado.

Construir un middleware:

• Usamos artisasn:

php artisan make:controller MiddlewareEsAdmin

• Código.

• La lógica está en la función handle.

• Si se dan las condiciones adecuadas se pasa el filtro (return $next($request);)

• Si no se dan las condiciones abortar o redirigir.

<?php

namespace App\Http\Middleware;

use Closure;

class IsAdmin
{
   public function handle($request, Closure $next)
   {
       $user = $request->user();
       if ($user && $user->username == 'admin') {
           return $next($request);
       }
       abort(403, 'acceso denegado');
   }
}

• Registrar el middleware en el kernel dentro de $routeMiddleware

• Ya podemos usarlo como el resto:

Route::get('families/ajax', 'FamilyController@ajax')->middleware('admin');

Sesiones y Autenticación

Autenticación

• Ya vimos como añadir el sistema de autenticación propio de Laravel

• Disponde de un juego de migraciones, rutas, controladores y vistas que hacen posible la gesión de usuarios

• Documentación oficial: https://laravel.com/docs/7.x/frontend#introduction

• Autenticarse es identificarse, que la apliación nos reconozca como un usuario concreto.

• Para hacerlo debemos hacer uso de variables de sesión.

• Laravel viene con un sistema base muy completo. Vamos a usar la versión usada en Laravel 7:

    composer require laravel/ui
    php artisan ui bootstrap --auth

• Las vistas generadas están construidas con Twiter Bootstrap y se almacenan en el directorio: resources/views/auth.

• Rutas:

  • Para login se usa /login

  • Tras el login se usa /home. Puede personalizarse en el LoginController.

  • Por defecto el nombre de usuario es su e-mail.

  • Para cerrar la sesión: logout

  • Para resetear la contraseña: password/reset

• Para el reseteo de contraseñas se envia un correo con un token.

• Para pasar los mails a log y no enviar realmente:

  • En el fichero .env cambiar el parámetro: `MAIL_DRIVER=log `

  • Completar en config/mail.php:

    'from' => [
      'address' => env('MAIL_FROM_ADDRESS', '[e-mail]'),
      'name' => env('MAIL_FROM_NAME', 'Adminstrador'),
    ],

  • Los correos se guardan en storage/logs

  • Podemos ver el correo enviado para resetear contraseña

• Si queremos acceder a la información del usuario actual debemos usar la clase fachada Auth.

//Mostrar la información de usuario
Route::get('usuario', function () {
    $user = Auth::user();  //namespace global: \Auth
    dd($user);
    //si sólo nos interesa el id podríamos hacer:
    //$id = Auth::id();
});

Sesiones

• Los parámetros de configuración de sesiones se definen en config/session.php.

• Importante es el almacenamiento y el tiempo de vida de la sesión.

• Con Laravel no es preciso usar directamente la variable $_SESSION.

• ni debemos usar las funciones session_start() o session_destroy()

• Podemos acceder a un dato guardado en sesión de tres modos:

  • El request, esto requiere inyección de dependencias:

    public function showProfile(Request $request, $id)
    {
      $value = $request->session()->get('key');
    }

  • La fachada Session

    $value = Session::get('key');

  • La función helper session():

    $value = session('key');

• Obtener todos los datos de una sesión

  $data = $request->session()->all();
  $data = Session::all(); //usando el Facade

• Podemos guardar datos en sesión de dos modos:

  $request->session()->put('email', '[e-mail]');
  session(['email' => '[e-mail]']); //usando el helper

• Podemos eliminar datos de sesión:

  $request->session()->forget('key'); //elemento key
  $request->session()->flush();   // todos
  Session::flush();               //todos con la fachada

• Guardar datos sólo durante una petición (request) sólamente.

• Esto se usa en validaciones de forma automática, transparente al usuario

  • Para los datos antiguos (old)

  • Para los mensajes de error

  //después de una petición se elimina. 
  $request->session()->flash('mensaje', '¡El usuario fue eliminado!');   
  //guardar los datos flasheados un request más.
  $request->session()->reflash();  
  //guardadr datos flasheados.
  $request->session()->keep(['mensaje', 'email']); 

Query Builder. Paginación

• Laravel nos permite realizar gran cantidad de consultas sin escribir sql.

• Hasta el momento, sobre los modelos hemos usado algunos métodos: find(), all(), save(), first().

• Las consultas pueden construirse a través de los modelos (User, Role, ...) o de la clase DB:

//todos los usuarios:
$user = User::first(); //mejor así para obtener objetos User
$user = DB::first(); //así obtenmos objetos "básicos"

• Vamos a poder filtrar usando where en alguna de sus variantes.

• El método all() no admite filtrado con where.

• Debemos usar get()

    $users = User::where('id', 100)->get();
    $users = User::where('id', '>', 100)->get();

    $users = User::where('id', '<=', 100)
        ->where('email', '[e-mail]')
        ->get();

• Existen otras variantes que podemos consultar en la documentación:

  • orWhere()

  • whereBetween()

  • whereIn()....

• No vamos a ver su uso. Queda como investigación del alumno.

• Para paginar basta con cambiar get() por paginate

    $users = $query->paginate(); //tamaño 15
    $users = $query->paginate($pageSize); //tamaño $pageSize

• En la vista la generación del índice de páginas es automático.

    {{$users->links()}} //estándar: Tailwind CSS
    {{$users->links('pagination::bootstrap-4')}} //Bootstrap

• En la rama del proyecto de clase "clase07" ha sido necesario depurar el código

• Puedes ver las explicaciones en los vídeos de dicha rama.

Validación

• La validación es una cuestión fundamental en cualquier aplicación, no sólo web. Cualquiera.

• Validar consiste en verificar la validez de los datos antes de procesarlos.

• ¿Validar en cliente o en servidor?.

• En el cliente es más rápido, no necesitamos conectar con el servidor ni hacer uso de la red.

• Pero nunca debemos confiar en la validación realizada en el cliente. Puede ser burlada intencionadamente o anulada de forma involuntaria.

• Validar en el cliente es opcional pero en el servidor es obligatorio.

Cómo validar en Laravel

• Existen varias maneras de hacerlo.

• Nosotros usaremos el método validate del objeto $request.

Ejemplo:

public function store(Request $request)
{
    $request->validate([
    'title' => 'required|unique:posts|max:255',
    'body' => 'required',
    ]);
    //validado ->  a guardar
} 

¿¿Qué pasa tras la validación ??

• Si la validación falla se produce una excepción y se reenvía la petición a la URL previa.

• Se crea un objeto $errors que permite mostrar los errores de validación.

• Los datos del formulario se flashean a la sesión y estarán disponibles sólo en la próxima peticicón para ser volver a rellenar el formulario como estaba.

• OJO. Si usamos Ajax se envía una respuesta al cliente con un código 422 y un JSON con los mensajes de error.

Rellenando con los datos viejos

• La funcion helper old() nos permite acceder a los datos que no se han validado y están en la sesión.

<label>Nombre:</label>
<input type="text" name="name" value="{{ old('name')}}">

Mostrando los errores con blade

• Todos los errores de la página

@foreach ($errors->all() as $error)
<li>{{ $error }}</li>
@endforeach

• Mostrar los errores de un campo:

//sólo el primero
{{ $errors->first('name') }}
//o todos los del campo
@foreach($errors->get('name') as $error)
{{ $error }}
@endforeach 

• También podemos usar la directiva @error de blade:

<label for="title">Post Title</label>

<input id="title" type="text" class="@error('title') is-invalid @enderror">

@error('title')
    <div class="alert alert-danger">{{ $message }}</div>
@enderror

Traduciendo mensajes

• Podemos traducir todos los literales de Laravel. No sólo los de validación.

• Debemos acceder a la siguiente ruta

• Descargar la carpeta del idioma que nos interese.

• Configurar el lenguaje en config.php

Reglas

• Se pueden añadir múltiples reglas para cada campo. Entre comillas y separadas por la barra vertical.

• La regla bail hace que no se sigan evaluando más reglas si esa falla.

• Revisar la documentación oficial: Available Validation Rules.

Unique y update

• Ojo cuando apliquemos la regla unique en actualizaciones (update).

• Si aplicamos la regla sin más va a fallar porque ya existe un registro con ese dato:

    'code' => 'required|unique:studies|max:6',

• Debemos indicar que no tenga en cuenta el propio registro para comprobar esta regla:

    'code' => 'required|max:6|unique:studies,code,' . $study->id,

Otros modos de validar

• Hemos planteado la forma habitual pero existen otras:

  • Creando clases Request a la medida de una validación.

  • Creando clases Validator

• Ambas soluciones son algo más sofisticadas y no las vamos a usar aunque podrían dar solución a situaciones más complejas.

Autorización: reglas y políticas

• Laravel nos brinda dos sistemas para autorizar acciones: reglas y puertas.

• Reglas

• Las reglas se definen asociadas a la clase Gate.

• Son una solución más simple.

• Políticas

• Son soluciones más elaboradas que engloban la autorización referida a un modelo concreto.

• Se definen en clases dentro guardadas en app/Policies

• Tienen una analogía a rutas y controladores, simpliciad vs complejidad y orden.

• En un proyecteo usaremos una u otra (o ambas) de acuerdo a su complejidad y envergadura.

Definir reglas

• Las reglas se definen en el AuthServiceProvider.php, dentro de su función boot.

• Podemos definir una regla con un closure (función anónima) dentro de dicho método:

public function boot()
{
    $this->registerPolicies(); 
    //nuestra regla es esta:
    Gate::define('update-post', function ($user, $post) {
        return $user->id == $post->user_id;
    });
}

Usar reglas

• Para comprobar las reglas debemos usar la fachada Gate y alguno de sus métodos (allows, denies). Lo podemos hacer en la propia ruta o más correctamente en el controlador o en un middleware:

if (Gate::denies('update-post', $post)) {
    abort(403);
    //o podríamos redireccionar:
    // return redirect('/home');
    // o mostrar una vista
    // return view('nombreVista');
}

• Observa que el $user no es pasado a la clase Gate, toma el autenticado. Si quisieramos pasarlo debemos hacerlo así:

//preguntando si se le permite
if (Gate::forUser($user)->allows('update-post', $post)) {
    // The user can update the post...
}
//o al revés ...
if (Gate::forUser($user)->denies('update-post', $post)) {
    // The user can't update the post...
}

Políticas

• Si el proyecto es pequeño la solución anterior es válida pero para algo grande puede no ser una buena solución.

• Las políticas separan código para no sobrecargar el código del AuthServiceProvider.

• Las políticas son clases guardadas en app/Policies y que se crean así:

//clase en blanco
php artisan make:policy PostPolicy
//clase con reglas CRUD predefinidas asociada a un modelo
//recomendable:
php artisan make:policy PostPolicy --model=Post

• Tras crear las políticas, éstas deben ser regitradas en el AuthServiceProvider:

class AuthServiceProvider extends ServiceProvider
{
    //deben incluírsee en el siguiiente array:
    protected $policies = [
        Post::class => PostPolicy::class,
    ];

Escribiendo las políticas:

• Podemos crear los métodos que necesitemos. Por ejemplo el método update lo podemos usar para actualizar un objeto del modelo afectado. Sus argumentos deben ser el user y un objeto del modelo protegido:

public function update(User $user, Post $post)
{
    return $user->id === $post->user_id;
}
//aunque si el método no usa ningún objeto del modelo lo podemos dejar así:
public function create(User $user)
{
    return true; //una expresión booleana...
}

• El método before permite tomar decisiones generales sin evaluar la política

public function before($user, $ability)
{
    if ($user->isSuperAdmin()) {
        return true;
    }
}
// si devuelve true -> autorizado. No comprueba nada más
// si devuelve false -> denegado. No comprueba nada más
// si devuelve null -> lo que diga la regla usada

TODO:

• Test

• Modelos y BBDD

• Errores

• Eloquent & Query Builder

• Relaciones

• Multi Idioma

• Ajax

• Paginación

• Mail

• Pdf

• Trabajo