Nel giugno del 2011 Taylor Otwell ha rilasciato Laravel, un framework PHP open-source per applicazioni web che da allora &egrave; diventato il framework PHP pi&ugrave; utilizzato. Per capire il successo di Laravel, &egrave; importante prima di tutto osservare com&#39;era il panorama delle applicazioni web prima del suo arrivo. Nell&#39;era di PHP5, c&#39;erano essenzialmente solo tre framework in uso: Zend Framework, CakePhp e CodeIgniter. Questo era lo scenario quando, nel 2005, SensioLabs introdusse Symfony, il primo framework PHP moderno. Grazie a Symfony, PHP &egrave; stato introdotto al concetto di MVC (Model View Controller), ORM (Object-Relational Mapping) e strutture dati tipiche di Ruby on Rails.La prima versione stabile di Symfony, la 0.1.0, &egrave; stata resa disponibile il 10 ottobre 2005, mentre la versione 1.0 &egrave; stata rilasciata il 30 luglio 2009. Nonostante ci&ograve;, gli sviluppatori PHP continuarono a utilizzare principalmente CodeIgniter, che all&#39;epoca era considerato la scelta principale per le sue funzioni semplici ma potenti.Ed ecco che finalmente arriva Taylor Otwell, il creatore di Laravel. Otwell era intenzionato a creare un framework che sopperisse alle lacune di CodeIgniter, come ad esempio l&rsquo;autenticazione e l&rsquo;autorizzazione. Ha cominciato a lavorare su Laravel come progetto secondario nel 2011, e da allora &egrave; cresciuto cos&igrave; tanto da diventare un&#39;azienda a tutti gli effetti, con decine di dipendenti.Otwell &egrave; responsabile di tutti gli aspetti dello sviluppo di Laravel, dal design e l&#39;architettura al marketing e alla gestione della community. &Egrave; anche un relatore alle conferenze PHP e ha scritto diversi libri su Laravel e sullo sviluppo web.Non &egrave; un mistero che Laravel abbia preso ispirazione da Symfony, visto che ne condivide circa il 30% del suo codice. Ma questo &egrave; del tutto naturale, visto che Symfony &egrave; un framework modulare. Di conseguenza, molti progetti/sviluppatori hanno riadattato le sinfonie in pacchetti per Laravel.Dopo aver ripercorso le tappe storiche di Laravel, andiamo a vedere quali sono le sue principali caratteristiche che hanno conquistato il settore dello sviluppo PHP:<ul>	<li>Artisan, una potentissima CLI per gestire l&rsquo;applicazione da riga di comando</li>	<li>Tinker, un potente REPL per interagire con le classi di Laravel da terminale</li>	<li>Migrations, per versionare lo schema del database</li>	<li>Seeders, per popolare il database</li>	<li>Requests, per validare i dati immessi dagli utenti nei moduli</li>	<li>Eloquent, per mappare i dati nel database</li>	<li>Composer, per gestire dipendenze e packages</li>	<li>Asset Bundling per gestire gli assets attraverso npm</li></ul>Facciamo subito una precisazione, per anticipare critiche che non vedono nulla di innovativo in questi strumenti. &Egrave; vero, la ruota &egrave; gi&agrave; stata inventata: le migrations sono tipiche dei software Ruby on Rails, Tinker si usa in molti linguaggi (basti pensare a Python) Artisan &ldquo;scimmiotta&rdquo; il rails di Ruby on Rails, e cos&igrave; via.Il punto di forza di Laravel non &egrave; l&rsquo;innovazione, ma la possibilit&agrave; di estendere il framework facilmente, proprio grazie a tutti questi strumenti appena elencati. Basti pensare ai service provider che permettono di agganciare packages appositi per Laravel. Anche adesso, nel 2022, se dovessi scegliere un framework completo in php, non avrei dubbi a scegliere Laravel.

Nel giugno del 2011 Taylor Otwell ha rilasciato Laravel, un framework PHP open-source per applicazio

Presentazione del Framework Laravel

Il modello Model-View-Controller (MVC) nell&#39;ingegneria del software &egrave; un modo per dividere il codice in tre sezioni distinte. Il modello ospita i dati e la logica aziendale, la vista gestisce l&#39;interfaccia utente e il controllore funge da mediatore tra i due. Questa separazione delle responsabilit&agrave; porta a un codice pi&ugrave; modulare e manutenibile, consentendo inoltre ai membri del team di lavorare contemporaneamente su diversi elementi del codice. Ad esempio, un designer pu&ograve; lavorare sulla vista mentre un programmatore si concentra sul controller.<h2>Controllers</h2>In Laravel, i controllers sono contenuti all&rsquo;interno della cartella app/Http/Controllers e, come abbiamo anticipato, sono responsabili della gestione degli input dell&#39;utente e della generazione della risposta appropriata.Nella maggior parte dei casi, il controller riceve la richiesta dell&#39;utente, la convalida e poi la passa ad un modello per l&#39;elaborazione. Una volta che i dati sono stati elaborati, il controller genera l&#39;output appropriato e lo passa alla vista.<h2>Models</h2>Nel pattern MVC, il modello &egrave; responsabile del recupero, della creazione, dell&#39;aggiornamento e della cancellazione dei dati. In Laravel, i models sono contenuti all&rsquo;interno della cartella app/Models.Oltre alle operazioni CRUD di base, un modello potrebbe contenere anche altre business logics, come operazioni di casting e relazioni con altri modelli. In breve, un modello viene utilizzato per incapsulare tutta la logica necessaria per manipolare i dati.Visto che l&rsquo;argomento Model &egrave; estremamente vasto, tratteremo l&rsquo;argomento in maniera pi&ugrave; approfondita nel capitolo dedicato ad Eloquent, l&rsquo;ORM di Laravel.Per adesso, mi sento solo di aggiungere che per convenzione di Laravel, i Modelli sono dichiarati usando il nome al singolare, mentre la relativa tabella va dichiarata usando il plurale (ovviamente in inglese). &Egrave; comunque possibile bypassare questo standard, valorizzando la propriet&agrave; table di ogni modello.<h2>Views</h2>La vista &egrave; il componente che il software utilizza per servire l&#39;interfaccia all&rsquo;utente. Per impostazione predefinita, in Laravel tutte le viste sono contenute nella cartella resources/views.Le viste contengono HTML, gli assets JavaScript e CSS, dati dinamici che sono passati dal Controller. Laravel utilizza un proprio template engine, denominato Blade che ha una sua sintassi, molto intuitiva. Il framework le compila in codice PHP e poi le memorizza nella cache fino a quando non vengono modificate.

Il modello Model-View-Controller (MVC) nell&#39;ingegneria del software &egrave; un modo per divider

Il pattern MVC in Laravel

