Autore: Riccardo Mel

Transcript

1 Guida Laravel 4 Autore: Riccardo Mel info@riccardomel.com Sommario del corso Primi passi e installazione di Laravel Introduzione alle routes per gestire il progetto Guida all uso dei Controller Gestire il layout in Laravel 4: Guida al blade template system Database e migrazioni in Laravel 4 Capitolo 1: Installazione e primi passi Quando si sviluppano applicazioni come CMS, WebApp molto complesse nasce ben presto l'esigenza di avere una serie di controlli e best practices già precompilate e pronte all'uso. Per questo motivo sono nati da molti anni a questa parte una vasta selezione di Framework PHP che possono essere utilizzati a questo scopo. Tengo subito a precisare che ne esistono moltissimi tipi, e ciscuno possiede pregi e difetti. Partite dal presupposto quindi che il framework "perfetto" non esiste, esiste solo quello che fa al caso vostro. Il mio consiglio è partire da uno (se vorrete seguire il mio ciclo di articoli sarà Laravel) e di ampliare la vostra conoscenza anche approfondendone altri. Tenete presente che in linea di massima il funzionamento "logico" dei framework è abbastanza similare, in quanto adottano ormai tutti un pattern di programmazione di tipo MVC (ModelViewController). Ecco una breve lista dei più famosi framework per agevolare lo sviluppo e rendere le nostre applicazioni stabili e sicure. Codeigniter Codeigniter è un ottimo framework php nato per essere facile e veloce. La sua curva di apprendimento è infatti forse la più facile che potete trovare. Yii Framework Un ottimo framework non proprio facilissimo per iniziare ma estremamente veloce e sicuro. 1

2 Zend Un "pilastro" dei framework php molto usato sopratutto da grandi aziende. Ultra-stabile e rodato. Alcune scelte adottate sono discutibili. Curva di apprendimento da rivedere. Symfony Un altro must-have dei framework php, anziano, community attiva ed enorme (vengono organizzati anche dei symfonyday), assolutamente completo e stabile. Contro: il più difficile da imparare sopratutto se siete al vostro primo framework. CakePHP Un framework snello e facile da usare, senza troppe pretese. Onestamente però eviterei di consigliarlo per progetti medio-grandi dati i suoi limiti. Per progetti piccoli può essere una soluzione veloce, ma per questo tipo di progetti esistono altre vie. Ok quindi perchè hai scelto Laravel? Laravel non è forse il più facile framework da cui partire. Inutile negarlo. Tuttavia è stato da subito la mia scelta dopo aver "masticato" un po' di Codeigniter. Questo perchè è estremamente completo, stabile e veloce e ha feature davvero particolari che lo rendono unico e utile in molte occasioni (avrò modo di spiegarvele passo passo in questo corso). La community è in continua crescita (fate conto che fra tutti i framework sopra-citati è il più giovane ) proprio perchè molti developer CI (CodeIgniter) si stanno spostando su Laravel. La licenza è di tipo Open Source MIT. Laravel vi permetterà di creare qualsiasi tipo di progetto dal piccolo al grande,e non vi sentirete mai "costretti" a cambiare perchè vi manca qualcosa. Installazione di Laravel 4 Passiamo ora all'installazione di Laravel. Se non avete mai visto un framework php potrebbe essere abbastanza difficile senza una guida passo-passo. Per vostra fortuna eccola: Step1: Download di Laravel Scaricate laravel dal sito ufficiale e copiate il contenuto in una cartella nel vostro server. Per comodità useremo XAMPP come server locale e "laravel" come cartella in cui mettere i file. 2

3 Step2: Installare COMPOSER Laravel utilizza Composer per gestire le dipendenze, per installarlo quindi dovrete installarlo. Andate sul sito ufficiale di Composer, scaricate e installate. Step3: abilitare ssl nel php ini in caso di errore Nel caso vi apparisse un messaggio di questo tipo: You must enable the openssl extension to download files via https Potrebbe essere necessario abilitare il supporto SSL nel vostro PHP ini. Per farlo aprite il php.ini del vostro server e cercate la stringa: ;extension=php_openssl.dll Per abilitare il supporto ssl vi basterà eliminare il punto e virgola iniziale. Step4: Spostarsi nella directory A questo punto, installato composer, aprite la console di windows (cercate cmd.exe). Dobbiamo spostarci nella directory locale in cui avete posizionato i file nel punto 1 (nel nostro caso "laravel"). Per farlo dobbiamo usare il comando "cd DIRECTORY". cd C:\\xampp\htdocs\laravel Step5: Popolare le dipendenze Una volta dentro la directory scrivete la seguente riga nella console: composer install A questo punto aspettate che vengano create le dipendenze e che tutto venga installato. Variante: Nel caso voleste saltare lo step 1 potete usare il seguente codice per creare automaticamente la directory e scaricare i file necessari di Laravel (ovviamente nello step 4 dovrete posizionarvi nella root del server e non già dentro la cartella del progetto): composer create-project laravel --prefer-dist Variante2: Per installarlo in una sotto-cartella: composer create-project laravel/laravel --prefer-dist Step6: Aprire laravel installato 3

