Instalation

1.
Intai se downloadeaza si se instaleaza composerul
In CLI exista o serie de comnezi disponibile pentru composer pe care le putem afla cu
composer list
2.
apoi se instaleaza laravel
- fie prin comanda directa in CLI:
composer create-project laravel/laravel --prefer-dist
- downloadam "Laravel installer PHAR archive" apoi in CLI :
laravel new numelefolderului
- fie downloadam ultima versiune a laravel si extragem continutul intru folder pe server
apoi in CLI:
selecta directrorul root al laravel si dam comanda:
composer install
Acest proces necesita ca Git sa fie instalat in prealabil

 app.debug NU TREBUIE SETAT CA true in modul productie

 folderele din app/storage necesita sa fie setate ca sa aiba acces de a fi scrise de catre
web server

3.
Apoi mergem in xampp/apache/conf/httpd.conf la linia 243
Document root si 244 Directory si modificam
din C:/xampp/htdocs in C:/xampp/htdocs/laravel/public
Astfel cand tastam in browser localhost/ va aprea route de baza si nu va fi nevoie sa
scriem C:/xampp/htdocs/laravel/public

4.
In acelasi fisier xampp/apache/conf/httpd.conf trebuie sa verificam daca
xampp/apache/conf/httpd.conf este activat (nu trebuie sa fie comentat)
 CONFIGURATION
By default toate configuratiile din app/configure sunt setate pentru environment
production.

Config::get(‘fisier.key’,’default’) - accesam o anumiita configuratie, al doilea parametru

este valoarea default care va fi afisata daca acea configuratie nu exista
Config::set(‘fisier.key’,’defaul’) - seteaza pentru un anumit key din configuratii o
valoare
Configuratiile setate astfel vor fi valabile doar pentru urmatoarea cerere nu sunt
definitive

Putem accesa environment folosim:

- App::environment()
- app()->environment()
- app()->env
- $GLOBALS['env'] // nu e recomandat , dar e posibil

Pentru a verifica daca environment este ‘local’:

- App::isLocal()
- app()->isLocal()

Pentru a verifica daca environment este 'testing':

- App::runningUnitTests()
- app()->runningUnitTests()

Pentru a verifica daca suntem intr-un anumit mediu (sau mai multe)
if (App::environment('local', 'staging'))
{
// The environment is either local OR staging...
}

Pentru a seta alte environment decat cel default ( productie) vom modifica boostrap/start:

$env = $app->detectEnvironment(array(
'local' => array('philips-mbp.home'),
'staging' => array('staging-server'),
'production' => array('production-server')
));

local = numele environmentului

philips-mbp.home = numele serverului utilizat. Pentru a afla numele serverului in CLI
tastam hostname
Putem folosi o functie closure pentru a detecta mult mai dinamic environmental

$env = $app->detectEnvironment(function()
{
return $_SERVER['MY_LARAVEL_ENV'];
});

Utilizarea fisierului punct (dot files)

Un dot file este un fisier pozitionat in directorul de baza laravel care contine informatii
sensitive sau detalii care sunt legate strict de mediul in care lucrezi.
Pentru fiecare mediu se poate crea un nou dot file.
NU DENUMITI fisierul cu termenul de ‘testing’ deoarece acesta este folosit pentru UNIT
TESTING.

De ex:
Pentru a pastra ascunse informatiile despre baza de date.
Se poate creea un fisier nou cu numele:
.env.local.php care va fi pozitionat in directorul de baza. In interiorul lui vom returna o
matrice de perechi key valori specifice mediului current(local)

<?php
return array(
'DATABASE_NAME' => 'my_database',
'DATABASE_USER' => 'username',
'DATABASE_PASSWORD' => 'totally_secure_password'
);

Iar in database.php vom introduce codul:

'database' => $_ENV['DATABASE_NAME'],

'username' => $_ENV['DATABASE_USER'],
'password' => $_ENV['DATABASE_PASSWORD']

Astfel cand lucram in mediul local, laravel va prelua configuratiile specifice despre baza
de date.

De asemenea trebuie ca in fisierul .gitignore sa includem numele fisierului creat

(.env.local.php) pentru a ne asigura ca fisierul nu e adaugat la git repository

Mainteince mode
Pentru a trece aplicatia in modul mainteince modificam app/start/global:
App::down(function()
{
return Response::view("view_utilizat", array() , 503);
});

Apoi executam in folderol root al aplicatiei in CLI:

php artisan down = aceasta va retce aplicatia in mainteinece mode
php artisan up = va readuce aplicatia in modul live

Artisan vine la pachet cu laravel daca e instalat in CLI prin composer install.
Pentru a vedea comenzile disponibile tasteaza in folderol root in CLI: php
artisan list.
Pentru a vedea comenzile disponibile in composer tasteaza in CLI: composer list

In bootstrap/start.php putem
- seta mediul de lucru astfel:
$env = $app->detectEnvironment(function()

{ return 'development'; });

- seta numele foldrului foloist impreuna cu numele serverului

$env = $app->detectEnvironment(array(
'local' => array('your-machine-name'),));
- setam mediul de lucru intrun mod dinamic
$env = $app->detectEnvironment(function()
{ return $_SERVER['MY_LARAVEL_ENV']; });

Daca dorim sa facem o migratie intrun alt mediu vom specifica asta in CLI :
$ php artisan migrate --env=local

Artisan command
Pe langa toate comenzile disponibile din CLI putem defini propria noastra comanda in
app/commands sau oricunde alt undeva caza in care trebuie sa fim atenti sa poate fi
incarcate de composer.json.
1. Pentru a creea o comanda tastam in CLI

php artisan command:make Numelecomenzii

Daca nu suntem de acord cu locul in care sunt salvate putem alege fie alta locatie
fie un namespace.
php artisan command:make Numelecomenzii --path/classes
--namespace=Classes
 Cand cream comanda putem folosi -- command pentru a denumi comanda.