In questo capitolo vedremo come installare correttamente Laravel su ambiente Linux con l&rsquo;obiettivo finale di visualizzare a video la schermata di benvenuto. Installeremo l&rsquo;ultima versione stabile che, nel momento in cui si scrive, &egrave; la 9.41.0Innanzitutto, dobbiamo verificare la presenza delle dipendenze necessarie per far girare il software:<ul>	<li>PHP &gt;= 8.0.2</li>	<li>Le librerie ctype, json, mbstring, tokenizer, xml e curl</li>	<li>Composer</li>	<li>Un database relazionale</li>	<li>Node.js</li>	<li>NPM</li></ul>Laravel 9 supporta 5 RDBMS:<ul>	<li>MariaDB &gt;= 10.3</li>	<li>MySQL &gt;= 5.7</li>	<li>PostgreSQL &gt;= 10.0</li>	<li>SQLite &gt;= 3.8.8</li>	<li>SQL Server &gt;= 2017</li></ul>In questa guida faremo riferimento a MySQL. Cominciamo proprio dal database, creando lo schema per la nostra prima applicazione Laravel. Non mi soffermo sulle varie procedure di questa fase, supponendo che sappiate come creare un database, un utente per MySQL e abbinare i relativi permessi.Fatto questo, dobbiamo occuparci dei permessi a livello di sistema. Questo perch&eacute;? Perch&eacute; come abbiamo detto nel capitolo introduttivo di questa guida, Laravel dispone di una CLI di comando che viene utilizzata dall&rsquo;utente di sistema, mentre l&rsquo;applicazione web viene invocata dall&rsquo;utente del web server. Quindi, per farla breve, dobbiamo aggiungere l&rsquo;utente di sistema al gruppo del web server.Se utilizziamo Apache, sulle distribuzioni basate su Debian, utente e gruppo si chiamano www-data, mentre sulle distro Red Hat la denominazione &egrave; apache.Quindi, supponendo che siamo su Ubuntu, lanciamo il seguente comando da terminale<pre><code>sudo usermod -a -G www-data $USER</code></pre>Sempre da terminale, navighiamo fino alla cartella del web server che ospiter&agrave; la nuova applicazione e successivamente scarichiamo attraverso l&rsquo;ultima versione di Laravel:<pre><code>composer create-project laravel/laravel mr-webmaster</code></pre>Terminata la procedura, torniamo ad occuparci dei permessi, impostando correttamente utente e gruppo per tutta l&rsquo;applicazione<pre><code>sudo chown -R $USER:www-data mr-webmaster/</code></pre>Diamo la possibilit&agrave; al software di scrivere sulla cartella destinata al salvataggio dei logs e dei files<pre><code>sudo chmod -R 775 mr-webmaster/storage</code></pre>Ora navighiamo all&rsquo;interno dell&rsquo;applicazione e installiamo i pacchetti di default, utilizzando sempre composer<pre><code>cd mr-webmaster/
composer install</code></pre>Al termine della procedura vedremo una nuova cartella vendor, dove sono contenuti tutti i packages del framework, compresi quelli del core stesso che hanno come namespace Illuminate.Il prossimo step &egrave; la creazione del file di configurazione dell&rsquo;ambiente. All&rsquo;interno dell&rsquo;applicazione che abbiamo installato c&rsquo;&egrave; un modello da cui partire, .env.example. Creiamone una copia, rinominandola in .env<pre><code>cp .env.example .env</code></pre>Apriamo il nuovo file .env e modifichiamo i parametri per la connessione al database, impostando quelli corretti del nostro ambiente<pre><code>DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_db
DB_USERNAME=your_db_username
DB_PASSWORD=your_db_password</code></pre>Salviamo il file e da terminale generiamo una chiave sicura e casuale che verr&agrave; utilizzata dal framework per criptare elementi come cookie e sessioni dei file.<pre><code>php artisan key:generate</code></pre>Questo comando aggiunge la chiave direttamente nel file .env, quindi ricordiamoci di replicare l&rsquo;operazione nel momento in cui si far&agrave; il deploy in produzione.Ok, abbiamo quasi finito. Lanciamo il comando per ripulire la cache del software<pre><code>php artisan optimize</code></pre>E finalmente possiamo visualizzare la nostra pagina di benvenuto. Non abbiamo ancora configurato Apache, quindi useremo il web server incorporato in PHP, digitando da terminale il comando<pre><code>php artisan serve</code></pre>Apriamo l&rsquo;url che il terminale ci ha restituito come output e godiamoci il nostro nuovo framework.

In questo capitolo vedremo come installare correttamente Laravel su ambiente Linux con l&rsquo;obiet

Come installare e configurare Laravel

Artisan &egrave; un&#39;interfaccia a riga di comando inclusa in Laravel che fornisce una serie di comandi per aiutare l&#39;utente nel flusso di sviluppo.&Egrave; possibile utilizzare Artisan eseguendo il comando &quot;php artisan&quot; dal terminale. Verr&agrave; visualizzato un elenco di tutti i comandi disponibili. &Egrave; quindi possibile eseguire un comando specifico digitando &quot;php artisan [comando]&quot;.I comandi pi&ugrave; utilizzati di Artisan sono quelli che generano i componenti del framework con un costrutto di base gi&agrave; impostato. Ad esempio, per creare un nuovo Controller &ldquo;UserController&rdquo; baster&agrave; eseguire il seguente comando:<pre><code>php artisan make:controller UserController</code></pre>Una volta eseguito il comando, troveremo la classe UserController all&rsquo;interno della cartella App/Http/Controllers. Questa classe sar&agrave; vuota, ma se avessimo voluto aggiungere i metodi per una CRUD, sarebbe bastato aggiungere l&rsquo;attributo &ndash;resource al comando precedente:<pre><code>php artisan make:controller UserController --resource</code></pre>&Egrave; anche possibile creare con un singolo comando la maggior parte dei files che compongono un componente. Ad esempio se dovessimo gestire la CRUD di un&rsquo;ipotetica entit&agrave; &ldquo;City&rdquo;, potremmo lanciare questo comando:<pre><code>php artisan make:model City -mcr</code></pre>In questo modo, Laravel creer&agrave; per noi il modello, il controller con i metodi per la CRUD e il file per migrare la struttura della tabella.<h2>Estendere Artisan</h2>Artisan non serve solamente a creare dei files. Ad esempio lo utilizzeremo per riempire il database con dati di test, gestire cron-job e tanto altro. Possiamo anche creare comandi personalizzati che andranno ad estendere la classe <code>Illuminate/Console/Command</code>.I comandi personalizzati possono essere eseguiti come qualsiasi altro comando di Artisan. &Egrave; possibile eseguirli dal terminale o includerli nel codice dell&rsquo;applicazione Laravel, utilizzando l&rsquo;apposita Facade Artisan.Vediamo un comando di esempio che ci stamper&agrave; sul terminale un saluto concatenando il parametro immesso dall&rsquo;utente ad una stringa predefinita.Utilizziamo Artisan per creare un nuovo comando personalizzato<pre><code>php artisan make:command Hello</code></pre>Il nostro nuovo comando sar&agrave; creato all&rsquo;interno della cartella app/Console/Commands e ovviamente il file si chiamer&agrave; Hello.phpApriamo con il nostro Code Editor e vediamo come si presenta questa classe<pre><code class="language-php">&lt;?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class Hello extends Command {
 /**
 * The name and signature of the console command.
 *
 * @var string
 */
 protected $signature = 'command:name';

 /**
 * The console command description.
 *
 * @var string
 */
 protected $description = 'Command description';

 /**
 * Execute the console command.
 *
 * @return int
 */
 public function handle() {
 return 0;
 }
}
</code></pre>La prima implementazione da eseguire &egrave; modificare la propriet&agrave; signature, impostando il nome del comando e gli eventuali parametri.<pre><code class="language-php">protected $signature = 'greet' . '{name : Il nome dell\'utente da salutare}';</code></pre>Se avessi voluto rendere il parametro opzionale, mi sarebbe bastato aggiungere un punto interrogativo, in questo modo<pre><code class="language-php">protected $signature = 'greet' . '{name? : Il nome dell\'utente da salutare}';</code></pre>Adesso implementiamo il metodo handle(), recuperando l&rsquo;input immesso dall&rsquo;utente e restituiamo l&rsquo;output sulla console<pre><code class="language-php">public function handle()
{
 $this-&gt;info('Ciao ' . $this-&gt;argument('name'));
 return 0;
}</code></pre>Ora non ci resta che lanciare dalla CLI il comando e osservare il risultato<pre><code>php artisan greet Luca</code></pre>

Artisan &egrave; un&#39;interfaccia a riga di comando inclusa in Laravel che fornisce una serie di c

Artisan: La CLI di Laravel