4 Per vedere il vostro sito dovrete digitare "localhost/laravel/public" per vedere il contenuto. Ovviamente per altri progetti sostituite "laravel" con il nome della cartella in cui avete messo i files. Configurazioni essenziali La cartella essenziale per gestire la vostra app è per l'appunto "App". Per prima cosa però configuriamo l'app e il database. Per configurare l'applicazione aprite il file: "config / app.php" Per configurare il database aprite il file:"config / database.php" Laravel usa un invio via SMTP (più sicuro di PHP MAIL), per configurare l' di invio e il server SMTP aprite il file:"config / mail.php" Capire il pattern di programmazione MVC Come vi avevo già preannunciato il pattern logico di programmazione usato da Laravel è di tipo ModelViewController. Il funzionamento basilare da capire è piuttosto semplice. Controller: elabora e "smista" le varie richieste http Model: Set di istruzioni utili a gestire qualcosa (es. aggiunta articoli, modifica articoli etc) View: Template per la visualizzazione a schermo. In questo modo l'html e le funzioni progettuali rimangono "divise". In Laravel è presente altresì un file essenziale, posizionato dentro la cartella app chiamato routes.php. Di base questo file appare così: Route::get('/', function() return View::make('hello'); In pratica quando l'utente richiede la root del vostro sito (ovvero localhost/tuosito/public) deve essere elaborata la vista "hello" presente nella cartella view (troverete un file hello.php). Il template system usato da Laravel per le "viste" è chiamato Blade. Scopriremo meglio come creare un layout completo nella prossima lezione, Per ora iniziate a capire il funzionamento della pagina hello iniziale o provate a creare una vostro routes a partire da quelle di esempio. Conclusioni Nella prossima lezione vedremo come usare al meglio le views e creare un template usando il Blade template system. 4

5 Capitolo 2: Le routes Che cosa sono le routes e a cosa servono Come suggerisce il nome, una route è una "strada". Per capire meglio potete pensarle come uno strumento per "smistare" letteralmente le richieste http che vegono effettuate. In un pattern di sviluppo MVC e per rendere più ordinato e logico tutto l'impianto progettuale vi consiglio di evitare di effettuare il controlling direttamente dentro la route ma di passare variabili e informazioni al controller. Il tutto risulterà più ordinato e facile da gestire (sopratutto per grandi progetti). Ma cosa fa di fatto un route? Partiamo dal presupposto che ogni link ha una sua struttura essenziale. Ad esempio per la vista delle categorie potremmo pensare a una struttura simile a questa: Per le pagine invece potremmo usare: Per la vista del solo articolo singolo presente in una categoria invece: Come avete modo di notare, anche se di fatto ogni link "reale" sarà univoco, ha anche una struttura "fissa" a seconda di quale sezione deve puntare. Ovviamente il mio consiglio è quello di pianificare PRIMA di iniziare a stendere la vostra app quale sarà la struttura generale dei vostri link. Di fatto le routes servono proprio a definire quale pattern volete usare per i vostri link e decidere cosa elaborare e visualizzare al visitatore quando digita o segue un link. Routes semplici La route più semplice è già presente quando installate Laravel 4 e permette di renderizzare la home. Ecco la struttura di una routes GET (standard): //Quando il visitatore richiede la root (home) del sito Route::get('/', function() //Visualizza Hello World return 'Hello World'; 5

6 Come avete modo di notare la struttura per dichiarare una root è semplice: Route:: -> Dichiarazione standard (fissa) tipo di richiesta -> può essere get, post, any Pattern del link -> Lo decidete voi a seconda delle vostre esigenze e usi. Funzione da renderizzare se il pattern viene identificato -> in questa sezione potete o eseguire una funzione direttamente nella route (sconsigliato) oppure passare i dati ed eseguire un controller (consigliato) che elaborerà la richiesta e passerà il tutto a una view per renderizzare a schermo i risultati. Ecco alcuni esempi di routes utili a capire meglio (leggi i commenti al codice per maggiori informazioni). Route POST Molto utile e usato per elaborare, ad esempio, link o dati passati tramite ajax. //Se il link corrisponde al pattern cat/targetweb e viene passato via POST Route::post('cat/targetweb', function() //Visualizza questo return 'Categoria: TargetWeb'; Route Any Any sta a indicare che non ci importa se il link viene passato via POST o GET. In entrambi i casi elabora la richiesta. Route::any('targetweb', function() return 'Targetweb'; Route HTTPS Rende sicura via HTTPS la connessione Route::get('targetweb', array('https', function() return 'Must be over HTTPS'; })); [lightgrey_box] NOTA: Avrete già capito che ogni pattern - link o richiesta deve necessariamente avere la relativa route per essere "smistato" ed elaborato da Laravel. [/lightgrey_box] 6