php artisan command:make - -command =users:assign
2. Dupa ce am creat o comanda aceasta va aparea in app/commands . Aici vom completa
numel e daca nu lam completat in –command. Acesta defineste numele cum va aprea in
list. Aoi vom completa description cu descrierea care va apre de asemnea in list. Fire este
functia care se va executa cand commanda va fi chemata din CLI. Apoi trebuie sa definim
argumente si optiuni fiecare in functiile corespunzatoare.
3. Cand definim un argument vom folosi o matrice de genul:
array($name, $mode, $description, $defaultValue) . argumenetul mode poate fi:
InputArgument::REQUIRED orInputArgument::OPTIONAL
4. Cand definim o optiune vom folosi o matrice de genul:
array($name, $shortcut, $mode, $description, $defaultValue) optiunea poate fi:
InputOption::VALUE_REQUIRED,InputOption::VALUE_OPTIONAL, InputOptio
n::VALUE_IS_ARRAY, InputOption::VALUE_NONE.
5. Cand comanda se executa avem nevoie de argumente si de variabile. Pentru a le accesa
vom folosi:
$this->argument('name'); returneaza argumentul cu numele name
$this->argument(); returneaza toate argumentele
$this->option('name'); returneaza optiunea cu numele name
$this->option(); returneaza toate optiunile
6. Pentru a trimite mesaje consolei vom folosi:
$this->info('Display this on the screen'); afiseaza un text pe ecran
$this->error('Something went wrong!'); afiseaza o eroare pe ecran
$this->ask('What is your name?'); pune o intreabare si preia raspunsul ca argument
$this->secret('What is the password?'); pune o intrebare iar raspunsul este preluat ca
rgument insa nu e vizibil la tastare
$this->confirm('Do you wish to continue? [yes|no]') afiseaza on intreabre si astepata
un raspuns de genul Y sau N
$this->confirm($question, true); similar cu confrim doar ca daca nu e tasta nimic preia
valoarea default
7. Pentru ca laravel sa poate folosi aceasta comanda trebuie sa o inregistram in
app/start/artisan.php astfel: Artisan::add(new CustomCommand);
Daca comanda este inregistrata in IoC Container vom folosi
Artisan::resolve('binding.name');
Daca comanda este inregistarta in service provider vom folosi methoda commands din
metoda boot si trecem IoC Container binding in commanda:
public function boot()
{
$this->commands('command.binding');
}
8. Putem sa chemam alte comenzi din interiorul comenzii recent definite astfel:
$this->call('command:name', array('argument' => 'foo', '--option' => 'bar'));
 Request Lifecycle
Ordinea de functionare al laravel:
1. .thaccess specifica ca fisierul care va preluea cererea din browser este
public/index.php
2. Aceasta va incarca bootstrap/start.php. Aceasta va creea un nou obiect al
Application (care functioneaza pe post de IoC Container). Apoi vor fi setate
anumite cai (path/base, path/app, path/public) si se detecteaza mediul in care se
lucreaza. Apoi va fi activate un script bootstrap care merge adanc pana in lavarel-
framework-src-Illuminate-foundantion-start care realizeaza anumite setari
(timezone, error etc) dar si inregistreaza toti service providers configurati pentru
aplicatie. Service providers au doar o singura metoda: register. Aceasta este
chemata cand service providers este inregistrat cu aplicatia prin intermediul
propriei metode register. Service providers pot fi folosit pentru orice sarcina
bootstrap, nu numai pentru inregistrarea cu IoC Container. Dupa ce toate service
prodivers au fost inregistrati fisierul app/start va fi incarcat.
3. Aici sunt incarcate modelele is controlerele, apoi se stabileste fisierul in care sunt
salvate erorile, sunt incarcate erorile care apar; daca este activata functia
maintaince mode (app::down) atunci va fi afisat viewul din functie. Altfel sunt
incarcate filtrele si routele.
4. Aici evenimentele before si after verifica sarcinile ce trebuiesc realizate inainte de
a chema un route (autentificare, guest etc). Route preia informatiile din model le
prelucreeaza si le incarca in view.
5. Obiectul trimis catre aplicatie este reintors clientului

Fisierel care pornesc aplicatia sunt stocate in app/start. Aici se gasesc:

- global.php
- local.php
- artisan.php
Fisierul global contie o serie de obiecte si includerea filtrelor app/filters. In acest fisier
totusi outem adauga orice dorim iar acestea vor fi incluse la fiecare cerere a aplictiei,
indifferent de mediu.
Fisierul local/php este chemata numai atunci cand aplicatia este in mediul local.
Daca avem si ale medii in afara de cel local putem creea fisiere in folderol start. Acestea
vor fi incarcate automat in momentul cand aplicatia ruleaza in mediul respectiv.
In fisierele start putemn pune orice cod boostrap. Pentru aplicatii mari muta codeul
boostrap in service providers.
Filters = o bucata de cod pe care vrem sa o rulam inainte sau dupa ce laravel cere un
route. Daca vrem ca doar anumiti utilizatori sa acceseze un anumit route, putem lipi un
filtru de autentificare care va determina daca utilizatorii curenti sunt utilizati. Astfel cand
un utilizator in carca sa acceseze un anumity route, laravel va rula filtru inainte de a
accesa route cerut. Dac filtrul returneaza un rasouns atunci laravel va actiona acel raspuns
sin u ceerea initiala a utilizatorului.

Route::filter('auth', function()
{
if (Auth::guest()) return Redirect::guest('login');
});

Laravel verifica daca utilizatorul current e guest. Daca utilizatorul current nu e

autentificat , filtrul returneaza un redirect catre pagina login.

Route::get('user/premium', array('before' => 'auth|premium',

'uses' => 'UserController@premium',
'as' => 'user.premium'
));
In filtrul de mai sus:
Primul parametru este numele paginii iar al doilea este o matrice formata din filtru ,
numele controlerului si numele URL-ului.
Filtrul poate avea mai multe valori pe care la va verfica. Daca primul nu e validat, al
doilea e anulat. Deci valorile filtrelor trebuie puse de la mare la mic (ca actiune)