I Service Provider sono il perno del boot in tutte le applicazioni Laravel, di conseguenza rappresentano l&rsquo;entry point per estendere il framework con funzionalit&agrave; personalizzate.Tutti i Service Provider sono registrati nel file <code>config/app.php</code> all&#39;interno dell&#39;array providers.Quando un fornitore di servizi viene registrato, Laravel richiama automaticamente il metodo <code>register()</code> della classe. Inoltre, i Service Provider possono sfruttare il metodo boot() che viene invocato durante il processo di bootstrap.Una volta avviato, il fornitore di servizi rimane attivo per tutta la durata della richiesta.Laravel offre la possibilit&agrave; di utilizzare diversi Service Provider che sono responsabili di una parte specifica dell&rsquo;applicazione. Ad esempio, la classe AuthServiceProvider si occupa dell&rsquo;autenticazione degli utenti, la classe EventServiceProvider definisce eventi e relativi listeners e RouteServiceProvider che definisce i percorsi HTTP.Oltre a questi Service Provider principali, ovviamente ne possiamo creare degli altri.<h2>Creare un Service Provider personalizzato</h2>Se vogliamo registrare il nostro Service Provider personalizzato, possiamo farlo facilmente seguendo alcune semplici convenzioni.Quando si crea un nuovo provider tramite la CLI Artisan, esso sar&agrave; collocato nella directory <code>app/Providers</code>:<pre><code class="language-php">php artisan make:provider MyServiceProvider</code></pre>Se diamo un&#39;occhiata alla classe appena generata, noteremo che contiene un metodo register() e un metodo boot(). Il metodo register() deve essere utilizzato per legare le funzionalit&agrave; al provider dopo che questo &egrave; stato avviato. Quindi, se abbiamo una funzionalit&agrave; che non dipende da altri Provider, la dobbiamo dichiarare all&rsquo;interno di questo metodo.Il metodo boot(), invece, viene eseguito subito dopo che tutti i Service Provider sono stati registrati, quindi, in questo metodo abbiamo accesso a tutto ci&ograve; che &egrave; stato elaborato durante la fase di avvio dell&#39;applicazione.All&rsquo;interno di ogni Service Provider abbiamo accesso alla propriet&agrave; $app che a sua volta ci fornisce l&rsquo;accesso al Service Container principale del framework. Attraverso questa propriet&agrave;, nel metodo register(), possiamo legare le nostre classi personalizzate al framework con una sintassi del genere.<pre><code class="language-php">public function register()
{
 $this-&gt;app-&gt;bind('limitless', function () {
 return new Limitless();
 });
}</code></pre>Ora non preoccupiamoci se qualche concetto non risulta chiarissimo, perch&egrave; mano a mano che andremo avanti con questa guida, tutti i dubbi verranno risolti. Per adesso ricordiamoci questi concetti:<ul>	<li>Un Service Providers inietta funzionalit&agrave; nel framework</li>	<li>Il metodo register() va usato quando la funzionalit&agrave; non &egrave; legata ad altri providers</li>	<li>Il Service Provider contiene la propriet&agrave; $app che &egrave; l&rsquo;istanza stessa del framework</li></ul>A questi tre concetti aggiungo solo una piccola anticipazione: Nel metodo register() abbiamo usato la sintassi tipica per bindare una Facade, altro tema importante di Laravel. Nel prossimo capitolo vedremo di che cosa si tratta.

I Service Provider sono il perno del boot in tutte le applicazioni Laravel, di conseguenza rappresen

I Service Provider di Laravel

Nel capitolo precedente, parlando dei Service Provider, abbiamo introdotto l&rsquo;argomento delle Facades. Nella programmazione orientata agli oggetti, il Facade Pattern consiste nella creazione di un oggetto che serve da interfaccia frontale ad un codice pi&ugrave; complesso.Questa definizione pu&ograve; anche soddisfare chi si ferma ai concetti base, ma per noi che vogliamo approfondire non &egrave; sufficiente. Per cui andiamo a vedere come funzionano le Facades in Laravel.Il framework fa un uso massiccio di questi oggetti: la maggior parte delle classi che utilizziamo sono Facades, con una sintassi del genere:<pre><code>Facade::doSomething();
Facade::doSomething()-&gt;doSomethingElse();</code></pre>Dal codice appena esaminato, notiamo che i metodi vengono eseguiti staticamente. E in effetti, nella documentazione di Laravel leggiamo che le Facades servono come &ldquo;proxy statici a classi sottostanti, offrendo il vantaggio di una sintassi tersa ed espressiva, pur mantenendo una maggiore testabilit&agrave; e flessibilit&agrave; rispetto ai metodi statici tradizionali&rdquo;.Per capire meglio questi concetti, andiamo a creare una Facade Personalizzata. Artisan non supporta la creazione di questi componenti, per cui dobbiamo procedere manualmente. Creiamo una cartella all&rsquo;interno di app, dove andremo ad organizzare tutte le nostre estensioni. La chiameremo Extensions. E all&rsquo;interno di questa nuova cartella ne creiamo altre due, rispettivamente Facades e Classes.Adesso creiamo una nuova classe all&rsquo;interno della cartella Facades appena creata, che estender&agrave; la Facade base di Laravel.<pre><code>namespace App\Extensions\Facades;
use Illuminate\Support\Facades\Facade;
class TestFacade extends Facade
{
 protected static function getFacadeAccessor()
 {
 return 'testKey';
 }
}</code></pre>Ogni Facade deve implementare un solo metodo, getFacadeAccessor() che restituisce una stringa. Capiremo nel corso di questa lezione a che cosa ci serve.Adesso dobbiamo creare una classe che &egrave; parte integrante di quella business logic che il design pattern Facade nasconde. La classe la posizioniamo all&rsquo;interno della nuova cartella app/Extensions/Classes e potr&agrave; avere un qualsiasi nome.<pre><code>namespace App\Extensions\Classes;
class Test
{
 public function hello()
 {
 return 'Ciao, io sono la classe reale della Facade';
 }
}</code></pre>Il prossimo step &egrave; registrare nel Service Provider il binding tra la Facade e la classe reale. Quindi apriamo la classe AppServiceProvider, contenuta nella cartella app/Http/Providers e definiamo il binding in questo modo.<pre><code>namespace App\Providers;
use App\Extensions\Classes\Test;
use Illuminate\Support\ServiceProvider;
class AppServiceProvider extends ServiceProvider
{
 /**
 * Register any application services.
 *
 * @return void
 */
 public function register()
 {
 $this-&gt;app-&gt;bind('testKey', fn() =&gt; new Test());
 }
 /**
 * Bootstrap any application services.
 *
 * @return void
 */
 public function boot()
 {
 //
 }
}</code></pre>Definiamo l&rsquo;alias nel file config/app.php, all&rsquo;interno del blocco &lsquo;aliases&rsquo; e sucessivamente lanciamo il comando php artisan optimize<pre><code>'aliases' =&gt; Facade::defaultAliases()-&gt;merge([
'TestFacade' =&gt; App\Extensions\Facades\TestFacade::class
])-&gt;toArray(),</code></pre>Da questo momento possiamo usare la Facade per accedere ai metodi della classe reale<pre><code>TestFacade::hello();</code></pre>Ma com&#39;&egrave; possibile tutto ci&ograve;? &Egrave; possibile grazie a PHP) Vediamo nel dettaglio cosa succede dietro le quinte. Ci ricordiamo che i Service Providers vengono caricati all&rsquo;avvio del framework, quindi dopo il boot la propriet&agrave; app &egrave; disponibile all&rsquo;uso e contiene la coppia Facade =&gt; Classe Reale.La propriet&agrave; $app &egrave; accessibile anche dalla classe Illuminate\Support\Facades\Facade che abbiamo esteso con la nostra TestFacade.Quest&rsquo;ultima eredita l&rsquo;implementazione del metodo magico , per gestire la chiamata di metodi statici che in realt&agrave; non sono stati definiti nella classe. Tale gestione prevede il recupero del valore del metodo getFacadeAccessor() che abbiamo implementato, quindi la stringa &lsquo;testKey&rsquo;.La stessa stringa l&rsquo;abbiamo definita anche nel binding del ServiceProvider. La Facade fa un match tra questa stringa e gli elementi della propriet&agrave; $app. Quando risolve il match, utilizzer&agrave; l&rsquo;istanza della classe reale.

Nel capitolo precedente, parlando dei Service Provider, abbiamo introdotto l&rsquo;argomento delle F