7 In tutti questi esempi abbiamo elaborato la richiesta direttamente dentro la route specificando una function elementare. In generale la route deve però "puntare" a un controller che dovrà poi elaborare i dati (o accedere al database ad esempio). Per fare ciò dovete usare una struttura di questo tipo: //La route punta al controller "HomeController" e all'azione "showwelcome" Route::get('/', 'HomeController@showWelcome'); Non vi preoccupate, capirete meglio nelle prossime lezioni quando parleremo dei Controllers. Passare variabili alla routes Nella creazione di una webapp avrete bene presto la necessità di dover "passare" dati o variabili per elaborare delle richieste. Laravel ci permette di definire nel pattern delle routes elementi variabili in questo modo: //Esempio: Se digitate cat/5 come url Route::get('cat/id}', function($id) //Output: La route visualizzerà: Route dinamica - Cat 5 return 'Route dinamica - Cat'.$id; Potete anche fare in modo che la variabile sia opzionale usando questa sintassi: //Se non c'è la variabile ID quet'ultima assume il valore di default nullo Route::get('cat/id?}', function($cat= null) return $cat; Filtri e cenni sulle routes avanzate Grazie alle routes è possibile anche filtrare e smistare come meglio crediamo il flusso di richieste a seconda di determinate condizioni. Ecco un piccolo esempio introduttivo: //Definizione della route filtrata "old" Route::filter('old', function() //Se il valore dell'imput age è < di 200 if (Input::get('age') < 200) 7

8 //Reindirizza alla Home return Redirect::to('home'); } Altre routes utili Routes a pattern Route::when('admin/*', 'admin'); In questo esempio comunichiamo alla routes che non ci importa che cosa c'è dopo admin/ Forzare la pagina 404 App::abort(404); Route private (accessibili solo se autenticati) //Rende privata la routes Route::group(array('before' => 'auth'), function() Route::post('targetweb/admin/id}', 'Controller@Action'); 8

9 Capitolo 3: Guida all uso dei Controller Che cosa sono i Controller in Laravel4 Nella precedente lezione abbiamo visto come strutturare la nostra applicazione a seconda del link che viene richiesto dal visitatore. Lo scopo finale di una routes in una programmazione strutturata è quello di passare informazioni a qualcosa di più "complesso" capace di elaborare / filtrare eventuali informazioni per poi visualizzarle all'utente finale. Questo strumento "complesso" prende il nome di Controller. Pensiamo ad esempio ad un blog. Di base avremo bisogno di una lista di articoli da cui scegliere e di una vista singola dove l'articolo viene mostrato in modo esteso con foto/testo etc. Come avrete imparato dal precedente capitolo avremo bisogno quindi di due routes: una per la categoria e una per la single view. Ogni routes dovrà puntare a una funzione differente del controller. Ecco un esempio chiarificatore per la visualizzazione di una categoria del blog: //Routes presente nel file routes.php Route::get('blog', 'BlogController@showCat'); // app/controllers/blogcontroller.php class BlogController extends BaseController public function showcat() return View::make('blog/cat'); }//Cat }//Class Come avete visto in questo semplice esempio la routes ad una richiesta HTTP di questo tipo: Elabora la funzione showcat presente all'interno di BlogController. (BlogController@showCat). Nel nostro caso la funzione showcat consiste nel mostrare una banale vista (ovvero la pagina del blog), ma il vero potenziale dei controller sta nell'elaborazione e gestione del flusso di dati PRIMA di inviarli alla rispettiva view. Con un controller di questo tipo infatti, di fatto non viene inviato nulla alla vista "Blog/Cat" che risulterà pertanto ancora vuota senza nulla di dinamico da visualizzare. 9

10 Passare variabili ai controller ed elaborare il flusso di dati Come abbiamo detto vogliamo finalmente visualizzare qualcosa (dinamico) nella categoria. Come fare? Per prima cosa dobbiamo modificare la routes passando l'id della categoria da visualizzare in questo modo: Route::get('blog/permalink_cat}/id_cat}', Per ragioni SEO (e non solo) è buona abitudine passare anche il permalink della categoria. A questo punto, quando l'utente farà una richiesta di questo genere: //Oppure //etc etc Verrà elaborato il nostro controller a cui però saranno fornite le seguenti variabili: $permalink_cat $id_cat Cosa ce ne facciamo nello specifico? Bhè useremo l'id per "estrarre" dal database tutti gli articoli presenti in quella categoria e passeremo poi il tutto alla nostra vista. Per estrapolare i dati dal database ci basterà usare questo codice all'interno del nostro controller: class BlogController extends BaseController public function showcat($permalink_cat,$id_cat) //Trovo tutti gli articoli della cat attraverso l'id $articoli = Articoli::find($id_cat); //Visualizzo la pagina della categoria passando l'array articoli //contenente il loop di tutti gli articoli in cat return View::make('blog/cat', array('articoli ' => $articoli )); }//Class }//Function 10