Route::when('admin/*', 'admin');
Toate URL care sunt namespaced sub folderol admin/*
vor fi filtrate automat.

Route::when('post/*', 'auth', array('post',

1 'put', 'delete'));
Doar utilizatorii autentificati pot creea, edita, sterge
poastari din aplicatia curenta.

Route::group(array('before' => 'auth'), function()

{
Route::get('user/account', 'UserController@account');
Route::get('user/settings', 'UserController@settings');
Route::get('post/create', 'PostController@create');
Route::post('post/store', 'PostController@store');
// ...
});
Gruparea folderelor. Toate route vor trebui sa treaca prin acest filtru inainte de a putea fi
accesate.

ROUTES
1. Route::get( '/', function(){ return 'Hello World'; });
- primul parametru este pagina din browser
- al doilea paremtru este functia closure ca raspuns la accesarea paginii
- get sa foloseste la accesarea unei pagini, post la crearea sau updatare
2. Route::match(array('GET', 'POST'), '/', function(){ return 'Hello World';});
- primul parametru contine tipul de accesare
- al doilea este pagina din browser
- al treilea parametru este functia closure
3. Route::any('foo', function(){ return 'Hello World';});
- pentru orice tip de accesare
4. Route::get('foo', array('https', function(){ return 'Must be over HTTPS';}));
- fortam un route sa fie HTTPS

5. URL::to('foo')
- genereaza url catre un anume route

6. Route::get('user/{id}', function($id){ return 'User '.$id;});

- id devine un parametru pentru functia closure cand este introdus in url
7. Route::get('user/{name?}', function($name = null){ return $name;});
- name? este optional, daca nu e introdus in url, atunci functia automat il
considera null
8. Route::get('user/{name?}', function($name = 'John'){ return $name;});
- name poate avea valoarea default null sau o alta valoarea care va fi
executa dacanu e introdus alta valoare in rul
9. Route::get('user/{id}/{name}', function($id, $name){ // })
->where(array('id' => '[0-9]+', 'name' => '[a-z]+'))
- putem adauga constrangeri la route
- Daca constrangerile nu sunt respectate pagina va returna o eroare
 - daca vrem sa introducem constrangeri doar pentru un url nu mai punem
array cid oar constrangerea
10. Route::pattern('id', '[0-9]+');
Route::get('user/{id}', function($id){ // Only called if {id} is numeric. });
- putem define un pattern de constrageri ce se vor aplica intotdeauna pentru
elementul din url selectat
11. Route::filter( 'foo', function(){ if (Route::input('id') == 1) { //}});
- daca vrem sa accesam un element din afara route vom folosi Route::input

12. Route::filter('old', function()

{ if (Input::get('age') < 200){ return direct::to('home'); }});
- cu ajutorul filter putem limita accesul utilizatorilor in anumite route
- exista filter deja stabilite: auth, auth.basic, guest, csrf.
- exemplul de mai sus defineste un filtru
- daca filtrul returneaza un raspuns atunci acel raspuns va fi luat in
considerare si nu route care a creat cererea
- toate filtrele ‘after nu vor mai fi executate’ daca acest filtru returneaza un
raspuns
13. Route::get('user',
array( 'before' => 'old', function(){ return 'You are over 200 years old!'; }));
- ataseaza un route de un filtru
- orice cererea catre acest route va trece intai prin filtrul ‘old’ pentru a fi
verificata conditia din closure
- astfel se ataseaza un filtru de un route

14. Route::get('user', array('before' => 'old','uses' =>'UserController@showProfile'));

- astfel se ataseaza un filtru de actiunea unui route

15. Route::get('user', array('before' => 'auth|old', function(){ return 'You are

authenticated and over 200 years old!'; }));
- daca vrem sa atasam mai multe filtre unui route o putem face prin pipe sau
prin array
16. Route::get('user', array('before' => array('auth', 'old'), function()
{ return 'You are authenticated and over 200 years old!';}));

17. Route::filter('age', function($route, $request, $value)

{ //});
Route::get('user', array('before' => 'age:200', function()
{ return 'Hello World';}));
- specificam parametrii pentru filter

18. Route::filter('log', function($route, $request, $response)

{ //});
- filtrul after primesc un $responce ca al treilea argument in filtru

19. Route::filter('admin', function()

 { // });
Route::when('admin/*', 'admin');
- cream un pattern pentru filtru astfel de fiecare data can dincercam sa
accesam admin/orice filtru va intra in actiune si va impune regulile lui

20. Route::filter('foo', 'FooFilter');

- daca vrem sa utilizam in loc de closure o clasa('FooFilter')
- by default functia filter va fi chemata din clasa respective
- daca vrem sa utilizam alta metoda vom declara astfel: 'FooFilter@foo';

21. Route::get('user/profile', array('as' => 'profile', function(){ //}));

- definim route (cu closure) pentru al folosi in URL

22. Route::get('user/profile', array('as' => 'profile', 'uses' =>

'UserController@showProfile'));
- definim un route cu actiune pentru al folosi in URl

23. URL::route('profile');
- definim un URL catre un route
24. Redirect::route('profile');
- redirectionam catre un route din alt route

25. Route::currentRouteName();
- accesam numele route care lucreaza momentan

26. Route::group(array('before' => 'auth'), function()

{
Route::get('/', function()
{ // Has Auth Filter });

Route::get('user/profile', function()
{ // Has Auth Filter });
});
- aplicam un filter unui grup de route

27. Route::group(array('namespace' => 'Admin'), function(){ //});

- toti contrrolerii din acest grup trebuie sa fie de namespace ‘Admin’

28. Route::group(array('domain' => '{account}.myapp.com'), function()

{
Route::get('user/{id}', function($account, $id)
{ // });
});
- laravel manipuleaza wildcards subdomain si trece parametrii wildcard din
domeniu
29. Route::model('user', 'User');
- User este modelul pe care il vom lega de filtrul user

30. Route::get('profile/{user}', function(User $user){ //});

- acest route va folosi user ca o instantiere a modelului User
- Asadar daca facem o cerere catre profile/1, utilizatorul cu ID = 1 va fi
utilizat in route
- daca numarul introdus nu corespunde vreunui user atunci vom afisa o
pagina de eroare

31. Route::model('user', 'User', function(){ throw new NotFoundHttpException;});

- putem introduce o pagina de eroare personalizata care sa rapsunda cererii
incazul in care nu avem utilizator cu numarul cerut

32. Route::bind('user', function($value, $route)

{ return User::where('name', $value)->first();});
- bind personalizeaza cautarea cu model astfel: model va cauta permanent
dupa id , insa cu bind legam termenul ‘user’ in orice route s-ar gasi ca
parametru, de functia closure din bind.

33. App::abort(404);
- utilizam pentru a chema o pagina cu eroare din route
 Request & Input
1. Input::get(‘name);
- Accesam valorile din form dupa name din form

2. Input::get(‘name’,’default_value’)
- Setam o valoare default in cazul in care in form nu exista un name specificat

3. Input::all();
- Stocam intro matrice toate valorile din form

4. if (Input::has('name'))
- verificam daca exista in matricea Input un element cu name specificat

5. Input::only('username', 'password')
- Returnam doar anumite valori din Input

6. Input::except('credit_card')
- Returnam toate valorile mai Input mai putin pe cele specificate

7. Input::get('products.0.name')
- Cand vrem sa accesam in interiorul matricei putem folosi .

8. Cand vrem sa returnam un view cu valori vom folosi View::make()->with

Cand folosim view pentru a prinde un raspuns sis a returnam coockie vom folosi:

$response = Response::make('Hello World');

$cookie = Cookie::make('name', 'value', $minutes));
$response->withCookie($cookie)

9. Cookie::queue($name, $value, $minutes);

- Utilizat pentru a transmite cookie in view in modul flash (o data dupa care sunt
sterse)

10. Cookie::forever('name', 'value');

- Setam valoare unui cookie pentru totdeauna

11. Cookie::get('name')
- Returnam valoarea unui cookie dupa nume

12. Input::flash()
- Trimitem o valoarea catre session pana la urmatoarea cerere

13. Input::flashOnly('username', 'email');

- Trimite doar anumite valori catre session

14. Input::flashExcept('password');
 - Trimite toate valorile mai putin cele specificate

15. Redirect::to('form')->withInput(Input::except('password'))
- Dupa validare vom trimite inputurile catre form din pagina precedenta

16. Input::old('username')
- Daca validarea nu a reusit , insa valoarea introdusa a fost corecta, vom folosi
aceasta metoda pentru a accesa vechea valoare introdusa

17. Input::file('photo')
- Returneaza un fisier incarcat

18. Input::hasFile('photo')
- Verifica daca exista un anumit input in form

19. Input::file('photo')->isValid()
- Verifica daca fisierul uplodad este valid

20. Input::file('photo')->move($destinationPath, $fileName);

- Muta un fisier din loactia tempopara in locatia specificata, al doilea argument e
optional si specifica noul nume al fisierului dup ace e mutat

21. Input::file('photo')->getRealPath()
- Returneaza calea fisierului incarcat

22. Input::file('photo')->getClientOriginalName()
- Returneaza numele original al fisierului incarcat

23. Input::file('photo')->getClientOriginalExtension()
- Returneaza extensia fisierului

24. Input::file('photo')->getSize()
- Returneaza marimea unui fisier incarcat

25. Input::file('photo')->getMimeType()
- Returneaza tipul fisierului incarcat

26. Request::path()
- Returneaza tot doar URL incarcat

27. Request::method()
- Returneza tipul de metoda utilizat

28. Request::isMethod('post')
- Verifica daca tipul metodei este ca cel specificat
29. Request::is('admin/*')
- Verifica daca o anumita cerere verifica un anumit patern

30. Request::url()
- Returneaza calea completa

31. Request::segment(1)
- Returneaza numele secgemtul din URL specificat ca argument

32. Request::header('Content-Type')
- Returneaza un anumit header

33. Request::server('PATH_INFO')
- Returneaza valori din $_SERVER

34. Request::secure()
- Verifica daca cererea este sigura (secure)

35. Request::ajax()
- Determina daca cererea utilizeaza ajax

36. Request::isJson()
- Determina daca cererea are continut JSON

37. Request::wantsJson()
- Determina daca cererea cere continut JSON

1. Request::format()
- Returneaza formatul rasounsului la cerere bazanduse pe header Accept

Controller

1. Route::get('foo', array('uses' => 'FooController@method','as' => 'name'));

 - fiecare controller trebuie sa extinda BaseController care la randul lui extinde
Controller asfel putem utiliza toate metodele disponibile. Controlerul poate fi
definit oriunde in aplicatie doar ca composer.json trebuie s ail poate accesa

2. URL::action(‘FooController@method’)
– pentru a accesa functionalitatea unei metode prin controller

3. action(‘FooController@method’)
– pentru a accesa functionalitatea unei motode prin controller (helper action)

4. URL::route(‘home’)
– pentru a acceas functionalitatea unei motode utilizsand numele routeului

5. Route::currentRouteAction()
– accesam numele metodei si al controlerului care este actionat momentan

6. class UserController extends BaseController {

public function __construct()
{ $this->beforeFilter('auth', array('except' => 'getLogin'));
$this->beforeFilter('csrf', array('on' => 'post'));
$this->afterFilter('log', array('only' =>
array('fooAction', 'barAction'))); }
}
- filtrele pot fi adaugate atat la route cat si in interiorul controlerului pentru a fi aplicat
doar asupra unei metode

7. php artisan controller:make PhotoController

- in CLI va creea un controller cu un colier plate (schite metodeloer utilizate
pentru CRUD)

8. Route::resource('photo', 'PhotoController');
- defineste un route care creeaza mai multe route care vor controla mai multe
actiuni asupra resursei atribuite.
Verb Path Action Route Name

GET /resource index resource.index

GET /resource/create create resource.create

POST /resource store resource.store

GET /resource/{resource} show resource.show

GET /resource/{resource}/edit edit resource.edit

Verb Path Action Route Name

PUT/PATCH /resource/{resource} update resource.update

DELETE /resource/{resource} destroy resource.destroy

9. php artisan controller:make PhotoController --only=index,show

php artisan controller:make PhotoController --except=index
- putem specifica daca dorim sa definim dora numiyte metode introun anumit
controller

10. Route::resource('photo', 'PhotoController',

array('only' => array('index', 'show')));
Route::resource('photo', 'PhotoController',
array('except' => array('create', 'store', 'update', 'destroy')));
- putem specific ace metode folosim si din controller

11. Route::resource('photo', 'PhotoController',

array('names' => array('create' => 'photo.build')));
- daca vrem sa numim altfel metodele din controller

12. public function missingMethod($parameters = array())

{ // }
- Putem defini o metoda care va fi chemata daca nu este gasita metoda ceruta.

RESPONSES

34. $response = Response::make($contents, $statusCode);

$response->header('Content-Type', $value);
return $response;
 - daca vrem sa trimitem un raspuns personalizat in browser

35. Response::view('hello')->header('Content-Type', $type);

- returnam un View cu un header personalizat

36. $cookie = Cookie::make('name', 'value');

$Response = Response::make($content);
return $response ->withCookie($cookie);
- incarcam un view cu coockies

37. return Redirect::to(‘URL’)

- redirectionam catre un URL

38. return Redirect::to('URL')->with('message', 'Login Failed')

- redirectionam catre un URL cu variabile
39. return Redirect::route('login');
- returneaza catre un anumit route

40. return Redirect::route('profile', array(1));

- returneaza catre un anumit route cu parametrii

41. return Redirect::route('profile', array('user' => 1));

- returneaza catre un anumit route cu parametrii numiti

42. return Redirect::action('HomeController@index')

- returneaza catre o metoda a unui controller

43. return Redirect::action('UserController@profile', array(1));

- returneaza catre o metoda a unui controller cu parametrii

44. return Redirect::action('UserController@profile', array('user' => 1));

- returneaza o catre o metoda a unuicontroller cu parametrii numiti

VIEWS

45. @extends se foloseste in view pentru a arata ce pattern view foloseste

46. @section
@stop
 -folosit in view pentru a incarca sectiunea definita in pattern view in @section
@show

47. @section
@show
- defineste o sectiune in template unde va fi introdus text in view.
- Poate contine si un text in template care va fi mostenit in view daca se foloseste
@parent in view
- Folosit pentru sectiuni mari de text
-

48. @yield
- defineste o sectiune in template unde va fi introdus text in view
- putem defini un text default care va fi introdus in view daca nu exista in template
aceasta sectiune
- utilizat pentru a introduce in view sectiuni compacte precum: title, description
,css, javascript

49. Route::get('/',
function(){ return View::make('greeting', array('name' =>'Taylor'));});
- returnam un view in care introducem variabile

50. View::make('greeting')->with('name', 'Steve');

- returnam un view in care introducem variabile
- daca vrem sa trecem mai multe variabile le vom define in al doilea
parametru sub frma de matrice

51. View::make('greeting')->withName('steve')
- returnam un view in care introducem variabile

52. View::make('greeting')->nest('child', 'child.view');

View::make('greeting')->nest('child', 'child.view', $data);
- returnam un view intrun alt view; primul argument al nest devine variabila
in view iar al doilea parametru este calea view care va fi incarcat view
current;

53. <?php echo $child; ?>

- pentru a incarca in view variabila din view
54. View::share('name', 'Steve');
- daca vrem ca o anumita bucata de informatie sa fie vizibila in toate view
(cream o variabila globala)

55. View::composer('profile', function($view)

{ $view->with('count', User::count()); });
 - de fiecare data cand vom cere in browser un view al carui route este
‘profile’ inainte ca acel view sa fie afisat se va executa callback definita in
view::composer asupra variabilei din callbak

56. View::composer('profile', 'ProfileComposer');

- putem define in loc de un callback o clasa care va contine functiile din
calback
class ProfileComposer {
public function compose($view)
{ $view->with('count', User::count()); }}
- clasa va contine functionalitatea

57. View::composers(array(
'AdminComposer' => array('admin.index', 'admin.profile'),
'UserComposer' => 'user',
));
- putem define mai multi composeri simultan

58. View::creator('profile', function($view)

{
$view->with('count', User::count());
});
- functioneaza ca si View::composer doar ca sunt lansati imediat ce viewul a
fost instantiate

59. return Response::json(array('name' => 'Steve', 'state' => 'CA'));

- creaza un raspuns json
60. return Response::download( calea fisierului, numele fisierului, tipul_fisierului);
- creaza un fisier de download ;
- calea fisierului e de genul: public_path().’fisier.pdf’
- numele fisierului e de genul: nume.pdf
- tipul fisierului e de genul: array(‘Content_type’=>’application/pdf’)

61. Response::macro('caps', function($value)

{ return Response::make(strtoupper($value));});
- definim un raspuns personalizat care va fi folosit in route si controller prin
chemarea raspunsului:

62. return Response::caps('foo');

- Response::macro trebuie sa se gaseasca in unul din fisierele din folderol start
in functie de mediul in care lucram.
- Daca vrem sa ne bucuram de functionalitatea functie macro atunci vom chema
Response::caps() in controller sau route.
Errors and Loggin

1. $logFile = 'laravel.log';
 Log::useDailyFiles(storage_path().'/logs/'.$logFile);
- Default laravel salveaza toate erorile intrun singur fisier localizat in
storage/log/laravel.log. Daca dorim ca erorile sa le salvam in fisierele separate
in functie de zi tot in storage/log vom folosi codul de mai sus in
app/start/global.

2. Daca vrem sa dezactivam afisarea de erori (ceea ce e indicat in modul productie) vom
seta optiunea debug ca FLASE in app/config/app.php

3. App::error(function(Exception $exception){ Log::error($exception); });

- Eroarea de baza

4. App::error(function(RuntimeException $exception){ // Handle the exception...});

- Putem defini handler care sa prinda erori in timpul executiei

5. App::error(function(InvalidUserException $exception)
{ Log::error($exception);
return 'Sorry! Something is wrong with this account!';
});
- Daca un handler returneaza un rasouns, acel raspuns va fi afisat in browser si nici
un alt handler nu va mai fi chemat

6. App::fatal(function($exception){ // });
- Daca vrem sa prindem erori fatale atunci putem folosi App:fatal
- Daca definim mai multe handler pentru exceptii ele trebuie sa fie definite de la cel
mai general la cel mai specific
- Handelrele pot fi definite in start/global.php iar daca acesta devine prea aglomerat
putem creea un fisier app/errors.php

7. App::abort(403, 'Unauthorized action.');

- Anumite exceptii descriu erori de cod HTTP, pentru asta folosim codul App::abort
- Al doilea parametru este textul pe care dorim sa il afisam

8. App::missing(function($exception)
{ return Response::view('errors.missing', array(), 404);});
- Daca vrem sa definim o pagina 404 personalizata

9. Log::info('This is some useful information.', array('context' => 'Other helpful

information'));
- Putem adauga prorpiile informatii in fisierul de aerori din storage/log prin
umratoarele functii : info, debug, notice, warning, error, critical, alert. Folosim
metoda specififcc fiecarei erori.
- Al doilea parametru este o matrice de valori pe care le piutem aduaga in eroare

10. Log::listen(function($level, $message, $context)

- Inregistram un eveniment care va prelua toate mesajele trecute in log
1. Log::getMonolog();
- Accesam instantierea Monolog utilizata de Laravel
{ // });
CACHE DB

Vom returna din DB toate question si vor fi introduce in cache unde vor ramane 60
minute. Astfel in urmatoarea ora acest query ramanme in cache si toate cererile catre baza
de date vor lua informatia de aici.
E util atunci cand nu modificam baza de date frecvent.
$questions = Question::remember(60)->get();
Simple Laravel CRUD with Resource
Controllers
Creating, reading, updating, and deleting resources is used in pretty much every
application. Laravel helps make the process easy using resource controllers. Resource
Controllers can make life much easier and takes advantage of some cool Laravel routing
techniques. Today, we’ll go through the steps necessary to get a fully functioning CRUD
application using resource controllers.
For this tutorial, we will go through the process of having an admin panel to create, read,
update, and delete (CRUD) a resource. Let’s use nerds as our example. We will also make
use of Eloquent ORM.

This tutorial will walk us through:

 Setting up the database and models

 Creating the resource controller and its routes

 Creating the necessary views
 Explaining each method in a resource controller

To get started, we will need the controller, the routes, and the view files.

Getting our Database Ready

Nerd Migration

(This sounds like a bunch of nerds moving south for the winter). We need to set up a quick
database so we can do all of our CRUD functionality. In the command line in the root
directory of our Laravel application, let’s create a migration.

php artisan migrate:make create_nerds_table --table=nerds --create

This will create our nerd migration in app/database/migrations. Open up that file and let’s add
name, email, and nerd_level fields.

// app/database/migrations/####_##_##_######_create_nerds_table.php

<?php

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateNerdsTable extends Migration {

/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('nerds', function(Blueprint $table)
{
$table->increments('id');

$table->string('name', 255);
$table->string('email', 255);
$table->integer('nerd_level');

$table->timestamps();
});
}

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

Now from the command line again, let’s run this migration. Make sure your database
settings are good in app/config/database.php and then run:
php artisan migrate

Our database now has a nerds table to house all of the nerds we CRUD (create, read, update,
and delete). Read more about migrations at the Laravel docs.

Eloquent Model for the Nerds

Now that we have our database, let’s create a simple Eloquent model so that we can access
the nerds in our database easily. You can read about Eloquent ORM and see how you can use
it in your own applications.

In the app/models folder, let’s create a Nerd.php model.

// app/models/Nerd.php

<?php

class Nerd extends Eloquent

{

That’s it! Eloquent can handle the rest. By default, this model will link to our nerdstable and
and we can access it later in our controllers.

Creating the Controller

From the official Laravel docs, on resource controllers, you can generate a resource
controller using the artisan tool.

Let’s go ahead and do that. This is the easy part. From the command line in the root
directory of your Laravel project, type:

php artisan controller:make NerdController

This will create our resource controller with all the methods we need.

// app/controllers/NerdController.php

<?php
class NerdController extends \BaseController {

/**
* Display a listing of the resource.
*
* @return Response
*/
public function index()
{
//
}

