Guida Laravel 4 - targetweb.it · tipo MVC (ModelViewController ... stabile e veloce e ha feature...
36
By targetweb.it - Autore: Riccardo Mel – [email protected] 1 Guida Laravel 4 Autore: Riccardo Mel – [email protected] 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.
Transcript of Guida Laravel 4 - targetweb.it · tipo MVC (ModelViewController ... stabile e veloce e ha feature...
By targetweb.it - Autore: Riccardo Mel – [email protected]
1
Guida Laravel 4 Autore: Riccardo Mel – [email protected]
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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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.
http://laravel.com
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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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
By targetweb.it - Autore: Riccardo Mel – [email protected]
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'email 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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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:
http://tuosito.it/cat/link-nome-categoria/id
Per le pagine invece potremmo usare:
http://tuosito.it/page/nome-della-pagina/id
Per la vista del solo articolo singolo presente in una categoria invece:
http://tuosito.it/nome-articolo/id
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';
By targetweb.it - Autore: Riccardo Mel – [email protected]
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]
By targetweb.it - Autore: Riccardo Mel – [email protected]
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)
By targetweb.it - Autore: Riccardo Mel – [email protected]
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');
});
By targetweb.it - Autore: Riccardo Mel – [email protected]
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:
http://tuosito.it/blog
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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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}',
'BlogController@showCat');
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:
http://tuosito.it/blog/web-design/4
//Oppure
http://tuosito.it/blog/sviluppo/5
//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 ));
}//Function
}//Class
By targetweb.it - Autore: Riccardo Mel – [email protected]
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:
<?php
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);
By targetweb.it - Autore: Riccardo Mel – [email protected]
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 ));
}//Function
}//Class
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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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>
<body>
@section('header')
<h1>Questo è il mio Header</h1>
@show
@section('sidebar')
<h3>Sidebar del blog</h3>
@show
<div class="container">
@yield('content')
</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
By targetweb.it - Autore: Riccardo Mel – [email protected]
14
//Routes.php
Route::get('/', 'TuoController@showWelcome');
//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 del file:
@extends('layouts.master')
@section('header')
<h1>Header del sito </h1>
<p>(se definite questa sezione verrà sovrascritto
quando messo nel file matrice)</p>
@stop
@section('sidebar')
<p>Questo è un contenuto dinamico generato per la sola
Home.</p>
@stop
@section('content')
<p>Contenuto della home qui.</p>
@stop
La prima istruzione:
@extends('layouts.master')
By targetweb.it - Autore: Riccardo Mel – [email protected]
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 funzioni:
@section('content')
<p>Contenuto</p>
@stop
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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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 vista
@include('view.nomevista')
Commenti in Laravel
{{-- I commenti di questo tipo non appaiono nell'HTML
--}}
Recuperare percorso assoluto all'applicazione per menu ed immagini (o altro)
<?php 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 IF/ELSE
@if (count($loop) === 1)
<p>Hai un solo elemento nel loop da
visualizzare!</p>
@elseif (count($loop) > 1)
<p>Hai molti elementi da visualizzare!</p>
@else
<p>Nessun elemento trovato </p>
@endif
By targetweb.it - Autore: Riccardo Mel – [email protected]
17
Controlli selettivi
// Se non sei autenticato
@unless (Auth::check())
<p> Non sei autenticato. </p>
@endunless
Loop contenuto
//Per ciascun elemento del loop
@foreach ($loop as $item)
<p>Item: {{ $item->id }}</p>
<p>Item: {{ $item->titolo }}</p>
@endforeach
Cicli FOR
@for ($i = 0; $i < 10; $i++)
Valore: {{ $i }}
@endfor
Cicli WHILE
@while (true)
<p>Loop infinito YO!</p>
@endwhile
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' : '' }}}">
By targetweb.it - Autore: Riccardo Mel – [email protected]
18
{{ Form::label('title', 'Titolo', array('class'
=> 'control-label')) }}
<div class="controls">
{{ Form::text('title', Input::old('title'))
}}
{{ $errors->first('title') }}
</div>
</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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
19
//Submit con classe personalizzata (utile se usate
Bootstrap)
{{ Form::submit('Salva', array('class' => 'btn btn-
primary')) }}
//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
By targetweb.it - Autore: Riccardo Mel – [email protected]
20
//Esempio con separatore diverso del classico trattino
return Str::slug('Titolo del post', '_');
//Output: titolo_del_post
Alla prossima lezione!
By targetweb.it - Autore: Riccardo Mel – [email protected]
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
<?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',
By targetweb.it - Autore: Riccardo Mel – [email protected]
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
By targetweb.it - Autore: Riccardo Mel – [email protected]
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:
<?php
use Illuminate\Database\Migrations\Migration;
class CreateArticoli extends Migration {
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
//
}
/**
* Reverse the migrations.
By targetweb.it - Autore: Riccardo Mel – [email protected]
24
*
* @return 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:
<?php
/**
* Run the migrations.
*
* @return 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()
<?php
/**
* Reverse the migrations.
*
By targetweb.it - Autore: Riccardo Mel – [email protected]
25
* @return 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:
<?php
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateUsers extends Migration {
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
By targetweb.it - Autore: Riccardo Mel – [email protected]
26
Schema::create('articoli', function(Blueprint
$table)
{
$table->increments('id');
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return 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
<?php
Schema::create('example', function($table)
{
By targetweb.it - Autore: Riccardo Mel – [email protected]
27
$table->increments('id');
});
+-------+------------------+-----+----------------+
| Field | Type | Key | Extra |
+-------+------------------+-----+----------------+
| id | int(10) unsigned | PRI | auto_increment |
+-------+------------------+-----+----------------+
bigIncrements
<?php
Schema::create('example', function($table)
{
$table->bigIncrements('id');
});
+-------+---------------------+-----+----------------+
| Field | Type | Key | Extra |
+-------+---------------------+-----+----------------+
| id | bigint(20) unsigned | PRI | auto_increment |
+-------+---------------------+-----+----------------+
string
<?php
Schema::create('example', function($table)
{
$table->string('nickname', 128);
});
+----------+--------------+
| Field | Type |
+----------+--------------+
| nickname | varchar(255) |
+----------+--------------+
text
<?php
Schema::create('example', function($table)
{
$table->text('body');
});
+-------+------+
By targetweb.it - Autore: Riccardo Mel – [email protected]
28
| Field | Type |
+-------+------+
| body | text |
+-------+------+
integer
<?php
Schema::create('example', function($table)
{
$table->integer('esempio');
});
+-----------+---------+
| Field | Type |
+-----------+---------+
| shoe_size | int(11) |
+-----------+---------+
date
<?php
Schema::create('example', function($table)
{
$table->date('when');
});
+-------+------+
| Field | Type |
+-------+------+
| when | date |
+-------+------+
dateTime
<?php
Schema::create('example', function($table)
{
$table->dateTime('when');
});
+-------+----------+
| Field | Type |
+-------+----------+
| when | datetime |
+-------+----------+
time
By targetweb.it - Autore: Riccardo Mel – [email protected]
29
<?php
Schema::create('example', function($table)
{
$table->time('when');
});
+-------+------+
| Field | Type |
+-------+------+
| when | time |
+-------+------+
timestamp
<?php
Schema::create('example', function($table)
{
$table->timestamp('when');
});
+-------+-----------+---------------------+
| Field | Type | Default |
+-------+-----------+---------------------+
| when | timestamp | 0000-00-00 00:00: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.
<?php
use Illuminate\Database\Migrations\Migration;
class AddTitleToUsers extends Migration {
/**
* Run the migrations.
*
By targetweb.it - Autore: Riccardo Mel – [email protected]
30
* @return void
*/
public function up()
{
Schema::table('articoli', function($table)
{
$table->string('status');
});
}
/**
* Reverse the migrations.
*
* @return 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
By targetweb.it - Autore: Riccardo Mel – [email protected]
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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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:
<?php
$query = "
INSERT INTO
film
VALUES (
'{$film->titolo}',
'{$film->descrizione}'
);
";
Grazie ad eloquent invece il codice si riduce drasticamente a:
<?php
//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?
By targetweb.it - Autore: Riccardo Mel – [email protected]
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
<?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
<?php
// app/routes.php
// Quando viene digitato l'indirizzo add/films
Route::get('/add/films', function()
{
By targetweb.it - Autore: Riccardo Mel – [email protected]
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();
By targetweb.it - Autore: Riccardo Mel – [email protected]
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.
By targetweb.it - Autore: Riccardo Mel – [email protected]
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.