11 Nota importante: per poter usare la funzionalità FIND($id) dovete aver impostato il relativo Model all'interno della cartella "models". Nel nostro caso specifico andate a creare un file Article.php all'interno della cartella "models" e metteteci dentro questo codice per abilitare le funzionalità offerte da Eloquent ORM: class Article extends Eloquent protected $table = 'articles'; public function author() return $this->belongsto('user'); } } Nota importante #2: Le variabili che definite nella funzione (ShowCat nel nostro caso) devono avere lo stesso ordine di quelle che avete impostato all'interno della routes. Se avessimo scritto in questo modo ad esempio: public function showcat($id_cat,$permalink_cat) avremmo avuto dei problemi, quindi fate attenzione! Codice completo: Gestione vista blog //File Routes.php Route::get('blog/permalink_cat}/id_cat}','BlogControl ler@showcat'); //File models/article.php class Article extends Eloquent protected $table = 'articles'; public function author() return $this->belongsto('user'); }//Function }//Class //File controller/blogcontroller.php class BlogController extends BaseController public function showcat($permalink_cat,$id_cat) //Trovo tutti gli articoli della cat attraverso l'id $articoli = Articoli::find($id_cat); 11

12 //Visualizzo la pagina della categoria passando l'array articoli //contenente il loop di tutti gli articoli in cat return View::make('blog/cat', array('articoli ' => $articoli )); }//Class }//Function Conclusioni Grazie al nostro ciclo di guide dedicate a Laravel alla fine di questa lezione dovreste avere imparato: Che cos'è Laravel e perchè usarlo Come installarlo in pochi semplici steps Come gestire le routes (richieste) per i vostri progetti Come elaborare le routes e gestire il flusso di dati (loop etc). Nella prossima lezione andremo a vedere come strutturare le "viste" ovvero come visualizzare a schermo i dati recuperati ed elaborati dal controller. 12

13 Capitolo 4: Gestire il layout in Laravel 4: guida al blade template system Struttura del template Usare il Blade template system risulta da subito piuttosto intuitivo: di fatto abbiamo un file di layout "master" ovvero una matrice. A loro volta le matrici possono poi essere opportunamente rese dinamiche con le varie views sovrascrivendo determinate sezioni precedentemente dichiarate. Poniamo sempre l'esempio del nostro blog in Laravel. Avremo di fatto bisogno di una vista per la home, una per le categorie e una per l'articolo singolo. Per realizzare il tutto ad esempio, procediamo come segue: Create un file master.blade.php all'interno della cartella views/layouts e incollate questo codice: <html> <h1>questo è il <h3>sidebar del <div </div> </body> </html> Come vedete all'interno della matrice vanno definite tutte le "sezioni" da rendere dinamiche. Senza la dichiarazione di sezione non potremo agire successivamente sul contenuto, rendendo di fatto quell'elemento del tema statico. La suddivisione in sezioni è pertanto un'operazione molto importante e deve essere il più accurata possibile. Una volta realizzata la matrice (nel nostro caso un classico blog con sidebar) andiamo a definire le "viste" del nostro tema. Nel nostro esempio, dobbiamo ovviamente aver impostato le relative routes e controller come abbiamo visto nei capitoli precedenti. Ecco uno schema riassuntivo per visualizzare, ad esempio la home: //Esempio riassuntivo per la visualizzazione // della home tramite routes e controller 13

14 //Routes.php Route::get('/', //Controllers/TuoController.php class TuoController extends BaseController public function showwelcome() return View::make('home') }//Function }//Class Come avete notato per visualizzare una vista abbiamo bisogno di una funzione simile a questa: View::make('nomefileblade'). All'interno di Make dovete inserire il nome del file nome.blade.php corrispondente alla view che volete visualizzare. Se il file si trova all'interno di una cartella dovrete usare questa sintassi: View::make('cartella/nomefileblade'); Nel nostro caso: return View::make('home') Apre il file home.blade.php presente nella root della cartella app/views. Ecco la struttura interna <h1>header del sito </h1> <p>(se definite questa sezione verrà sovrascritto quando messo nel <p>questo è un contenuto dinamico generato per la <p>contenuto della home La prima 14