Gestione delle Facades in Laravel

I Service Container sono un componente fondamentale del framework Laravel. Il loro scopo &egrave; fornire un sistema pratico per iniettare le dipendenze nelle funzionalit&agrave;.Nell&#39;ingegneria del software, la dependency injection &egrave; una tecnica in cui un metodo o una funzione riceve le sue dipendenze (cio&egrave; gli oggetti di cui ha bisogno per funzionare) come parametri. Questa tecnica ci permette di eliminare le dipendenze codificate, evitando di istanziare oggetti all&rsquo;interno della classe, rendendo il nostro codice pi&ugrave; flessibile.Per fare un esempio, si consideri questo snippet senza dependency injection<pre><code>class Address
{
 public function getAddress()
 {
 return 'This is my address';
 }
}
class GeoCoding
{
 public function getAddressCoordinates()
 {
 $dependency = new Address();
 return $dependency-&gt;getAddress();
 }
}</code></pre>Lo stesso risultato si pu&ograve; ottenere in maniera pi&ugrave; elegante ricorrendo alla dependency injection<pre><code>class Address
{
 public function getAddress()
 {
 return 'This is my address';
 }
}
class GeoCoding
{
 public function getAddressCoordinates(Address $address)
 {
 return $address-&gt;getAddress();
 }
}</code></pre>Il vantaggio di usare il secondo costrutto &egrave; chiaro: abbiamo la possibilit&agrave; di cambiare il comportamento di una dipendenza, senza dover mettere le mani su tutte le classi che la incapsulano.Questo esempio &egrave; molto semplice, la dipendenza che dobbiamo iniettare nella nostra classe non ha una configurazione iniziale. In un caso pi&ugrave; complesso, in cui dobbiamo implementare il costruttore della dipendenza, dobbiamo necessariamente usare un IoC Container. Per definizione, il contenitore IoC &egrave; un componente software che fornisce servizi ad altri componenti senza che questi ultimi debbano essere a conoscenza del modo in cui tali servizi vengono forniti.Non preoccupiamo pi&ugrave; di tanto di questa definizione, anche perch&egrave; nel core di Laravel questo Container gi&agrave; esiste e funziona benissimo. Noi dobbiamo solo utilizzarlo.Supponiamo che la classe Address abbia bisogno di un parametro nel costruttore per funzionare correttamente, ad esempio di un&rsquo;API key. Quindi la classe si presenter&agrave; in questa maniera.<pre><code>class Address
{
 protected $apiKey;
 public function __construct($apiKey)
 {
 $this-&gt;apiKey = $apiKey;
 }
 public function getAddress()
 {
 return 'This is my address';
 }
}</code></pre>Per istanziare questa classe e poterla iniettare senza problemi nella classe GeoCoding, possiamo usare il Container di Laravel, disponibile nel metodo register del Service Provider che abbiamo analizzato nella sezione precedente.<pre><code>class AppServiceProvider extends ServiceProvider
{
 /**
 * Register any application services.
 * @return void
 */
 public function register()
 {
 $this-&gt;app-&gt;bind(Address::class, concrete: function() {
 $apiKey = '123456789';
 return new Address($apiKey);
 });
 }
}</code></pre>Esiste un ulteriore vantaggio usando questo sistema: al container possiamo passare anche un&rsquo;interfaccia o una classe astratta, in quanto ci penser&agrave; lui a risolvere l&#39;implementazione concreta. In questo modo possiamo &ldquo;allentare&rdquo; l&#39;accoppiamento tra i vari componenti e rendere il codice pi&ugrave; modulare ed estensibile.Facciamo un esempio pratico di quanto appena esposto, creando un servizio per gestire i social network. Nella cartella Extensions creiamo due sottocartelle: &ldquo;Contracts&rdquo; e &ldquo;Services&rdquo;. Laravel usa il termine Contract per indicare le interfacce, quindi atteniamoci a questo standard.Creiamo il contratto nella cartella Contracts, definendo un paio di metodi<pre><code>namespace App\Extensions\Contracts;
interface SocialContract
{
 public function share();
 public function like();
}</code></pre>E successivamente definiamo la classe Social nella cartella Services<pre><code>namespace App\Extensions\Services;
use App\Extensions\Contracts\SocialContract;
class Social implements SocialContract
{
 protected $url;
 public function __construct($url)
 {
 $this-&gt;url = $url;
 }
 public function share()
 {
 return 'You shared this content ' . $this-&gt;url;
 }
 public function like()
 {
 return 'You liked this content ' . $this-&gt;url;
 }
}</code></pre>Nel Service Provider utilizziamo l&rsquo;IoC Container per legare i due componenti<pre><code>namespace App\Providers;
use Illuminate\Support\ServiceProvider;
use App\Extensions\Services\Social;
use App\Extensions\Contracts\SocialContract;
class AppServiceProvider extends ServiceProvider
{
 /**
 * Register any application services.
 * @return void
 */
 public function register()
 {
 $this-&gt;app-&gt;bind(SocialContract::class, concrete: function() {
 $url = 'https://www.mrw.it';
 return new Social($url);
 });
 }
}</code></pre>Adesso dobbiamo semplicemente iniettare il Contratto come parametro nella classe deputata al suo utilizzo. Visto che abbiamo definito una Facade nel capitolo precedente, useremo la relativa classe reale che si nasconde dietro la facciata. Implementiamo il costruttore in modo che riceva il nostro Servizio e modifichiamo il metodo hello() per avere un ritorno a video.<pre><code>namespace App\Extensions\Classes;
use App\Extensions\Contracts\SocialContract;
class Test
{
 private SocialContract $social;
 public function __construct(SocialContract $social)
 {
 $this-&gt;social = $social;
 }
 public function hello()
 {
 dd($this-&gt;social);
 }
}</code></pre>Torniamo al ServiceProvider e facciamo la magia. Modifichiamo il binding tra Facade e Classe Concreta implementato nello scorso capitolo, passando al costruttore il Service Container creato poco fa, che possiamo recuperare attraverso il metodo get() della classe Illuminate\Foundation\Application, l&rsquo;istanza del framework.<pre><code>public function register()
{
 $this-&gt;app-&gt;bind(SocialContract::class, concrete: function() {
 $url = 'https://www.mrw.it';
 return new Social($url);
 });
 $this-&gt;app-&gt;bind('testKey', fn($app) =&gt; new Test($app-&gt;get(SocialContract::class)));
}</code></pre>Il risultato sar&agrave; quello atteso, il tutto grazie all&rsquo;IoC Container di Laravel.

I Service Container sono un componente fondamentale del framework Laravel. Il loro scopo &egrave; fo

Service Container