/**
* Show the form for creating a new resource.
*
* @return Response
*/
public function create()
{
//
}

/**
* Store a newly created resource in storage.
*
* @return Response
*/
public function store()
{
//
}

/**
* Display the specified resource.
*
 * @param int $id
* @return Response
*/
public function show($id)
{
//
}

/**
* Show the form for editing the specified resource.
*
* @param int $id
* @return Response
*/
public function edit($id)
{
//
}

/**
* Update the specified resource in storage.
*
* @param int $id
* @return Response
*/
public function update($id)
{
//
}

/**
* Remove the specified resource from storage.
*
* @param int $id
* @return Response
 */
public function destroy($id)
{
//
}

Setting Up the Routes

Now that we have generated our controller, let’s make sure our application has the routes
necessary to use it. This is the other easy part (they actually might all be easy parts). In
your routes.php file, add this line:

// app/routes.php

<?php

Route::resource('nerds', 'NerdController');

This will automatically assign many actions to that resource controller. Now if you, go to
your browser and view your application at example.com/nerds, it will correspond to the proper
method in your NerdController.

Actions Handled By the Controller

HTTP Verb Path (URL) Action (Method) Route Name

GET /nerds index nerds.index

GET /nerds/create create nerds.create

POST /nerds store nerds.store

GET /nerds/{id} show nerds.show