15 Definisce su quale matrice operare. Laravel permette infatti di specificare diverse matrici. Nel caso del blog ad esempio potrebbe essere necessario specificare la matrice home (con slider o senza sidebar ad esempio) differente da quella delle categorie e vista singola. Le Permettono di effettuare una sovra-scrittura del contenuto "statico" messo all'interno della matrice. Preparare i files e librerie del vostro tema Per preparare la struttura dei vostri files da usare nel tema vi consiglio di creare prima il tutto su carta per definire cartelle e un workflow generale dell'applicazione. IN generale le cartelle images, javascript e stylesheets vanno inserite all'interno della cartella public (non vi preoccupate, vedremo in seguito come rimuovere la cartella public e far visualizzare il sito semplicemente dalla root dello stesso). Per "linkare" le varie librerie e files dell'applicazione usate questa sintassi all'interno della vostra matrice o views del tema: //Stili CSS HTML::style('stylesheets/frontend/bootstrap.min.css') }} //Librerie o JS HTML::script('javascripts/frontend/theme.js') }} Nel caso l'applicazione disponga di un backend il mio consiglio è di suddividere ulteriormente ogni cartella in backend e frontend. Ad esempio avremo: /images backend frontend /stylesheets backend frontend e cosi via. In questo modo avrete tutto catalogato nel migliore dei modi. 15

16 Visualizzare dati Come abbiamo visto nella precedente lezione sui controller possiamo passare alla views anche variabili, array o altro. Ma come faccio a gestire la visualizzazione dei vari elementi? Ecco alcuni strumenti pronti all'uso per iniziare a comporre il vostro tema. Visualizzare variabili $variabile }} Escape delle variabili $variabile }}} Includere una sub-views all'interno della Commenti in Laravel -- I commenti di questo tipo non appaiono nell'html --}} Recuperare percorso assoluto all'applicazione per menu ed immagini (o altro) echo URL::to('/');?> Controlli e loop Ovviamente il vero fulcro della dinamicità di un tema Laravel è composto sicuramente dai loop o dai controlli. Nel caso del loop ricordatevi di passare alla vista l'array del contenuto come abbiamo visto nella precedente lezione: return View::make('home')->with('loop', $loop ); Ecco alcuni codici utili: Controlli (count($loop) === 1) <p>hai un solo elemento nel loop da (count($loop) > 1) <p>hai molti elementi da <p>nessun elemento trovato 16

17 Controlli selettivi // Se non sei (Auth::check()) <p> Non sei autenticato. Loop contenuto //Per ciascun elemento del ($loop as $item) <p>item: $item->id }}</p> <p>item: $item->titolo Cicli ($i = 0; $i < 10; $i++) Valore: $i Cicli (true) <p>loop infinito Gestione Form Laravel 4 permette un controllo completo sui form, per aprire un nuovo form vi basterà usare questa sintassi: Form::open(array('url' => 'add/nomeroute','method'=>'post')) }} //Codice form qui Form::close() }} [lightgrey_box] NOTA: Se il vostro form accetta i files in upload ricordatevi di aggiungere 'files' => true dentro l'array di apertura del form.[/lightgrey_box] Per i vari input invece usate una struttura che possa contenere anche eventuali errori di compilazione: <!--Input type="text" --> <div class="control-group $errors->has('title')? 'error' : '' }}}"> 17

18 Form::label('title', 'Titolo', array('class' => 'control-label')) }} }} </div> <div class="controls"> Form::text('title', Input::old('title')) $errors->first('title') }} </div> <!--Input textarea --> <div class="control-group $errors- >has('description')? 'error' : '' }}}"> Form::label('description', 'Descrizione', array('class' => 'control-label')) }} <div class="controls"> Form::textarea('description', Input::old('description'), array( 'id' => 'description', 'class'=> 'description', 'rows' => 20, )); }} $errors->first('description') }} </div> </div> Per le select la sintassi di codice da usare è la seguente: //Con valori fissi Form::select('status', array('elemento' => 'Elemento', 'Elemento2' => 'Elemento2'))}} //Con valori in array passati dal controller Form::select('categoria', $categoriesarr)}} Potete anche impostare un valore di default personalizzato per la select in questo modo: //Elemento2 selezionato di default Form::select('status', array('elemento' => 'Elemento', 'Elemento2' => 'Elemento2'),'Elemento2')}} Altri elementi utili per i form. 18

19 //Submit con classe personalizzata (utile se usate Bootstrap) Form::submit('Salva', array('class' => 'btn btnprimary')) }} //Elemento nascosto Form::hidden('name',$name) }} Helpers molto utili in Laravel Utilità per le parole echo Str::lower('Viva Targetweb'); // viva targetweb echo Str::upper('Viva Targetweb'); // VIVA TARGETWEB. echo Str::title('Viva Targetweb ciao a tutti'); // Viva Targetweb Ciao A Tutti Limitare caratteri echo Str::limit("Lorem ipsum dolor sit amet", 10); // Lorem ipsu... echo Str::limit_exact("Lorem ipsum dolor sit amet", 10); // Lorem i... Generare una stringa random echo Str::random(32); Singolare e plurale echo Str::plural('user'); // users echo Str::singular('users'); // user Creare uno slug/permalink return Str::slug('Titolo del post'); //Output: titolo-del-post 19

20 //Esempio con separatore diverso del classico trattino return Str::slug('Titolo del post', '_'); //Output: titolo_del_post Alla prossima lezione! 20