Le migrazioni di Laravel consentono di versionare lo schema del database dell&rsquo;applicazione e di legarlo in modo indissolubile al resto del software. Detto in maniera pi&ugrave; semplice, le migrations sono delle classi di Laravel che, attraverso la Facade Schema, ci permettono di creare e modificare lo schema del database, in qualsiasi ambiente andremo ad installare l&rsquo;applicazione.In questo capitolo impareremo ad usarle. Cominciamo a localizzarle, aprendo la cartella database/migrationsCome possiamo vedere, in questa cartella ci sono alcuni files con estensione PHP. I files hanno un prefisso che indica la data in cui sono stati creati, seguito da un nome che ci dice l&rsquo;azione della migration. Le 4 migrations che vediamo sono incluse di default in ogni progetto.Ogni migration ha due metodi: up() e down(). Il primo viene eseguito per aggiungere una modifica allo schema, il secondo invece ha il compito di riportare lo schema alla situazione precedente.In pratica, i metodi up() delle migrations vengono invocati quando si lancia questo comando<pre><code>php artisan migrate</code></pre>Al contrario, i metodi down() delle migrations vengono invocati quando si lancia questo comando<pre><code>php artisan migrate:rollback</code></pre>Detto questo, prima di buttarci a capofitto nella scrittura delle migrations facciamo quello che dovrebbe fare ogni buon programmatore: progettare il database.<img alt="Database Laravel" height="666" src="https://backoffice.programmato.it/storage/photos/1/6558b98dcad69.jpg" width="1170" />Il nostro obiettivo &egrave; versionare questo database composto da cinque entit&agrave;: Produttore, Modello, Macchina, Utente e Patente. La tabella car_user ci servir&agrave; per definire la relazione molti a molti tra macchine e utenti, considerando che un utente pu&ograve; possedere pi&ugrave; macchine e la stessa macchina pu&ograve; essere cointestata a pi&ugrave; persone. Inoltre dobbiamo conservare uno storico per risalire ad ogni passaggio di propriet&agrave;Cominciamo modificando la migrations degli utenti, eliminando il campo name e aggiungendo i campi stringa first_name e last_name. Il metodo up di questa migration si dovr&agrave; presentare cos&igrave;<pre><code>public function up()
{
 Schema::create('users', function (Blueprint $table) {
 $table-&gt;id();
 $table-&gt;string('first_name');
 $table-&gt;string('last_name');
 $table-&gt;string('email')-&gt;unique();
 $table-&gt;timestamp('email_verified_at')-&gt;nullable();
 $table-&gt;string('password');
 $table-&gt;rememberToken();
 $table-&gt;timestamps();
 });
}</code></pre>Come vedete, stiamo usando il metodo create() della Facade Schema. Il primo parametro &egrave; il nome della tabella, mentre il secondo &egrave; una closure che gestisce la creazione dei campi. L&rsquo;istruzione $table-&gt;timestamps() andr&agrave; a creare due campi di tipo data, created_at e updated_at, che Laravel utilizza per tenere traccia della creazione e dell&rsquo;aggiornamento di ogni singolo record.Adesso creiamo la migration dei produttori, come sempre utilizzando artisan<pre><code>php artisan make:migration create_producers_table</code></pre>Apriamo il file appena creato e implementiamo il metodo up() per aggiungere i campi necessari alla tabella.<pre><code>public function up()
{
 Schema::create('producers', callback: function (Blueprint $table) {
 $table-&gt;id();
 $table-&gt;string('name', 255);
 $table-&gt;timestamps();
 });
}</code></pre>Ripetiamo la stessa operazione per creare la migration della tabella car_models, ma in questo caso nel metodo up dobbiamo impostare anche la relazione con la tabella producers<pre><code>php artisan make:migration create_car_models_table</code></pre><pre><code>public function up()
{
 Schema::create('car_models', callback: function (Blueprint $table) {
 $table-&gt;id();
 $table-&gt;unsignedBigInteger('producer_id');
 $table-&gt;foreign('producer_id')-&gt;references('id')-&gt;on('producers');
 $table-&gt;string('name', 255);
 $table-&gt;decimal('price', 9, 3);
 $table-&gt;timestamps();
 });
}</code></pre>Adesso creiamo la migration della tabella driving_licenses, dove impostiamo la relazione con la tabella users<pre><code>php artisan make:migration create_driving_licenses_table</code></pre><pre><code>public function up()
{
 Schema::create('driving_licenses', function (Blueprint $table) {
 $table-&gt;id();
 $table-&gt;unsignedBigInteger('user_id');
 $table-&gt;foreign('user_id')-&gt;references('id')-&gt;on('users')-&gt;onDelete('cascade');
 $table-&gt;string('number', 255);
 $table-&gt;timestamp('valided_until_at');
 $table-&gt;timestamps();
 });
}</code></pre>Ora occupiamoci della migration per la tabella cars, dove ci sar&agrave; una relazione con la tabella car_models. E qui dobbiamo fare un appunto: le migrations devono girare in ordine sequenziale, a partire dal timestamp impostato come prefisso del file. Quindi dobbiamo fare attenzione quando impostiamo le relazioni, perch&eacute; quando Laravel deve creare un vincolo relazionale, se non trova la tabella da relazionare, va in errore.Detto questo, possiamo generare la migration<pre><code>php artisan make:migration create_cars_table</code></pre>Apriamo il nuovo file e inseriamo i campi come segue<pre><code>public function up()
{
 Schema::create('cars', callback: function (Blueprint $table) {
 $table-&gt;id();
 $table-&gt;string('license_plate', 15);
 $table-&gt;unsignedBigInteger('car_model_id');
 $table-&gt;foreign('car_model_id')-&gt;references('id')-&gt;on('car_models')-&gt;onDelete('cascade');
 $table-&gt;timestamp('registered_at')-&gt;nullable();
 $table-&gt;timestamps();
 });
}</code></pre>L&rsquo;ultimo step &egrave; la creazione della pivot che ci serve per gestire la relazione molti a molti tra utenti e macchine. Qui utilizzeremo un ulteriore timestamp, per indicare la fine della decorrenza.La pivot deve chiamarsi come la combinazione dei nomi delle due tabelle che la compongono (in questo caso al singolare), separate da un underscore.php artisan make:migration create_car_user_tableE di seguito il relativo metodo up<pre><code>public function up()
{
 Schema::create('car_user', function (Blueprint $table) {
 $table-&gt;unsignedBigInteger('car_id');
 $table-&gt;foreign('car_id')-&gt;references('id')-&gt;on('cars')-&gt;onDelete('cascade');
 $table-&gt;unsignedBigInteger('user_id');
 $table-&gt;foreign('user_id')-&gt;references('id')-&gt;on('users');
 $table-&gt;timestamp('ended_at')-&gt;nullable();
 $table-&gt;timestamps();
 });
}</code></pre>Ora da terminale lanciamo il comando per lanciare le migration<pre><code>php artisan migrate</code></pre>Perfetto, il nostro database &egrave; stato creato. Ma prima di passare oltre, vediamo cosa succede se creiamo una nuova migration e successivamente lanciamo il comando per migrare lo schema.<pre><code>php artisan make:migration create_tests_table</code></pre><pre><code>php artisan migrate</code></pre>Come possiamo vedere, Laravel ha lanciato solo l&rsquo;ultima migration, in quanto le altre erano gi&agrave; state lanciate. Questo &egrave; possibile perch&eacute; all&rsquo;interno del nostro database c&rsquo;&egrave; una tabella chiamata migrations, dove il framework memorizza i batch delle migrazioni.<img alt="migrazioni progressive" height="520" src="https://backoffice.programmato.it/storage/photos/1/guida-laravel/6558b9df99ee3.png" width="960" />Appreso questo concetto, dobbiamo ripristinare il versionamento alla situazione precedente. Ci baster&agrave; invocare il comando rollback delle migrations e saranno cancellate solo le tabelle relative all&rsquo;ultimo batch.<pre><code>php artisan migrate:rollback</code></pre>Cancelliamo il file {prefix}_create_tests_table.php e passiamo alla lezione successiva.

Le migrazioni di Laravel consentono di versionare lo schema del database dell&rsquo;applicazione e d

Usare le Migrations di Laravel per versionare lo schema del database