GET /nerds/{id}/edit edit nerds.edit

PUT/PATCH /nerds/{id} update nerds.update

HTTP Verb Path (URL) Action (Method) Route Name

DELETE /nerds/{id} destroy nerds.destroy

Tip: From the command line, you can run php artisan routes to see all the routes associated with your
application.

The Views
Since only four of our routes are GET routes, we only need four views. In our app/views folder,
let’s make those views now.

 app
o views
 nerds
 index.blade.php
 create.blade.php
 show.blade.php
 edit.blade.php

Making It All Work Together

Now we have our migrations, database, and models, our controller and routes, and
our views. Let’s make all these things work together to build our application. We are going to
go through the methods created in the resource controller one by one and make it all work.

Showing All Resources nerds.index

Description URL Controller View File

Function

Default page for showing all GET example.com/nerds index() app/views/nerds/index.blade.php

the nerds.

Controller Function index()

In this function, we will get all the nerds and pass them to the view.

// app/controllers/NerdController.php
<?php

...

/**
* Display a listing of the resource.
*
* @return Response
*/
public function index()
{
// get all the nerds
$nerds = Nerd::all();

// load the view and pass the nerds

return View::make('nerds.index')
->with('nerds', $nerds);
}

...

The View app/views/nerds/index.blade.php