21 Migrazioni e Database in Laravel 4 Laravel 4 permette diversi modi e strategie per accedere al database ed elaborare i dati. I driver per i database supportati di default sono molto vari e comprendono: Mysql Sql Server PostgreSQL SqlLITE Configurare laravel 4 per la connessione al db La prima cosa da fare per poter usare laravel collegato ad un database è configurare il "puntamento" agendo sul file app/config/database.php 'connections' => array( 'sqlite' => array( 'driver' => 'sqlite', 'database' => DIR.'/../database/production.sqlite', 'prefix' => '', ), 'mysql' => array( 'driver' => 'mysql', 'host' => 'localhost', 'database' => 'database', 'username' => 'root', 'password' => '', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '', ), 'pgsql' => array( 'driver' => 'pgsql', 21

22 ), 'host' => 'localhost', 'database' => 'database', 'username' => 'root', 'password' => '', 'charset' => 'utf8', 'prefix' => '', 'schema' => 'public', 'sqlsrv' => array( 'driver' => 'sqlsrv', 'host' => 'localhost', 'database' => 'database', 'username' => 'root', 'password' => '', 'prefix' => '', ), ), A seconda del driver impostato laravel andrà a recuperare il set di informazioni utili alla connessione al database. Ovviamente dovete impostare il driver a questa riga: 'driver' => 'mysql', Gli shortcode da inserire nella riga precedente per richiamare le varie connessioni differenti sono: mysql - MySQL sqlite - SQLite pgsql - PostgreSQL sqlsrv - SQL Server Ricordatevi di impostare altresì una connessione predefinita: 'default' => 'mysql', Le migrazioni Nella creazione di un'applicazione o sito internet, ogni developer ha l'esigenza di effettuare aggiornamenti "mirati" al suo database. Pensiamo ad esempio una task list di questo tipo: Creare tabella articoli con 4 campi base Aggiungere campo "status" ad articoli Rinomina della colonna da "category" a "cat" Aggiungere sistema di votazione articolo 22

23 Come avrete modo di notare da questo semplice esempio un sito è di fatto "vivo" e ha bisogno di continue manutenzioni, modifiche e aggiustamenti. Laravel4 vi consente di aggiungere in modo sequenziale e controllato le vostre modifiche al database tramite l'uso delle migrazioni. E non solo. Vi permette infatti, qualora qualcosa andasse storto, di effettuare un roll-back per annullare l'effetto della migrazione. Questo può sembrare poco utile ma pensate a un sito medio-grande: ogni modifica può compromettere la stabilità del sistema e ogni amministratore deve agire in modo chirurgico in modo tale da poter ripristinare il sistema in pochi istanti qualora vi siano errori. Creare ed eseguire una migration Per agire su laravel aprite la vostra console di sistema (su windows scrivete cmd nella barra di ricerca). Spostatevi nella cartella contenente l'installazione di laravel in questo modo: cd C:\\xampp\htdocs\tuainstallazionelaravel Ovviamente il percorso è puramente indicativo, e varia a seconda di dove avete installato il vostro xampp o easyphp o similari. Una volta dentro la cartella dell'installazione di laravel che volete amministrare create la vostra prima migrazione digitando questo codice: $ php artisan migrate:make create_articoli Di fatto questo codice (da digitare nel terminale!) crea un file all'interno della cartella app/database/migrations. Il nome del file è varibiabile ma al suo interno troverete: use Illuminate\Database\Migrations\Migration; class CreateArticoli extends Migration /** * Run the migrations. * void */ public function up() // } /** * Reverse the migrations. 23

24 * void */ public function down() // } } Come vedete il codice è diviso in due public function up() e down(). Nella sezione UP andremo a mettere cosa deve fare la migrazione, nella parte DOWN andiamo a inserire cosa deve fare laravel qualora facessimo il roll-back. Ecco, nel nostro esempio come agire sul codice: /** * Run the migrations. * void */ public function up() Schema::create('articoli', function($table) $table->increments('id'); $table->text('titolo'); $table->text('descrizione'); $table->timestamps(); } La funzione UP di questo esempio crea (create) la tabella articoli nel database con i campi: id(auto-increments), titolo (text), descrizione (text), timestamps() crea automaticamente due campi chiamati "created_at" ed "updated_at" che sono davvero molto utili in fase di gestione. Andiamo a vedere il codice della function down() /** * Reverse the migrations. * 24

25 void */ public function down() Schema::drop('articoli'); } Nel nostro esempio la funzione down, per effettuare il rollback, dovrà semplicemente eliminare la tabella appena creata dal database. Pertanto conterrà semplicemente il comando drop(nometabella). Una volta che avrete "compilato" i vari metodi up e down siete pronti per effettuare il run della migrazione e rendere effettive le modifiche al database.per farlo aprite il terminale precedentemente aperto e digitate: php artisan migrate Fatto! avete creato la vostra prima tabella "articoli" all'interno del vostro database! Utile tips per la creazione di nuove tabelle tramite migrazioni Se non avete voglia ogni volta di aggiungere la parte di codice up down etc potete digitare da termina il comando: php artisan migrate:make create_articoli --create -- table=articoli che fornirà un codice di migrazione di questo tipo: use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration; class CreateUsers extends Migration /** * Run the migrations. * void */ public function up() 25