I seeders sono classi che vengono utilizzate per popolare il database con dei dati. &Egrave; un argomento essenziale quando si fa un refactoring o si ha bisogno di qualche dato per fare degli Unit Tests.In questa lezione vedremo come creare dei dati fittizi, utilizzando la classe Faker di Laravel ma il seeder pu&ograve; essere utilizzato anche per importare i dati da un database gi&agrave; esistente o da un file excel.Per creare un seeder, utilizziamo il seguente comando<pre><code>php artisan make:seeder GenerateSomeFakeDatas</code></pre>Il comando creer&agrave; un file nella directory database/seeders. In questo file, andremo a gestire il popolamento a cascata delle seguenti tabelle: users, producers e car_models.Utilizzeremo due tecniche:<ul>	<li>per la tabella users disponiamo gi&agrave; del relativo modello e quindi useremo le factory</li>	<li>per le altre due tabelle useremo un altro strumento, il Query Builder.</li></ul>Le factory sono uno degli strumenti pi&ugrave; utilizzati per generare dati fittizi nelle applicazioni Laravel. Queste classi si agganciano direttamente al relativo modello e indubbiamente fanno risparmiare moltissimo tempo. Per generare la factory basta lanciare il seguente comando, ovviamente impostando un modello gi&agrave; esistente<pre><code>php artisan make:factory MyModel</code></pre>Non abbiamo bisogno di creare la factory per gli utenti, dal momento che &egrave; gi&agrave; presente di default nella cartella database/factories.Dobbiamo per&ograve; modificare il metodo definition() visto che nella tabella abbiamo cambiato alcuni campi<pre><code>public function definition()
{
 return [
 'first_name' =&gt; fake()-&gt;firstName(),
 'last_name' =&gt; fake()-&gt;lastName(),
 'email' =&gt; fake()-&gt;unique()-&gt;safeEmail(),
 'email_verified_at' =&gt; now(),
 'password' =&gt; bcrypt('123456789'),
 'remember_token' =&gt; Str::random(10)
 ];
}</code></pre>Ora apriamo il seeder GenerateSomeFakeDatas e includiamo le dipendenze che ci servono<pre><code>namespace Database\Seeders;
use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use App\Models\User;</code></pre>Fatto questo, definiamo la dichiarazione per usare la factory degli utenti nel metodo run() del seeder<pre><code>public function run()
{
 User::factory()-&gt;count(20)-&gt;create();
}</code></pre>Da terminale facciamo girare il seeder con questo comando<pre><code>php artisan db:seed --class=GenerateSomeFakeDatas</code></pre>E andiamo a controllare la tabella users nel databaseNel caso volessimo omettere il parametro relativo alla classe da lanciare, dobbiamo agire sul seeder di default, DatabaseSeeder. Apriamolo e richiamiamo all&rsquo;interno del metodo run() il nostro seeder GenerateSomeFakeDatas.<pre><code>public function run()
{
 $this-&gt;call(GenerateSomeFakeDatas::class);
}</code></pre>Cos&igrave; facendo, ogni volta che lanciamo il comando php artisan db:seed, saranno lanciati tutti i seeders inclusi nella classe di default.Completiamo il nostro seeder, aggiungendo un p&ograve; di dati per le tabelle producers e car_models. Come detto, useremo il Query Builder, visto che non abbiamo ancora affrontato il discorso dei modelli di Laravel.<pre><code>public function run()
{
 User::factory()-&gt;count(20)-&gt;create();
 for ($producer_counter = 1; $producer_counter &lt;= 10; $producer_counter++) {
 $producer_id = DB::table('producers')-&gt;insertGetId([
 'name' =&gt; fake()-&gt;company,
 'created_at' =&gt; now(),
 'updated_at' =&gt; now()
 ]);
 $rand_number = random_int(2, 5);
 for ($models_counter = 1; $models_counter &lt;= $rand_number; $models_counter++) {
 DB::table('car_models')-&gt;insert([
 'name' =&gt; fake()-&gt;firstNameFemale(),
 'price' =&gt; fake()-&gt;numberBetween(12000, 24540),
 'producer_id' =&gt; $producer_id,
 'created_at' =&gt; now(),
 'updated_at' =&gt; now()
 ]);
 }
 }
}</code></pre>In questo codice ho impostato un ciclo di 10 iterazioni e attraverso il Query Builder ho popolato la tabella producers con un nome fittizio. Ho dovuto impostare i campi created_at e updated_at in quanto sono prerogative di Eloquent. Il metodo insertGetId() del Query Builder mi restituisce il PDO::lastInsertId che ho poi utilizzato nel ciclo successivo per legare i modelli delle automobili al relativo produttore.Nella lezione successiva cominceremo a lavorare con Eloquent e tutto ci&ograve; diventer&agrave; un vago ricordo. Per adesso limitiamoci a lanciare il comando php artisan db:seed e al suo termine controlliamo che le tabelle delle database siano effettivamente popolate.

I seeders sono classi che vengono utilizzate per popolare il database con dei dati. &Egrave; un argo

I Seeders, un utile strumento per popolare il database

Utilizzare l'ORM Eloquent nelle applicazioni Laravel

Eloquent &egrave; l&#39;ORM (object-relational mapper) integrato di Laravel. Offre un modo semplice per lavorare con il database, senza dover scrivere query SQL, fornendo all&rsquo;utente un&#39;implementazione ActiveRecord per lavorare con i suoi dati, il che significa che ogni tabella del database ha un &quot;modello&quot; corrispondente.I modelli sono archiviati nella directory app/Models e di default seguono la seguente convenzione: il nome della tabella deve essere al plurale e il relativo modello al singolare. &Egrave; possibile bypassare questo vincolo, specificando nella propriet&agrave; $table del modello, il nome della relativa tabella.Per creare un modello, come al solito possiamo utilizzare Artisan. Creiamo i modelli che ci servono per gestire il database che abbiamo strutturato nelle lezioni precedenti.<pre><code class="language-php">php artisan make:model Producer
php artisan make:model CarModel
php artisan make:model Car
php artisan make:model DrivingLicense</code></pre>Questi quattro comandi creeranno altrettante classi nella directory app/Models.Di default, i modelli di Laravel non possono valorizzare i records con l&#39;assegnazione massiva, ossia non &egrave; possibile inviare un array al modello per creare direttamente un nuovo record nel DB. Questo limite &egrave; facilmente aggirabile valorizzando la propriet&agrave; fillable del modello. Apriamo quindi il modello Producer e impostiamo la suddetta propriet&agrave;.<pre><code class="language-php">namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Producer extends Model
{
 use HasFactory;
 protected $fillable = [
 'name'
 ];
}</code></pre>Facciamo la stessa operazione per il modello CarModel, ovviamente valorizzando la propriet&agrave; con i campi della relativa tabella<pre><code class="language-php">namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class CarModel extends Model
{
 use HasFactory;
 protected $fillable = [
 'producer_id',
 'name',
 'price'
 ];
}</code></pre>E questo &egrave; lo snippet per il modello Car<pre><code class="language-php">namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Car extends Model
{
 use HasFactory;
 protected $fillable = [
 'car_model_id',
 'license_plate',
 'registered_at'
 ];
}</code></pre>Per il modello DrivingLicense invece procederemo in un&rsquo;altra maniera. Abbiamo a disposizione un&rsquo;altra propriet&agrave;, $guarded, che possiamo valorizzare con un&rsquo;array vuota. Infatti, mentre la propriet&agrave; fillable fornisce al software una whitelist con i campi che si possono valorizzare, la propriet&agrave; guarded viene usata per riempire una blacklist. Quindi, valorizzandola con una matrice senza elementi, stiamo dicendo a Laravel che tutti i campi della tabella possono essere valorizzati.<pre><code class="language-php">namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class DrivingLicense extends Model
{
 use HasFactory;
 protected $guarded = [];
}</code></pre>Adesso dobbiamo creare il Modello per la tabella car_user, ma questa tabella &egrave; una pivot quindi ha bisogno di una gestione diversa. Per accedere correttamente ai suoi dati dobbiamo creare una classe che non estende Illuminate\Database\Eloquent\Model ma bens&igrave; Illuminate\Database\Eloquent\Relations\Pivot.Possiamo tranquillamente usare Artisan per generare questa classe, baster&agrave; aggiungere il parametro &ndash;p (pivot)<pre><code class="language-bash">php artisan make:model CarUser –p</code></pre>Ora vediamo Eloquent all&rsquo;opera. Dal momento che disponiamo gi&agrave; di qualche dato nel database, proviamo ad utilizzare i modelli per estrarre e visualizzare i records, avvalendosi di Tinker.Digitiamo questo comando nella console del progetto<pre><code>php artisan tinker</code></pre>Una volta avviato il REPL, utilizziamo questa sintassi per estrarre tutti i records del modello Producer.<pre><code>\App\Models\Producer::all();</code></pre>Quello che vediamo nell&rsquo;immagine &egrave; una Collezione di Eloquent che contiene 10 elementi, 10 istanze del modello Producer. Io ho tagliato l&rsquo;immagine per ragioni editoriali, ma vi assicuro che l&rsquo;output &egrave; corretto, in quanto nel database abbiamo 10 records.Se avessi voluto filtrare il dato, avrei dovuto usare uno dei tanti helper di Eloquent per invocare le clausole del DBMS. Vediamo alcuni esempi:<pre><code class="language-php">// Restituisce i records con id 1,2 e 3
Producer::whereIn('id', [1,2,3])-&gt;get();
// Restituisce i records con id 8, 9 e 10
Producer::where('id', '&gt;', 7)-&gt;get();
// Restituisce i records con id 8 e 9
Producer::where('id', '&gt;', 7)-&gt;where('id', '!=', 10)-&gt;get();
// Restituisce i records con id 1, 9 e 10
Producer::where('id', '&gt;', 8)-&gt;orWhere('id', '&lt;', 2)-&gt;get();</code></pre>Per recuperare un singolo record, avendo a disposizione il relativo id, possiamo utilizzare il metodo find()<pre><code>Producer::find(1);</code></pre>La dichiarazione che abbiamo usato &egrave; l&rsquo;equivalente di questa sintassi<pre><code>Producer::where('id', '=', $id)-&gt;first();</code></pre>Abbiamo a disposizione anche il metodo findOrFail() il quale restituisce un errore 404, se non trova nella tabella l&rsquo;id passato come parametro. Ovviamente solo se lo script &egrave; eseguito dal web server, mentre su Tinker vedremo solo l&rsquo;eccezione e non la relativa gestione.<pre><code>Producer::findOrFail(1233);</code></pre>Bene, in questo capitolo abbiamo visto i concetti base di Eloquent. Nella prossima lezione vedremo come utilizzare i modelli per inserire nuovi records nel database e come modificarli. In seguito passeremo alle caratteristiche pi&ugrave; avanzate di Eloquent, come le relazioni. Nel frattempo, se avete domande su questo articolo o su Laravel in generale, lasciate pure un commento qui sotto e vi risponder&ograve; al pi&ugrave; presto.