Now let’s create our view to loop over the nerds and display them in a table. We like
using Twitter Bootstrap for our sites, so the table will use those classes.

<!-- app/views/nerds/index.blade.php -->

<!DOCTYPE html>
<html>
<head>
<title>Look! I'm CRUDding</title>
 <link rel="stylesheet"
href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css">
</head>
<body>
<div class="container">

<nav class="navbar navbar-inverse">

<div class="navbar-header">
<a class="navbar-brand" href="{{ URL::to('nerds') }}">Nerd
Alert</a>
</div>
<ul class="nav navbar-nav">
<li><a href="{{ URL::to('nerds') }}">View All Nerds</a></li>
<li><a href="{{ URL::to('nerds/create') }}">Create a Nerd</a>
</ul>
</nav>

<h1>All the Nerds</h1>

<!-- will be used to show any messages -->

@if (Session::has('message'))
<div class="alert alert-info">{{ Session::get('message') }}</div>
@endif

<table class="table table-striped table-bordered">

<thead>
<tr>
<td>ID</td>
<td>Name</td>
<td>Email</td>
<td>Nerd Level</td>
<td>Actions</td>
</tr>
</thead>
<tbody>
@foreach($nerds as $key => $value)
 <tr>
<td>{{ $value->id }}</td>
<td>{{ $value->name }}</td>
<td>{{ $value->email }}</td>
<td>{{ $value->nerd_level }}</td>

<!-- we will also add show, edit, and delete buttons -->
<td>

