Construiți aplicații Web de la zero cu Laravel Filtre, validări și fișiere

În această mini-serie Nettuts +, vom construi o aplicație web de la zero, în timp ce vom scufunda într-un nou cadru PHP care absoarbe rapid aburi, numit Laravel.

În această lecție, vom învăța despre câteva funcții Laravel foarte utile: filtre și atât bibliotecile de validare și fișiere.

Revizuire

Bine ați venit înapoi la aplicațiile noastre Web de la Scratch cu seria Laravel! În cel de-al doilea tutorial al mini-seriei noastre, am învățat multe despre implementarea ORM a Laravel:

Unele fundaluri pe "Modele"
Ce este ORM elocvent
Cum se configurează configurația bazei de date Laravel
Cum să creați primul dvs. model Laravel
Funcțiile de bază ale bibliotecilor Auth și Input
Folosind ORM elocvent într-o vedere

Dacă nu ați văzut-o încă, vă recomand să examinați prima și a doua parte a mini-serie - aceasta va face mult mai ușor să urmăriți împreună, pe măsură ce construim aplicația noastră de testare, Instapics, prin fiecare parte.

Deci sa începem!

1 - Filtre Laravel

Pe scurt, filtrele sunt funcții pe care le putem rula pe rute inainte de sau după ciclul cererii. Este util în special pentru lucruri precum autentificarea și logarea. Pentru a înregistra un filtru, trebuie să adăugăm ceva de genul: application / routes.php fişier:

Route :: filter ('myfilter', funcția () // Ce vrei să facă filtrul);

După ce înregistrăm filtrul, trebuie să îl atașăm la un traseu, după cum urmează:

Traseu :: orice ('/', array ('înainte' => 'filtru', funcție () // Ce vrei să facă traseul));

În exemplul de mai sus, myfilter va declanșa la toate cererile pagina de index (adică. /). Să presupunem că am vrut să implementăm un filtru de autentificare pentru tablou de bord traseu:

Traseu :: filtru ('auth', functie () if (Auth :: guest ()) returneaza Redirect :: to ('home');); Route :: orice ('dashboard', array ('înainte' => 'auth, function () retur View :: make (' dashboard '););

Codul de mai sus va redirecționa toate solicitările neautorizate la tablou de bord traseu spre Acasă traseu.

Filtre globale

În mod implicit, Laravel include două filtre, inainte de și după, care rulează înainte și după fiecare cerere pe o aplicație. Acestea sunt de obicei în cazul în care vă așezați lucruri, cum ar fi înregistrarea cererilor, adăugarea de active globale sau lansarea evenimentelor globale. De exemplu:

Route :: filtru ('după', funcție ($ răspuns)) Log :: write ('request', 'Request finished'). \ nRequest Information: \ n '. var_export (Intrare :: get (), true)););

Acest lucru scrie a cerere introduceți mesajul de jurnal în jurnalul aplicației și listează orice intrare din cerere.

Grupuri de traseu

Dacă găsiți că aplicați același filtru pe mai multe rute, puteți utiliza Grupuri de traseu să le grupezi împreună și să reduci repetarea codului:

Route :: filtru ('admin_auth', function () if (Auth :: guest () || Auth :: user () -> isAdmin ())  ); Route :: grup (array ('înainte' => 'admin_auth'), function () Route :: get ('admin', function () : get ('useradmin', function () retur View :: make ('useradmin');););

Controler Filtre

Pentru aplicații (cum ar fi propriile noastre Instapics) care folosesc controlorii, putem aplica filtrele folosind $ This-> filtru () funcția în constructorul controlerului:

funcția publică __construct () $ this-> filter ('înainte', 'auth');

Aceste filtre, cum ar fi rutele, pot fi de asemenea personalizate pentru a se aplica numai anumitor verbe HTTP și acțiunilor specifice ale controlorilor:

funcția publică __construct () // call 'log_download' filtru pentru toate cererile de descărcare / fișier GET $ this-> filter ('după', 'log_download') -> numai (array (' obține'); // apela filtrul "auth_download" pentru toate cererile de descărcare / *, cu excepția acțiunii 'queue' $ this-> filter ('înainte', 'auth_download') -> except (array ('queue'));

2 - Validarea Laravel

Validarea încorporată a lui Laravel facilitează aplicarea validării la orice serie de valori, mai exact, formularul de intrare. Pentru a face acest lucru, pur și simplu trebuie să construiți două matrice:

$ intrare - aceasta este o matrice asociativă a valorilor pe care doriți să le validați.
norme $ - aceasta este o matrice asociativă (cu chei care sunt aceleași cu matricea de intrare $) care enumeră regulile de validare.

// Obținerea contribuției noastre din biblioteca de intrare $ input = Input :: all (); // Creați regulile de validare $ rules = array ('email' => 'obligatoriu | email | unic: utilizatori', 'parolă' => 'necesar'); // Obținerea unei instanțe de validare $ pentru eroarea noastră de verificare $ validation = Validator :: make ($ input, $ rules); // Verificați dacă validarea a reușit în cazul în care ($ validation-> fails ()) // face ceva cu mesajele de eroare de la validarea $ $ instanță $ validation-> errors;

Regulile de validare

Mai jos este o listă de reguli de validare care pot fi utilizate cu biblioteca de validare Laravel. Ca și în exemplul de mai sus, puteți să le amestecați și să le potriviți separându-le cu o conductă ("|„):

necesar - valoarea ar trebui să fie prezentă în matricea de intrare
```
 'email' => 'necesar'
```
alfa - valoarea ar trebui să fie formată numai din caractere alfabetice
```
 'full_name' => 'alfa'
```
alpha_num - valoarea trebuie să conțină numai caractere alfanumerice
```
 'username' => 'alpha_num'
```
alpha_dash - valoarea trebuie să fie formată numai din cifre alfanumerice, liniuțe și / sau sublinieri
```
 'user_name' => 'alpha_dash'
```
mărimea - valoarea ar trebui să fie de o anumită lungime sau ar trebui să fie egală cu valoarea numerică
```
 'api_key' => 'dimensiune: 10'
```
```
 'order_count' => 'dimensiune: 10'
```
între - valoarea este inclusă între un interval specificat
```
 'order_count' => 'între: 1,100'
```
min - valoarea este cel puțin dată
```
 'order_count' => 'min: 1'
```
max - valoarea este egală sau mai mică decât cea dată
```
 'order_count' => 'max: 100'
```
numeric - valoarea este numerică
```
 'order_count' => 'numeric'
```
întreg - valoarea este un număr întreg
```
 'order_count' => 'integer'
```

în - valoarea este cuprinsă în termenul dat

 'tshirt_size' => 'în: xsmall, mic, mediu, mare, xlarge'

nu în - valoarea nu este dată

 'tshirt_size' => 'not_in: xsmall, xlarge'

confirmat - va verifica dacă cheie_confirmare există și este egală cu valoarea
```
 'parola' => 'confirmat'
```
Aceasta va verifica dacă Confirmarea parolei valoarea există și este egală cu parola
admis - acest lucru va verifica dacă valoarea este setată la "da" sau 1. Utilă pentru casetele de selectare
```
 'terms_of_service' => 'acceptat'
```
la fel - valoarea este aceeași cu valoarea atributului dat
```
 'parola' => 'același: confirm_password'
```
diferit - valoarea trebuie să fie diferită de valoarea atributului dat
```
 'parola' => 'diferit: old_password'
```
Meci - valoarea trebuie să se potrivească cu expresia regulată dată
```
 'user_name' => 'potrivire: / [a-zA-Z0-9] * /'
```
unic - verifică unicitatea valorii din tabelul dat.
```
 'user_name' => 'unic: utilizatori'
```
O coloană dată este de asemenea acceptată dacă numele coloanei nu este același cu numele atributului.
```
 // dacă coloana din tabelul utilizatorilor este username, // putem furniza acest lucru în textul dat astfel: 'user_name' => 'unic: users, username'
```
Există momente când vrem să verificăm unicitatea, dar să ignorăm o anumită înregistrare (de obicei, înregistrarea asociată cu utilizatorul curent). Putem face acest lucru adăugând oa treia dată, care ar trebui să fie ID-ul acelei înregistrări în tabel.
```
 // ID 10 este ID-ul înregistrării utilizatorului curent 'user_name' => 'unic: users, user_name, 10'
```
există - valoarea ar trebui să existe într-un tabel
```
 'category' => 'există: categorii'
```
Aceasta acceptă și o secundă dată dacă vrem să schimbăm numele coloanei pentru a verifica.
```
 'category' => 'există: categorii, category_name'
```
inainte de - valoarea ar trebui să fie o dată înainte de data dată
```
 'publish_date' => 'înainte de: 2012-07-14'
```
după - valoarea ar trebui să fie dată după data dată
```
 'publish_date' => 'după: 2012-07-14'
```
e-mail - valoarea ar trebui să fie într-un format de e-mail valid
```
 'subscriber_email' => 'email'
```
URL-ul - valoarea este într-un format url valid
```
 'github_profile' => 'url'
```
active_url - valoarea este într-un format valid url ȘI este activă
```
 'github_profile' => 'active_url'
```
mimi - verifică tipul de mime al unui fișier încărcat. Puteți utiliza orice valoare de tip mime din config / mimes.php fişier
```
 'avatar' => 'mimes: jpg, gif, png, bmp'
```
imagine - fișierul ar trebui să fie o imagine
```
 'avatar' => 'imagine'
```
De asemenea, puteți utiliza funcția max validator aici pentru a verifica dimensiunea unui fișier în kilobyte
```
 'avatar' => 'imagine | max: 100'
```

Eroare de manipulare

Odată ce apelați Validator-> eșuează () sau Validator-> trece () metodă, biblioteca colectează toate erorile dintr-o clasă accesibilă prin intermediul acesteia Validator-> erori. Veți putea apoi să recuperați aceste erori cu unele funcții din erori clasă. Laravel oferă câteva funcții interesante pentru automatizarea procesării erorilor care se potrivește în majoritatea scenariilor POST / REDIRECT / GET:

clasa Register_Controller extinde Base_Controller public $ restful = true; funcția publică get_index () retur View :: make ('register.index');  funcția publică post_index () $ rules = array ('email' => 'obligatoriu | email | unic: utilizatori', 'parola' => 'confirmat'); Validarea $ = Validator :: make (Input :: get (), $ rules); dacă ($ validation-> fails ()) // Trimite obiectul validare $ la redirecționarea paginii Redirect :: to ('register') -> with_errors ($ validation);

Aici, folosim with_errors metoda pentru Redirecţiona bibliotecă. Aceasta leagă automat erori de $ variabil în vedere pentru oriunde suntem redirecționați - în acest caz, înregistrați / index pagină:

  $ variabila erorilor a trecut prin intermediul cu_errors  @if ($ errors-> has ('email')) @foreach ($ errors-> get (':mesaj
') ca $ email_error) $ email_error @endforeach @endif E-mail:  @if ($ erori-> are ('parola')) @foreach ($ errors-> get ('parola', ':mesaj
') ca $ password_error) $ password_error @endif Parola:  Confirma parola:

În fișierul de vizualizare, folosim $ Errors-> are () pentru a verifica dacă există o eroare pentru câmpul specific. În caz contrar, vom folosi $ Errors-> get () pentru a afișa mesajele de eroare. Al doilea parametru din această metodă poate fi folosit pentru a furniza un șablon cu privire la modul în care afișăm mesajul de eroare.

Mesaje de eroare personalizate

Deoarece majoritatea oamenilor ar dori să schimbe mesajele de eroare pentru Laravel pentru a se potrivi cu branding-ul sau limbajul aplicației, biblioteca de validare permite, de asemenea, personalizarea mesajelor de eroare generate prin simpla adăugare într-o mesaje $ array la Validați :: face funcția de apel:

$ rules = array ('email' => 'obligatoriu | email | unic: utilizatori', 'parola' => 'confirmat'); $ email = email "=" Adresa de e-mail pe care ați furnizat-o deja utilizată "," email_required "=> password_confirmed '=>' Confirmarea parolei nu a corespuns parolei dvs. '); validarea $ = Validator :: make (Input :: get (), $ rules, $ messages);

Există două moduri de a crea o mesaje $ matrice:

Bazat pe reguli - puteți furniza un mesaj personalizat pentru toate câmpurile validate de o anumită regulă. De exemplu:
```
 $ message = array ('required' => 'Câmpul atributului este obligatoriu', 'same' => size ',' between '=>' Atributul:: trebuie să fie între: min -: max. ',' in '=>' Atributul trebuie să fie unul dintre următoarele tipuri:: values ';
```
Aceasta va schimba mesajele de eroare implicite pentru toate câmpurile care au necesar, aceeași dimensiune, între și în reguli. Aici, vedem, de asemenea, că Laravel folosește înlocuitori pentru a înlocui anumite valori în mesajul de eroare. :atribut se va schimba în atributul de câmp (sans underderscores) este pentru. :alte este folosit pentru la fel , care se referă la celălalt atribut care ar trebui să se potrivească. :mărimea se referă la dimensiunea definită în parametrii regulii. : min și : max este valoarea minimă și maximă și : valori este lista de valori pe care am specificat că valoarea câmpului trebuie să fie.
Atribut bazat pe - pe de altă parte, puteți furniza și un mesaj personalizat pentru un atribut specific unei anumite reguli. Luând exemplul nostru de mai sus:
```
 $ email = email "=" Adresa de e-mail pe care ați furnizat-o deja utilizată "," email_required "=> password_confirmed '=>' Confirmarea parolei nu a corespuns parolei dvs. ');
```
email_required este mesajul de eroare folosit atunci când e-mail atributul nu reușește necesar regulă, email_email este mesajul de eroare folosit atunci când e-mail eșuează e-mail regulă și așa mai departe.

Dacă vă aflați în mod conștient să creați aceleași mesaje personalizate, ar fi mai ușor să specificați mesajele de eroare personalizate la nivel global. Puteți face acest lucru prin editarea application / langauge / ro / validation.php fișier și editarea personalizat array găsit acolo:

... 'custom_name' => array ('email_required' => 'Vă rugăm să furnizați o adresă de e-mail', 'email_email' => 'Introduceți o adresă de email validă', 'email_unique' => ',' password_confirmed '=>' Confirmarea parolei nu corespundea parolei dvs. '); ...

3 - Dosare Laravel

Manipularea încărcărilor de fișiere

lui Laravel Fișiere biblioteca ușurează gestionarea încărcărilor de fișiere utilizând Intrare :: încărcare metodă, care este un simplu înveliș pentru PHP move_uploaded_file funcţie:

Input :: upload ('input_name', 'director / to / save / file', 'filename.extension');

Pentru a valida încărcările de fișiere, puteți utiliza funcția validator biblioteca pe care am discutat-o mai sus așa:

$ input = array ('upload' => Intrare :: fișier ('upload')); $ rules = array ('upload' => 'mimes: zip, rar | max: 500'); $ validator = Validator :: face ($ input, $ rules);

Manipularea fișierelor

Fișiere biblioteca are și unele metode de manipulare a fișierelor, cum ar fi:

// Obțineți un fișier $ data = Fișier :: get ('path / file.extension'); // Scrie un fișier Fișier :: pune ('path / file.extension', $ data); // Adăugarea la un fișier File :: append ('path / file.extension', $ data);

Funcții legate de fișiere

Laravel furnizează, de asemenea, câteva funcții generale legate de fișiere care pot fi utilizate în întregul cod. De exemplu, Fișier :: extensie returnă extensia unui nume de fișier șir:

// Aceasta va returna fisierul 'zip' :: extension ('data.zip');

Fișier :: este Funcția verifică dacă un fișier este de un anumit tip. Luați notă că acest lucru nu verifică pur și simplu extensia fișierului, dar utilizează Informații despre fișier Extensie PHP pentru a citi conținutul real al fișierului. Acest lucru este util pentru a determina dacă un fișier are de fapt un tip de fișier corect:

// Returnează adevărat dacă fișierul este un fișier zip, false dacă altfel File :: is ('zip', 'path / file.zip');

O listă de extensii compatibile poate fi văzută în application / config / mimes.php.

Vorbind despre tipurile de mime, puteți folosi și Fișier :: mime pentru a obține tipurile de mime ale unei extensii. Tipul mime returnat se bazează pe același mimes.php fişier:

// Aceasta va întoarce imaginea / png Fișier :: mime ('png')

Fișier :: cpdir si Fișier :: rmdir metodele pot copia și șterge un director, respectiv.

Fișier :: cpdir ('director / to / copy', 'destination / directory'); // File :: rmdir este o ștergere recursivă, deci va șterge toate fișierele și folderele din interiorul directorului. Fișier :: rmdir ( 'directorul / a / șterge');

Acum că am învățat totul Filtre, Validare biblioteca și Fișiere bibliotecă, să le punem în aplicare în cererea noastră, Instapics.

Pasul 1 Creați un `AUTH` Filtru

Adăugați filtre la `Base_Controller`

Să începem prin a ne asigura că utilizatorii pot vizualiza numai pagini autentificate prin crearea unui AUTH filtru care rulează înainte de toate solicitările. Din moment ce folosim rutarea bazată pe controler, va trebui să ne configurem filtrele în regulatorul nostru. Să punem filtrele în __construi metodă a Base_Controller pentru a vă asigura că AUTH filtrul rulează pe toate controalele care o extind. În timp ce suntem la el, să adăugăm o nonauth și filtru pentru a vă asigura că persoanele pot vizita anumite pagini numai atunci când nu sunt autentificate:

clasa Base_Controller extinde Controller funcția publică __construct () // Assets Asset :: add ('jquery', 'js / jquery-1.7.2.min.js'); Asset :: adăugați ('bootstrap-js', 'js / bootstrap.min.js'); Asset :: adăugați ('bootstrap-css', 'css / bootstrap.min.css'); Asset :: adăugați ('bootstrap-css-responsive', 'css / bootstrap-responsive.min.css', 'bootstrap-css'); Asset :: adăugați ('style', 'css / style.css'); părinte :: __ construct (); // Filtre $ class = get_called_class (); comutator ($ class) caz 'Home_Controller': $ this-> filter ('înainte', 'nonauth'); pauză; cazul "User_Controller": $ this-> filter ('înainte', 'nonauth') -> numai (array ('authenticate')); $ this-> filter ('înainte', 'auth') -> numai (array ('logout')); pauză; implicit: $ this-> filter ('înainte', 'auth'); pauză;

Aici definim că orice solicitare către Acasă traseul va necesita un utilizator neautorizat, ceea ce este bun, deoarece acesta este locul unde se află ecranul de conectare. Orice altă cerere va implicit implicit să solicite un utilizator autentificat. Pentru User_Controller, avem de fapt două metode separate care necesită atât utilizatori neautorizați (autentificați), cât și utilizatori autentificați (logout), deci facem uz de numai pentru a specifica acțiunile controlerului la care se aplică filtrele.

Creați definiții de filtrare în `routes.php`

Acum deschis application / routes.php, care este locul unde vom defini AUTH și nonauth Filtre. Luați notă că este posibil să aveți deja deja existente AUTH definiție filtru, astfel încât să o înlocuiți cu cea de mai jos:

Route :: filtru ('auth', function () if (Auth :: guest ()) returneaza Redirect :: to ('home');); Route :: filtru ('nonauth', function () if (Auth :: guest () == false) returneaza Redirect :: to ('dashboard););

În AUTH filtru, verificăm dacă un utilizator este autentificat cu Auth bibliotecă. Dacă utilizatorul nu este autentificat, îi redirecționăm înapoi la Acasă traseu în cazul în care ecranul de conectare este, în caz contrar, li se permite să continue. Același lucru cu nonauth filtru - verificați dacă utilizatorul este autentificat, dacă acesta este, apoi îl redirecționați spre tabloul de bord.

Pasul 2 Implementați încărcările de utilizatori

Creați un formular pentru încărcarea fotografiilor

Acum, când știm mai multe despre cum să gestionăm încărcările de fișiere în Laravel, să începem să implementăm una dintre ele Instapics"principalele caracteristici - încărcarea fotografiilor. Începeți prin crearea unui dosar numit aplicație / vizualizări / plugins , iar în interiorul acestuia se creează un fișier de vizualizare Blade numit upload_modal.blade.php. Inserați următoarele coduri HTML:

   Încărcați un nou Instapic
 
   Fotografie  Descriere  
 
  Anulare

Creați declanșatorul butonului

Să declanșăm această formă modală cu un buton - adăugați acest lucru cerere / opinii / machete / main.blade.php, după .nav-colaps div:

  @section ( 'navigație') Acasă
 @yield_section 
 
 @ secțiune ('post_navigation') @if (Auth :: check ()) @ include ('plugins.loggedin_postnav') @endif @yield_section

Aici vom include un fișier de vizualizare numit loggedin_postnav dacă utilizatorul este conectat. Aici vom adăuga butonul pentru formularul de încărcare modală. În același fișier, adăugați acest după .recipient div:

 @yield ( 'conținut') 
  © Instapics 2012
 
 
  @ secțiune ('modals') @if (Auth :: check ()) @ include ('plugins.upload_modal') @endif @yield_section

Aici includem upload_modal HTML. Ne asigurăm însă că utilizatorul nu este conectat înainte de a include acest fișier HTML, deoarece, ca și declanșatorul butonului, acest lucru nu ar fi cu adevărat necesar în cazul în care utilizatorul nu este autentificat.

Acum, creați cerere / vizualizari / plugins / loggedin_postnav.blade.php

Actualizați pagina și ar trebui să vedeți noul buton de încărcare - faceți clic pe acesta pentru a vedea că funcționează!

Conectați formularul la controlerul corespunzător

Acum, când avem chestii de lucru din față, să începem să lucrăm la partea din spate a formularului. Crea application / controllere / photo.php, și puneți următorul cod pentru controler:

clasa Photo_Controller extinde Base_Controller funcția publică action_upload () $ input = Input :: all (); $ extension = fișier :: extensie ($ input ['photo'] ['name']); $ director = cale ('public'). 'uploads /'. sha1 (Auth :: user () -> id); $ filename = sha1 (Auth :: user () -> id.time ()) ". $ extensie"; $ upload_success = Input :: upload ('foto', $ director, $ filename); dacă ($ upload_success) Session :: flash ('status_success', 'Încărcat cu succes noul Instapic');  altceva Session :: flash ('status_error', 'A apărut o eroare în timpul încărcării noului Instapic - încercați din nou.');  if ($ upload_success) $ photo = noua fotografie (array ('location' => URL :: to ('uploads / , 'descriere' => $ input ['description'])); Auth :: utilizator () -> (fotografii) -> introduceți ($ foto);  returnează Redirecționarea :: către ("tabloul de bord");

Încercați - ar trebui să puteți începe să încărcați un nou Instapics.

Adăugați validarea în formularul de încărcare

Să adăugăm câteva reguli de validare pentru acest lucru pentru a vă asigura că utilizatorul trimite numai lucrurile corecte. Actualizați controlerul cu următoarele:

clasa Photo_Controller extinde Base_Controller funcția publică action_upload () $ input = Input :: all (); dacă isset ($ input ['description'])) $ input ['descriere'] = filter_var ($ input ['description'], FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES);  $ rules = array ('photo' => 'cerută | imagine | max: 500', // încărcarea fotografiei trebuie să fie o imagine și nu trebuie să depășească 500kb 'description' => 'required' // este necesară descrierea); validarea $ = Validator :: make ($ input, $ rules); dacă ($ validarea-> nu reușește ()) returnează Redirecționarea :: la ('dashboard') -> with_errors ($ validation);  $ extension = fișier :: extensie ($ input ['photo'] ['name']); $ director = cale ('public'). 'uploads /'. sha1 (Auth :: user () -> id); $ filename = sha1 (Auth :: user () -> id.time ()) ". $ extensie"; $ upload_success = Input :: upload ('foto', $ director, $ filename); dacă ($ upload_success) $ photo = new Photo (array ('location' => URL :: to ('uploads / 'descriere' => $ input ['description'])); Auth :: utilizator () -> (fotografii) -> introduceți ($ foto); Session :: flash ('status_success', 'S-a încărcat cu succes noul dvs. Instapic');  altceva Session :: flash ('status_error', 'A apărut o eroare în timpul încărcării noului dvs. Instapic - încercați din nou.');  returnează Redirecționarea :: către ("tabloul de bord");

Vedeți cum validăm intrarea? Ne asigurăm că fotografia este prezentă, o imagine și mai puțin de 500kb. De asemenea, ne asigurăm că descrierea este prezentă după salubrizare. Încă nu vom putea vedea mesajele noastre de eroare, așa că haideți să le rezolvăm prin adăugarea unor coduri HTML pentru a reda mesajele noastre de eroare. Deschis cerere / opinii / machete / main.blade.php și adăugați următoarele în interiorul .recipient div:

 @ include ('plugins.status') @yield ('content') 
  © Instapics 2012

Acum, creați cerere / vizualizari / plugins / status.blade.php. Aici vom reda mesajele de eroare reale. De asemenea, vom adăuga suport pentru mesajele de stare bazate pe sesiuni (cum ar fi cele pe care le folosim în interiorul $ upload_success verificați Fotografii codul de comandă):

@if (isset ($ erori) && count ($ erori-> all ())> 0)  × Oh Snap!
  @foreach ($ errors-> all (':mesaj
') ca mesaj $) $ message @endforeach 
 
 @elseif (! is_null (Session :: get ('status_error'))  × Oh Snap!
 @if (is_array (Session :: get ('status_error')))  @foreach (Session :: get ('status_error') ca eroare $) $ error
 @endforeach 
 @else Session :: get ('status_error') @endif 
 @endif @if (! is_null (Session :: get ('status_success')))  × Succes!
 @if (is_array (Session :: get ('status_success')))  @foreach (Session :: get ('status_success') ca succes de $) $ success
 @endforeach 
 @else Session :: get ('status_success') @endif 
 @endif

Încercați să provocați erori în formularul de încărcare prin trimiterea fără nici un fișier selectat sau fără descriere (deoarece ambele sunt necesare). Ar trebui să vedeți mesajele de eroare redate în partea de sus:

Pasul 3 Adăugați validarea la formularul de înregistrare și de conectare

Acum că știm cum să folosim Laravel Validare bibliotecă, să revizuim prima noastră formă - formularul de înregistrare și de înregistrare. În momentul de față, folosim doar unul ecou pentru a vedea că datele de conectare sau de înregistrare au eșuat - să le înlocuim cu o validare corectă. Deschis application / controllere / user.php și actualizați-l astfel:

class User_Controller extinde Base_Controller funcția publică action_authenticate () $ email = Input :: get ('email'); $ password = Intrare :: get ('parola'); $ new_user = Intrare :: get ('new_user', 'off'); $ input = array ('email' => $ email, 'parola' => parola $); dacă $ new_user == 'on') $ rules = array ('email' => 'obligatoriu | email | unic: utilizatori', 'parola' => 'cerut'); validarea $ = Validator :: make ($ input, $ rules); dacă ($ validation-> fails ()) returnează Redirecționarea :: la ('home') -> with_errors ($ validation);  încercați $ user = new User (); $ user-> email = $ email; $ user-> parola = Hash :: make ($ password); $ User-> Salvare (); Auth :: autentificare (utilizator $); returnează Redirect :: către ('tabloul de bord');  captură (Excepție $ e) Session :: flash ('status_error', 'A apărut o eroare la crearea unui nou cont - încercați din nou.'); întoarcere Redirecționare :: la ("acasă");  altfel $ rules = array ('email' => 'obligatoriu' e-mail | există: utilizatori ',' parola '=>' cerut '); validarea $ = Validator :: make ($ input, $ rules); dacă ($ validation-> fails ()) returnează Redirecționarea :: la ('home') -> with_errors ($ validation);  $ credentials = array ('username' => $ email, 'parola' => parola $); dacă (Auth :: tentativă ($ credentials)) returnează Redirect :: la ('tabloul de bord');  altceva Session :: flash ('status_error', 'E-mailul sau parola dvs. sunt nevalide - încercați din nou.'); întoarcere Redirecționare :: la ("acasă");  funcția publică action_logout () Auth :: logout (); Redirecționează :: pentru ( 'home / index');

Din moment ce am făcut modularea modului nostru de redactare a mesajelor de stare, nu este nevoie nici măcar să scriem alte coduri HTML pentru a vedea mesajele de eroare în acțiune! Doar încercați!

Concluzie

În cel de-al treilea tutorial al nostru Laravel serie, am aflat:

Cum, când și unde să utilizați Laravel Filtre
Cum să folosiți Laravel Validare biblioteca, și cum să se ocupe de Validare erorile bibliotecii.
Cum se gestionează fișierele din Laravel folosind Fișiere bibliotecă

Laravel vine cu multe dintre aceste mici funcții și biblioteci, care, deși implementabil în alte moduri, este simplificat și simplificat (de exemplu, încărcări de fișiere într-o singură linie!) Prin adoptar

Cod