Eloquent &egrave; l&#39;ORM (object-relational mapper) integrato di Laravel. Offre un modo semplice 

Introduzione ai Modelli di Eloquent

In questa lezione vedremo come usare i Modelli di Eloquent per le operazioni di creazione e aggiornamento nel database.<h2>Creazione nuovo record</h2>Per la creazione di un nuovo record abbiamo due opzioni:Istanziare il modello e poi salvare il dato nel databaseSalvare il dato direttamente nel databaseEntrambe le soluzioni sono valide, sar&agrave; compito nostro, in un contesto operativo, valutare l&rsquo;opzione migliore.<h2>Metodo 1</h2><pre><code>$name = 'Nuovo produttore';
$producer = new Producer(['name' =&gt; $name]);
$producer-&gt;save();</code></pre><h2>Metodo 2</h2><pre><code>$name = 'Nuovo produttore';
$producer = Producer::create(['name' =&gt; $name]);</code></pre><h2>Modifica record</h2>Anche per l&rsquo;aggiornamento di un record abbiamo due possibili soluzioni tra cui scegliereIstanziare il modello con l&rsquo;id corretto, aggiornare le propriet&agrave; e salvare il record aggiornatoUsare il metodo update() per aggiornare direttamente il record<h2>Metodo 1</h2><pre><code>$id = 1;
$producer = Producer::findOrFail($id);
$producer-&gt;name = 'Nuovo nome del produttore'
$producer-&gt;save();</code></pre><h2>Metodo 2</h2><pre><code>$id = 1;
Producer::findOrFail($id)-&gt;update(['name' =&gt; 'Nuovo nome del produttore']);</code></pre>Qui forse mi sento di dare un consiglio pi&ugrave; pratico: se le propriet&agrave; che dobbiamo aggiornare sono molte, conviene usare il secondo approccio. Ma solo per una questione di tempo.<h2>Cancellazione record</h2>Indovinate un p&ograve;&hellip;anche qui abbiamo a disposizione due metodiIl metodo destroy() che funziona solo per il Query Builder di EloquentIl metodo delete() che funziona solo per l&rsquo;istanza del modello<h2>Metodo 1</h2><pre><code>Producer::where('id', '&gt;', 10)-&gt;destroy();</code></pre><h2>Metodo 2</h2><pre><code>$producers = Producer::where('id', '&gt;', 10)-&gt;get();
foreach($producers as $producer) {
 $producer-&gt;delete();
}</code></pre>

In questa lezione vedremo come usare i Modelli di Eloquent per le operazioni di creazione e aggiorna

Creare, aggiornare e cancellare records nel database attraverso i Modelli di Eloquent

Adesso che siamo in grado di utilizzare i metodi base dei modelli di Eloquent, facciamo un piccolo esercizio: generiamo la factory del modello Car e creiamo un seeder per popolare la relativa tabella. Abbiamo gi&agrave; visto in precedenza le Factory, quando abbiamo utilizzato quella del modello User per inserire qualche utente nel database.Creiamo la factory<pre><code>php artisan make:factory Car</code></pre>Apriamo la nuova factory e impostiamo il metodo definition() in questo modo<pre><code>use Carbon\Carbon;
public function definition()
{
 return [
 'license_plate' =&gt; fake()-&gt;unique()-&gt;bothify('#######'),
 'registered_at' =&gt; Carbon::today()-&gt;subDays(rand(0, 365))
 ];
}</code></pre>Ora creiamo il seeder<pre><code>php artisan make:seeder GenerateSomeFakeCars</code></pre>Apriamo il seeder e definiamo un semplice costrutto, dove estraiamo tutti i records della tabella car_models, li cicliamo e per ogni iterazione creiamo un numero di records variabile per la tabella cars, sfruttando la factory che abbiamo appena creato<pre><code>namespace Database\Seeders;
use Illuminate\Database\Seeder;
use App\Models\Car;
use App\Models\CarModel;
class GenerateSomeFakeCars extends Seeder
{
 /**
 * Run the database seeds.
 * @return void
 * @throws \Exception
 */
 public function run()
 {
 $car_models = CarModel::all();
 foreach ($car_models as $car_model) {
 Car::factory()-&gt;count(random_int(2, 5))-&gt;create(['car_model_id' =&gt; $car_model-&gt;id]);
 }
 }
}</code></pre>Ora non ci resta che far girare questa classe, come abbiamo imparato a fare nel capitolo dedicato ai seeders.Faremo ancora qualche altro esercizio con le Factory in quanto ci resta da popolare qualche tabella, Ma lo faremo sfruttando le relazioni di Eloquent, argomento del prossimo capitolo.

Adesso che siamo in grado di utilizzare i metodi base dei modelli di Eloquent, facciamo un piccolo e

Usare le factory dei Modelli