<!-- delete the nerd (uses the destroy method

DESTROY /nerds/{id} -->
<!-- we will add this later since its a little more
complicated than the other two buttons -->

<!-- show the nerd (uses the show method found at

GET /nerds/{id} -->
<a class="btn btn-small btn-success"
href="{{ URL::to('nerds/' . $value->id) }}">Show this Nerd</a>

<!-- edit this nerd (uses the edit method found at

GET /nerds/{id}/edit -->
<a class="btn btn-small btn-info"
href="{{ URL::to('nerds/' . $value->id . '/edit') }}">Edit this Nerd</a>

</td>
</tr>
@endforeach
</tbody>
</table>

</div>
</body>
</html>

We can now show all of our nerds on a page. There won’t be any that show up currently
since we haven’t created any or seeded our database with nerds. Let’s move on to the form
to create a nerd.
Creating a New Resource nerds.create

Description URL Controller View File

Function

Show the form to create a GET example.com/nerds/create create() app/views/nerds/create.blade.php

new nerd.

Controller Function create()

In this function, we will show the form for creating a new nerd. This form will be processed
by the store() method.

// app/controllers/NerdController.php

<?php

...

/**
* Show the form for creating a new resource.
*
* @return Response
*/
public function create()
{
 // load the create form (app/views/nerds/create.blade.php)
return View::make('nerds.create');
}

...

The View app/views/nerds/create.blade.php

<!-- app/views/nerds/create.blade.php -->

<!DOCTYPE html>
<html>
<head>
<title>Look! I'm CRUDding</title>
<link rel="stylesheet"
href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css">
</head>
<body>
<div class="container">

<nav class="navbar navbar-inverse">

<div class="navbar-header">
<a class="navbar-brand" href="{{ URL::to('nerds') }}">Nerd
Alert</a>
</div>
<ul class="nav navbar-nav">
<li><a href="{{ URL::to('nerds') }}">View All Nerds</a></li>
<li><a href="{{ URL::to('nerds/create') }}">Create a Nerd</a>
</ul>
</nav>

<h1>Create a Nerd</h1>

<!-- if there are creation errors, they will show here -->
{{ HTML::ul($errors->all()) }}
{{ Form::open(array('url' => 'nerds')) }}

<div class="form-group">
{{ Form::label('name', 'Name') }}
{{ Form::text('name', Input::old('name'), array('class' => 'form-
control')) }}
</div>

<div class="form-group">
{{ Form::label('email', 'Email') }}
{{ Form::email('email', Input::old('email'), array('class' =>
'form-control')) }}
</div>

<div class="form-group">
{{ Form::label('nerd_level', 'Nerd Level') }}
{{ Form::select('nerd_level', array('0' => 'Select a Level', '1'
=> 'Sees Sunlight', '2' => 'Foosball Fanatic', '3' => 'Basement Dweller'),
Input::old('nerd_level'), array('class' => 'form-control')) }}
</div>

{{ Form::submit('Create the Nerd!', array('class' => 'btn btn-primary'))

}}

{{ Form::close() }}

</div>
</body>
</html>

We will add the errors section above to show validation errors when we try tostore() the
resource.

Tip: When using {{ Form::open() }}, Laravel will automatically create a hidden input field with a token to
protect from cross-site request forgeries. Read more at the Laravel docs.
We now have the form, but we need to have it do something when it the submit button gets
pressed. We set this form’s action to be a POST to example.com/nerds. The resource
controller will handle this and automatically route the request to the store() method. Let’s
handle that now.
Storing a Resource store()

Description URL Controller Function View File

Process the create form submit and save the nerd to POST example.com/nerds store() NONE
the database.

As you can see from the form action and the URL, you don’t have to pass anything extra into
the URL to store a nerd. Since this form is sent using the POST method, the form inputs will
be the data used to store the resource.

To process the form, we’ll want to validate the inputs, send back error messages if they
exist, authenticate against the database, and store the resource if all is good. Let’s dive in.

Controller Function store()

// app/controllers/NerdController.php

<?php

...

/**
* Store a newly created resource in storage.
*
* @return Response
*/
public function store()
{
// validate
// read more on validation at http://laravel.com/docs/validation
$rules = array(
'name' => 'required',
'email' => 'required|email',
'nerd_level' => 'required|numeric'
);
$validator = Validator::make(Input::all(), $rules);
 // process the login
if ($validator->fails()) {
return Redirect::to('nerds/create')
->withErrors($validator)
->withInput(Input::except('password'));
} else {
// store
$nerd = new Nerd;
$nerd->name = Input::get('name');
$nerd->email = Input::get('email');
$nerd->nerd_level = Input::get('nerd_level');
$nerd->save();

// redirect
Session::flash('message', 'Successfully created nerd!');
return Redirect::to('nerds');
}
}

...

If there are errors processing the form, we will redirect them back to the create form with
those errors. We will add them in so the user can understand what went wrong. They will
show up in the errors section we setup earlier.

Now you should be able to create a nerd and have them show up on the main page! Navigate
to example.com/nerds and there they are. All that’s left is showing a single nerd, updating,
and deleting.
Showing a Resource show()

Description URL Controller Function View File

Show one of the GET example.com/nerds/{id} show() app/views/nerds/show.blade.php

nerds.

Controller Function show()

// app/controllers/NerdController.php

<?php

...

/**
* Display the specified resource.
*
* @param int $id
* @return Response
*/
public function show($id)
{
 // get the nerd
$nerd = Nerd::find($id);

// show the view and pass the nerd to it

return View::make('nerds.show')
->with('nerd', $nerd);
}

...

The View app/views/nerds/show.blade.php

<!-- app/views/nerds/show.blade.php -->

<!DOCTYPE html>
<html>
<head>
<title>Look! I'm CRUDding</title>
<link rel="stylesheet"
href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css">
</head>
<body>
<div class="container">

<nav class="navbar navbar-inverse">

<div class="navbar-header">
<a class="navbar-brand" href="{{ URL::to('nerds') }}">Nerd
Alert</a>
</div>
<ul class="nav navbar-nav">
<li><a href="{{ URL::to('nerds') }}">View All Nerds</a></li>
<li><a href="{{ URL::to('nerds/create') }}">Create a Nerd</a>
</ul>
</nav>
<h1>Showing {{ $nerd->name }}</h1>

<div class="jumbotron text-center">

<h2>{{ $nerd->name }}</h2>
<p>
<strong>Email:</strong> {{ $nerd->email }}<br>
<strong>Level:</strong> {{ $nerd->nerd_level }}
</p>
</div>

</div>
</body>
</html>

Editing a Resource edit()

Description URL Controller View File

Function

Pull a nerd from the GET example.com/nerds/ edit() app/views/nerds/edit.blade.php

database and allow editing. {id}/edit

To edit a nerd, we need to pull them from the database, show the creation form, but populate
it with the selected nerd’s info. To make life easier, we will use form model binding. This
allows us to pull info from a model and bind it to the input fields in a form. Just makes it
easier to populate our edit form and you can imagine that when these forms start getting
rather large this will make life much easier.
Controller Function edit()

// app/controllers/NerdController.php

<?php

...

/**
* Show the form for editing the specified resource.
*
* @param int $id
* @return Response
*/
public function edit($id)
{
// get the nerd
$nerd = Nerd::find($id);

// show the edit form and pass the nerd

return View::make('nerds.edit')
->with('nerd', $nerd);
}

...

The View app/views/nerds/edit.blade.php

<!-- app/views/nerds/edit.blade.php -->

<!DOCTYPE html>
<html>
<head>
<title>Look! I'm CRUDding</title>
 <link rel="stylesheet"
href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css">
</head>
<body>
<div class="container">

<nav class="navbar navbar-inverse">

<div class="navbar-header">
<a class="navbar-brand" href="{{ URL::to('nerds') }}">Nerd
Alert</a>
</div>
<ul class="nav navbar-nav">
<li><a href="{{ URL::to('nerds') }}">View All Nerds</a></li>
<li><a href="{{ URL::to('nerds/create') }}">Create a Nerd</a>
</ul>
</nav>

<h1>Edit {{ $nerd->name }}</h1>

<!-- if there are creation errors, they will show here -->
{{ HTML::ul($errors->all()) }}

{{ Form::model($nerd, array('route' => array('nerds.update', $nerd->id),

'method' => 'PUT')) }}

<div class="form-group">
{{ Form::label('name', 'Name') }}
{{ Form::text('name', null, array('class' => 'form-control')) }}
</div>

<div class="form-group">
{{ Form::label('email', 'Email') }}
{{ Form::email('email', null, array('class' => 'form-
control')) }}
</div>

<div class="form-group">
 {{ Form::label('nerd_level', 'Nerd Level') }}
{{ Form::select('nerd_level', array('0' => 'Select a Level', '1'
=> 'Sees Sunlight', '2' => 'Foosball Fanatic', '3' => 'Basement Dweller'),
null, array('class' => 'form-control')) }}
</div>

{{ Form::submit('Edit the Nerd!', array('class' => 'btn btn-

primary')) }}

{{ Form::close() }}

</div>
</body>
</html>

Note that we have to pass a method of PUT so that Laravel knows how to route to the
controller correctly.

Updating a Resource update()

Description URL Controller Function View File

Process the create form submit and save the nerd to PUT example.com/nerds update() NONE
the database.

This controller method will process the edit form. It is very similar to store(). We
willvalidate, update, and redirect.

Controller Function update()

// app/controllers/NerdController.php

<?php

...

/**
* Update the specified resource in storage.
*
 * @param int $id
* @return Response
*/
public function update($id)
{
// validate
// read more on validation at http://laravel.com/docs/validation
$rules = array(
'name' => 'required',
'email' => 'required|email',
'nerd_level' => 'required|numeric'
);
$validator = Validator::make(Input::all(), $rules);

// process the login

if ($validator->fails()) {
return Redirect::to('nerds/' . $id . '/edit')
->withErrors($validator)
->withInput(Input::except('password'));
} else {
// store
$nerd = Nerd::find($id);
$nerd->name = Input::get('name');
$nerd->email = Input::get('email');
$nerd->nerd_level = Input::get('nerd_level');
$nerd->save();

// redirect
Session::flash('message', 'Successfully updated nerd!');
return Redirect::to('nerds');
}
}

...
Deleting a Resource destroy()

Description URL Controller View File

Function

Process the create form submit and save the DELETE example.com/nerds/ destroy() NONE
nerd to the database. {id}

The workflow for this is that a user would go to view all the nerds, see a delete button, click
it to delete. Since we never created a delete button in ourapp/views/nerds/index.blade.php, we
will create that now. We will also add a notification section to show a success message.

We have to send the request to our application using the DELETE HTTP verb, so we will
create a form to do that since a button won’t do.

Alert: The DELETE HTTP verb is used when accessing the nerds.destroy route. Since you can’t just create
a button or form with the method DELETE, we will have to spoof it by creating a hidden input field in our
delete form.

The View app/views/nerds/index.blade.php

<!-- app/views/nerds/index.blade.php -->

...

@foreach($nerds as $key => $value)

<tr>
<td>{{ $value->id }}</td>
<td>{{ $value->name }}</td>
<td>{{ $value->email }}</td>
<td>{{ $value->nerd_level }}</td>

<!-- we will also add show, edit, and delete buttons -->
<td>

<!-- delete the nerd (uses the destroy method

DESTROY /nerds/{id} -->
<!-- we will add this later since its a little more
complicated than the other two buttons -->
{{ Form::open(array('url' => 'nerds/' . $value->id,
'class' => 'pull-right')) }}
 {{ Form::hidden('_method', 'DELETE') }}
{{ Form::submit('Delete this Nerd',
array('class' => 'btn btn-warning')) }}
{{ Form::close() }}

<!-- show the nerd (uses the show method found at

GET /nerds/{id} -->
<a class="btn btn-small btn-success"
href="{{ URL::to('nerds/' . $value->id) }}">Show this Nerd</a>

<!-- edit this nerd (uses the edit method found at

GET /nerds/{id}/edit -->
<a class="btn btn-small btn-info"
href="{{ URL::to('nerds/' . $value->id . '/edit') }}">Edit this Nerd</a>

</td>
</tr>
@endforeach

...

Now when we click that form submit button, Laravel will use the nerds.destroy route and we
can process that in our controller.

Controller Function destroy()

// app/controllers/NerdController.php

<?php

...

/**
* Remove the specified resource from storage.
*
* @param int $id
 * @return Response
*/
public function destroy($id)
{
// delete
$nerd = Nerd::find($id);
$nerd->delete();

// redirect
Session::flash('message', 'Successfully deleted the nerd!');
return Redirect::to('nerds');
}

...

Conclusion
That’s everything! Hopefully we covered enough so that you can understand how resource
controllers can be used in all sorts of scenarios. Just create the controller, create the single
line in the routes file, and you have the foundation for doing CRUD.

As always, let us know if you have any questions or comments. We’ll be expanding more on
Laravel in the coming articles so if there’s anything specific, throw it in the comments or
email us.