26 $table) } Schema::create('articoli', function(blueprint $table->increments('id'); $table->timestamps(); /** * Reverse the migrations. * void */ public function down() Schema::drop('articoli'); } } Come vedete in questo caso laravel4 vi fornisce già l'intelaiatura di base pronta per essere modificata con i vostri campi personalizzati. Rollback di una migrazione E se volessimo ritornare indietro? Molto semplice vi basterà usare da terminale il seguente codice: php artisan migrate:rollback Ritornerete automaticamente alla versione del database senza la tabella articoli creata della migrazione. Schema Builder Column Types: tipi di campi database Nel precedente capitolo abbiamo specificato termini come increments, text per fornire a laravel informazioni sulla tipologia di campi da creare per il database. Ne esistono ovviamente diversi tipi. ecco una comoda lista dei principali pronta all'uso. increments Schema::create('example', function($table) 26

27 $table->increments('id'); Field Type Key Extra id int(10) unsigned PRI auto_increment bigincrements Schema::create('example', function($table) $table->bigincrements('id'); Field Type Key Extra id bigint(20) unsigned PRI auto_increment string Schema::create('example', function($table) $table->string('nickname', 128); Field Type nickname varchar(255) text Schema::create('example', function($table) $table->text('body');

28 Field Type body text integer Schema::create('example', function($table) $table->integer('esempio'); Field Type shoe_size int(11) date Schema::create('example', function($table) $table->date('when'); Field Type when date datetime Schema::create('example', function($table) $table->datetime('when'); Field Type when datetime time 28

29 Schema::create('example', function($table) $table->time('when'); Field Type when time timestamp Schema::create('example', function($table) $table->timestamp('when'); Field Type Default when timestamp :00: Modifica di una tabella tramite migrations Nell'esempio di apertura abbiamo usato le migrazioni per creare una tabella. Se volessimo modificarne una esistente? Da terminale create intanto il file di migrazione in questo modo: $ php artisan migrate:make add_status_to_articoli Cercate di dare un nome "utile" alla migrazione in modo da capire da subito la modifica che avete effettuato. Nel caso d'esempio aggiungiamo un campo "status" all'interno della tabella appena creata articoli. Una volta fatto vi apparirà un file come da manuale all'interno di app/database/migrations. use Illuminate\Database\Migrations\Migration; class AddTitleToUsers extends Migration /** * Run the migrations. * 29

30 void */ public function up() Schema::table('articoli', function($table) $table->string('status'); } /** * Reverse the migrations. * void */ public function down() Schema::table('articoli', function($table) $table->dropcolumn('status'); } } Il procedimento è simile al precedente, come noterete però non uso più la formula Schema::create ma Schema::table. La logica di up() e down() è rimasta tuttavia invariata. UP()-> aggiungo campo status (string) DOWN() -> in caso di rollback elimina la colonna status (dropcolumn) Per eseguire la modifica che avete creato vi basterà eseguire da terminale il comando: php artisan migrate Link Approfondimento Documentazione Database Documentazione Schema Builder Documentazione Migration 30

31 Tutorial Database by by Codebright Tutorial Schema Builder by Codebright Tutorial Migrazioni by Codebright Nella prossima lezione dedicata a Laravel4 tratteremo il vero "cuore" pulsante di Laravel ovvero Eloquent. 31

32 Capitolo 6: Eloquent Laravel 4 In questa lezione della guida dedicata a Laravel 4 vediamo che cos'è e come funziona eloquent, il vero cuore pulsante di Laravel. Introduzione Una delle sezioni più complesse nella gestione di una qualsiasi applicazione è quella dell'accesso al database per prelevare,elaborare o inserire informazioni di vario tipo. Eloquent minimizza proprio questo problema andando a creare un vero e proprio "motore" utile a sopperire a questo problema. Vediamo un comodo esempio. Voglio inserire (tramite una query mysql) i valori di titolo e descrizione all'interno della tabella "film" del mio database. Per fare ciò senza laravel avrei dovuto usare una query di questo tipo: $query = " INSERT INTO film VALUES ( '$film->titolo}', '$film->descrizione}' ); "; Grazie ad eloquent invece il codice si riduce drasticamente a: //Nuova query $film = new Film; //Associo variabile - valore $film->titolo = 'Titolo film'; $film->descrizione = 'Descrizione film'; //SALVA! $film->save(); Grazie a un semplice comando save() possiamo salvare il nuovo contenuto nel database. Fantastico no? 32

33 Creazione di un model da usare con Eloquent Per poter utilizzare Eloquent il primo passo da seguire è quello di creare un model. Ogni tabella del database deve obbligatoriamente avere un suo model. Per creare il nostro primo model agiamo come segue: Step 1: create la tabella del vostro database. Se non sapete come fare seguite questa sezione della guida. In questo esempio specifico andiamo a creare una tabella chiamata "films" (plurale!) che andrà a contenere l'elenco dei film. Step2: Create un file php e chiamatelo Film.php (singolare!) Step3: Incollate questo codice all'interno di Film.php class Film extends Eloquent protected $table = 'films'; public function author() return $this->belongsto('user'); } } Step4: Salvate il file Film.php all'interno della cartella app/models di Laravel 4. NOTA: Come avrete notato ho messo in risalto la questione singolare/plurale nei nomi dei database. Dovete stare attenti ai nomi che date e usare il plurale per i nomi delle tabelle database e singolare per tutto il resto. A questo punto, per usare il vostro model usando eloquent potete facilmente agire come segue: Codice (minimale) per aggiungere un nuovo film al database tramite eloquent // app/routes.php // Quando viene digitato l'indirizzo add/films Route::get('/add/films', function() 33

34 //Nuovo inserimento, eloquent andrà a prelevare automaticamente la tabella esatta. $film = new Film; //Imposto i contenuti del nuovo film $film->titolo = 'The Avengers'; $film->descrizione = 'Noi abbiamo un Hulk.'; //Salvo il film $film->save(); Ovviamente questo codice è solo di esempio in quanto vi consiglio di piazzare quel codice all'interno di un controller piuttosto che direttamente nella root. ( Se non sai di cosa parlo visita il capitolo dedicato alle Routes e Controller). Principali tipi di Query Eloquent Aggiunta $film = new Film; //Imposto i contenuti del nuovo film $film->titolo = 'The Avengers'; $film->descrizione = 'Noi abbiamo un Hulk.'; //Salvo il film $film->save(); Modifica //Recupero elemento da modificare (1 = ID ) $film = Film::find(1); //Nuovi elementi $film->titolo = 'Capitan America'; $film->descrizione = 'Descrizione film'; //Salvo $film->save(); Vi invito a leggere i commenti per capire meglio il (semplice) funzionamento delle query di aggiornamento. In questa sezione tengo tuttavia a farvi notare una cosa: //Recupero elemento da modificare (1 = ID ) $film = Film::find(1); //Nuovi elementi $film->titolo = 'Capitan America'; $film->descrizione = 'Descrizione film'; //Salvo $film->save(); 34

35 //Seconda query $film->titolo = 'Capitan America2'; $film->descrizione = 'Descrizione film2'; //Salvo $film->save(); //Terza query $film->titolo = 'Capitan America3'; $film->descrizione = 'Descrizione film3'; //Salvo $film->save(); //Risultato finale // Sarà salvato solo il contenuto della terza query ovvero Capitan America3 // Questo perchè non è stato specificato un nuovo film da modificare. ($film = Film::find(1);) Vi invito a visionare i commenti direttamente sul codice. Eliminazione //Trovo elemento da eliminare $film = Film::find(1); //Cancello $film->delete(); Ricerca / Visualizzazione Recupero base di un elemento da ID $film = Film::find(50); In questo semplice esempio viene recuperato il film che ha l'id =50. Recupero elementi con clausola WHERE //Recupero categoria da ID e a partire del suo status $CatArr = Category::where('id', '=', $id)- >where('status', '=', 'Pubblicato')->get(); Come vedete possiamo concatenare i WHERE per filtrare e ottenere esattamente gli elementi di cui abbiamo bisogno.il comando get() alla fine invece è essenziale in quanto "attua" la query di recupero elementi. 35

36 Recupero solo un certo numero di elementi (LIMIT) La possibilità di limitare gli elementi prelevati dalla query è una funzionalità essenziale. Ecco come limitare il numero di elementi: $SingleArr = Article::where('permalink', '=', $permalink)->take(1)->get(); In questo caso verrà prelevato un solo record dalla tabella [take(1)]. Recupero Elementi con ordinamento (ORDERBY) $articlesarr = Article::where('status', '=', 'Pubblicato')->orderBy('created_at', 'DESC')->get(); NOTA: DESC -> Ordine Discendente ASC -> Ordine Ascendente Recupero ultimo ID inserito (LAST INSERT) $id_inserted = $article->id; Creare uno slug (permalink) automatico $article->permalink = Str::slug($userdata['title']); Titolo originale: Titolo Articolo Risultato: titolo-articolo Recupero elementi con paginazione $articlesarr = Article::where('status', '=', 'Pubblicato')->orderBy('created_at', 'DESC')- >paginate(15); In questo esempio grazie a paginate() preleviamo 15 elementi per pagina. Vi invito a visionare le prossime lezioni per un ulteriore approfondimento di questa (utilissima) funzionalità. NOTA: Se usate paginate() NON dovete mettere get() in fondo alla query. 36