In PHP, non &egrave; necessario specificare il tipo di dato di una variabile quando la si dichiara. Il parser PHP lo imposta automaticamente per noi. Tuttavia, il tipo di dato pu&ograve; essere convertito in un altro. A cosa ci pu&ograve; servire questo?Ad esempio, pu&ograve; capitare che quando un modulo viene inviato al server, uno dei campi deve essere &ldquo;castato&rdquo; prima di poter essere utilizzato in modo significativo. O anche si pu&ograve; verificare la situazione in cui il dato deve essere recuperato dal database e prima di essere manipolato dal controller &egrave; necessario effettuare un&#39;operazione di casting.I modelli di Laravel dispongono di una propriet&agrave; denominata cast che accetta come parametri un&rsquo;array, le cui chiavi sono i nomi dei campi della tabella mentre il relativo valore &egrave; il tipo di dato in cui si vuole castare tale campo.<pre><code>class MyModel extends Model
{
 protected $casts = [
 'field_1' =&gt; 'array',
 'field_2' =&gt; 'boolean',
 'field_3' =&gt; 'string',
 'field_4' =&gt; 'collection'
 ];
}</code></pre>Come vediamo dalle esempio &egrave; possibile usare i classici tipi di dato ma anche delle funzionalit&agrave; tipiche di laravel.Non solo, possiamo creare delle classi per effettuare un vero e proprio custom cast. Vediamo come procedere facendo un&rsquo;implementazione alla nostra entit&agrave; Car. In primo luogo creiamo una migration per aggiungere un campo json alla tabella cars<pre><code>php artisan make:migration add_options_field_to_cars_table</code></pre>Di seguito i metodi up() e down() della migration<pre><code>public function up()
{
 Schema::table('cars', function (Blueprint $table) {
 $table-&gt;json('options')-&gt;nullable()-&gt;after('registered_at');
 });
}
public function down()
{
 Schema::table('cars', function (Blueprint $table) {
 $table-&gt;dropColumn('options');
 });
}</code></pre>Facciamo girare la migration e dopodich&eacute; creiamo il nostro Custom cast<pre><code>php artisan make:cast CustomCast</code></pre>La classe sar&agrave; creata all&#39;interno della cartella app/Casts.Apriamola e vediamo che al suo interno ci sono due metodi: get() e set(). &Egrave; abbastanza intuitivo che il primo sar&agrave; richiamato in fase di lettura mentre il secondo sar&agrave; richiamato quando il campo viene valorizzato.In questa classe impostiamo una propriet&agrave; privata<pre><code>protected $default = [
'serial_number' =&gt; null,
'color' =&gt; null,
'power_supply' =&gt; null,
];</code></pre>E gestiamo il getter e il setter in maniera molto banale<pre><code>public function get($model, string $key, $value, array $attributes)
{
 return is_null($value) ? $this-&gt;default : json_decode($value, true);
}
public function set($model, string $key, $value, array $attributes)
{
 return is_array($value) ? json_encode($value) : json_encode($this-&gt;default);
}</code></pre>Adesso apriamo il modello Car, importiamo la classe appena creata e utilizziamola per castare il campo options<pre><code>namespace App\Models;
use App\Casts\CustomCast;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Car extends Model
{
 use HasFactory;
 protected $casts = [
 'options' =&gt; CustomCast::class
 ];
 ...
}</code></pre>Di seguito un esempio su come testare il nostro casting<pre><code>$car = Car::find(1);
// Qui interviene il metodo Get della Classe CustomCast
$car-&gt;options;
// Qui interviene il metodo Set della Classe CustomCast
$car-&gt;options = ['color' =&gt; 'yellow'];</code></pre><h2>Casting delle date</h2>Abbiamo la possibilit&agrave; di fare un casting automatico per quanto riguarda i campi di tipo data. Di default Laravel le gestisce come stringhe per cui non &egrave; possibile fare le operazioni tipiche del datetime.Possiamo modificare facilmente questo comportamento, specificando all&#39;interno del modello la propriet&agrave; $dates e impostando come valore un array contenente tutti i campi che vogliamo gestire come data.Ad esempio nel modello Car, far&ograve; il casting del campo registered_at in questo modo<pre><code>protected $dates = [
'registered_at'
];</code></pre><h2>Accessors</h2>Gli accessors rappresentano un altro approccio per manipolare gli attributi dei modelli in fase di lettura. Nelle versioni passate di Laravel, Accessors e Mutators dovevano essere assegnati con metodi diversi. Adesso &egrave; stato introdotto un nuovo sistema che ci permette di definire il getter e il setter di un attributo, all&#39;interno di un unico metodo.Personalmente faccio un largo uso degli accessors per formattare le date con un formato leggibile per gli utenti italiani. Ad esempio, definiamo un accessor nel modello User per formattare la data di validazione della email. Il campo si chiama email_verified_at, quindi per convenzione, il nostro metodo deve chiamarsi emailVerifiedAt()<pre><code>use Illuminate\Database\Eloquent\Casts\Attribute;
use Carbon\Carbon;
protected function emailVerifiedAt() : Attribute
{
 return new Attribute(
 get: fn ($value) =&gt; $value ? Carbon::parse($value)-&gt;translatedFormat('d/m/Y H:i') : null
 );
}</code></pre>Possiamo anche creare dei campi logici, che fisicamente non esistono nel database ma attraverso un accessor possono essere costruiti e iniettati nell&#39;istanza del modello.Ad esempio potremmo creare, sempre nel modello User, un accessor full_name. Un campo che non esiste in tabella ma che possiamo ricavare concatenando i campi first_name e last_name<pre><code>protected function fullName() : Attribute
{
 return new Attribute(
 get: fn () =&gt; $this-&gt;first_name . ' ' . $this-&gt;last_name
 );
}</code></pre>Testiamo il funzionamento su TinkerCome vedete, gli effetti degli accessors si notano solo nel momento in cui vengono invocati. In alcune situazioni, definire un accessor per un campo realmente esistente nel database, pu&ograve; portare una serie di problemi.Si pensi ad esempio alle operazioni di storicizzazione dei record, in cui di solito si prende un record dalla tabella live e si clona nella tabella delle storicizzazioni. Se nel modello sono definiti degli accessors, soprattutto per quanto riguarda le date, si potrebbero verificare dei problemi in fase di scrittura. Per risolvere questo piccolo inconveniente si utilizza il metodo getRawOriginal() passandogli come parametro il nome del campo.<h2>Mutators</h2>I mutators sono l&rsquo;altra funzionalit&agrave; relativa al casting attributi dei modelli. Come test, riprendiamo la situazione che abbiamo paventato alla fine del paragrafo precedente: Abbiamo una tabella da storicizzare con i dati con i record della tabella live.Velocemente creiamo modello e migration<pre><code>php artisan make:model UserHistory -m</code></pre>I campi della migrations saranno gli stessi della tabella users, senza token e password, con l&#39;aggiunta della foreign key per legare i records.<pre><code>public function up()
{
 Schema::create('user_histories', function (Blueprint $table) {
 $table-&gt;id();
 $table-&gt;unsignedBigInteger('user_id');
 $table-&gt;foreign('user_id')-&gt;references('id')-&gt;on('users')-&gt;onDelete('cascade');
 $table-&gt;string('first_name');
 $table-&gt;string('last_name');
 $table-&gt;string('email')-&gt;unique();
 $table-&gt;timestamp('email_verified_at')-&gt;nullable();
 $table-&gt;timestamps();
 });
}</code></pre>Aggiungiamo la propriet&agrave; guarded nel modello UserHistory<pre><code>class UserHistory extends Model
{
 use HasFactory;
 protected $guarded = [];
}</code></pre>E aggiungiamo nel modello User la relazione Has Many con il modello UserHistory<pre><code>public function histories()
{
 return $this-&gt;hasMany(UserHistory::class);
}</code></pre>A questo punto vediamo come storicizzare un utente qualsiasi. Come gi&agrave; detto, non abbiamo bisogno di tutti i campi, quindi elimineremo quelli che non ci servono con il metodo makeHidden().Dopodich&eacute;, attraverso la relazione che abbiamo appena creato, creeremo il nuovo record nella tabella user_histories<pre><code>$user = User::find(1);
$data = $user-&gt;makeHidden([
'id',
'password',
'remember_token',
'created_at',
'updated_at'
])-&gt;toArray();
$user-&gt;histories()-&gt;create($data);</code></pre>E come paventato riceveremo il seguente errorePer risolvere, possiamo creare un mutator nel modello UserHistory che casti nuovamente il campo email_verified_at.<pre><code>protected function emailVerifiedAt() : Attribute
{
 return new Attribute(
 set: function ($value) {
 $new_value = str_replace('/', '-', $value);
 $timestamp = strtotime($new_value);
 return Carbon::createFromTimestamp($timestamp);
 }
 );
}</code></pre>Et voil&agrave;, problema risolto.

In PHP, non &egrave; necessario specificare il tipo di dato di una variabile quando la si dichiara. 

Il casting degli attributi nei Modelli

Come abbiamo visto nelle lezioni precedenti, uno dei componenti chiave di Laravel &egrave; Eloquent,