Construiți aplicații web de la zero cu Laravel - ORM elocvent

Î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 lucra pe o parte integrantă a oricărei aplicații web: Modelele. Pe parcurs, vom afla despre implementarea uimitoare a ORM a lui Laravel: Elocvent.

Revizuire

Bine ați venit înapoi la noi Aplicații Web de la Scratch cu Laravel serie! În primul tutorial al seriei, am învățat multe despre Laravel și despre filozofia lui:

Ce este Laravel
Ce face Laravel diferit de alte cadre PHP
Unde se descarcă Laravel
Cum se configurează Laravel
Cum funcționează sistemul de dirijare a lui Laravel
Unele alte caracteristici ale sistemului de dirijare a lui Laravel
Cum se creează primul controler Laravel
Unele caracteristici suplimentare cu Controlerele lui Laravel
Cum se creează prima vizualizare Laravel
Cum se utilizează motorul Laravel Blade Templating Engine

Dacă nu ați citit-o încă, ar trebui să aruncați o privire la tutorialul anterior și să o citiți - acest lucru va face mai ușor să înțelegeți filozofia din spatele Laravel și cele mai multe din ceea ce discutăm în acest tutorial.

În această a doua parte a seriei Laravel, vom construi o parte crucială a aplicației noastre de testare web, Instapics, care este implementarea modelului. Fără să mai vorbim, să începem!

Ce sunt "Modele"?

Am vorbit deja despre ce modele sunt în unul dintre articolele mele anterioare, Zend Framework from Scratch - Models și Integrating Doctrine ORM, așa că, pentru a evita repetarea, voi scrie esența a ceea ce am scris mai devreme aici. Simțiți-vă liber să vă referiți la celălalt tutorial și să citiți mai multe despre Modelele de acolo.

Rezumat:

Modelele sunt reprezentanți ai bazei de date și ar trebui să fie locul în care se află toată logica de afaceri a unei aplicații
Controlorii comunică cu modelele și le solicită să obțină informațiile de care au nevoie
Aceste informații sunt apoi transmise de un controler la vizualizare și sunt redate
Este foarte rar ca un model să interacționeze direct cu o vizualizare, dar uneori se poate întâmpla când este necesar
Modelele pot vorbi cu alte modele și nu sunt autonome. Ei au relații care se întrepătrund între ele
Aceste relații fac mai ușoară și mai rapidă obținerea de informații de către un controlor, deoarece nu trebuie să interacționeze cu diferite modele - Modelele pot face acest lucru

Modelele din Laravel, sau în cele mai multe cadre, sunt dezvoltate în același mod. Diferența constă în faptul că Laravel ne oferă o modalitate ușoară de a construi aceste modele, oferindu-ne metode cu scop general pe care majoritatea modelelor le-ar avea nevoie - ORM elocvent.

ORC-ul elocvent

Un ORM este un mapper obiect-relațional, iar Laravel are unul pe care îl vei iubi absolut! Este numit "Elocvent", deoarece vă permite să lucrați cu obiectele și relațiile bazei de date utilizând o sintaxă elocventă și expresivă.

ORM elocvent este implementarea ORM implementată de Laravel. În opinia mea, este una dintre cele mai bune implementări ORM pe care le-am văzut până acum - rivalizând chiar și pe Doctrine ORM. Este incredibil de elegant, folosind convențiile standard pentru a diminua configurația.

Convenții

De exemplu, folosind un model Eloquent presupune că tabela reprezentată de model are un id camp. id este cheia primară pentru orice înregistrare și este folosită de majoritatea metodelor lui Eloquent.

Un alt lucru pe care Elloquent îl presupune corect este că numele tău de masă este forma plurală a modelului tău. De exemplu, dvs. Utilizator model va face referire la utilizatori masa. Deoarece acest lucru nu ar putea fi întotdeauna standard pentru unii, Laravel oferă o modalitate de a trece peste acest lucru: pur și simplu utilizați masă de $ steag:

user clasa se extinde Elocvent public static $ table = 'my_users';

Aceasta va instrui Laravel să nu folosească convenția și să folosească în schimb tabelul specificat.

În cele din urmă, Laravel poate, de asemenea, să automatizeze crearea și actualizarea timbrelor pentru noi. Pentru a face acest lucru, adăugați o creat la și / sau updated_at coloana din tabel și setați $ timestamp-ul pavilion în model:

user class extinde Elocvent public static $ timestamps = true;

Elocvent va vedea steagul și va seta automat creat la domeniul creării și actualizarea updated_at câmp de fiecare dată când este actualizată o înregistrare. Destul de cool, huh?

Recuperare rapidă

Recuperarea înregistrărilor este o metodă de recuperare a metodei de recuperare a lui Eloquent. De exemplu, trebuie să găsiți o înregistrare specifică a utilizatorului? Doar fa-o:

$ user = Utilizator :: find ($ user_id);

Aceasta returnează a Utilizator model pe care puteți face operațiuni! Trebuie să utilizați condiționate? Să ne imaginăm că doriți să preluați un utilizator prin adresa de e-mail. Pentru a îndeplini această sarcină, puteți face ceva de genul:

$ user = Utilizator :: unde ('email', '=', $ email) -> first ();

Alternativ, puteți utiliza metodele dinamice ale lui Laravel:

$ user = Utilizator :: where_email ($ email) -> first ();

Intrări și actualizări ușoare

Introducerea și actualizarea modelelor folosind Eloquent poate fi realizată în trei etape.

Pasul 1 - Obțineți / Creați modelul.

 $ user = utilizator nou (); // sau a obține un utilizator existent $ user = User :: get ($ user_id);

Pasul 2 - Setați datele

 $ user-> email = '[email protected]'; $ user-> parola = 'test1234';

Pasul 3 - Salvați
```
 $ User-> Salvare ();
```
Terminat!

Și, în final, definirea relațiilor.

Elloquent face ca procesul de definire a relațiilor și de recuperare a modelelor aferente să fie simplu și intuitiv.

La naiba! Elocvent susține trei tipuri de relații:

Unu la unu
One-to-many
Mulți-to-many

Pentru a defini o relație între modele, va trebui să creați o metodă în ambele modele care "descriu" relațiile dintre ele. De exemplu, să spunem a Utilizator are unul user_profile. Puteți face acest lucru prin definirea unui user_profile metodă în Utilizator model:

user class extinde elocvent funcția publică user_profile () return $ this-> has_one ('User_Profile');

pentru că Utilizator este modelul nostru "dominant" aici (adică un utilizator are un profil și nu un profil are un utilizator), definim că a user_profile aparține lui A Utilizator:

class User_Profile se extinde Elocvent public function user () return $ this-> belongs_to ('User');

Odată ce am definit aceste relații, putem face:

/ * Obțineți obiectul User_Profile al unui utilizator Acest lucru execută două interogări SQL: SELECT * FROM 'utilizatori' WHERE 'id' = $ user_id SELECT * FROM 'user_profiles' WHERE 'user_id' = $ user_id * / $ user = ($ user_id); $ user_profile = $ user-> user_profile; / * Putem de asemenea să o facem și invers. * / $ User_profile = User_Profile :: unde ('user_id', '=', $ user_id) -> first (); $ user = $ user_profile-> utilizator;

Un lucru demn de remarcat aici este o altă convenție: elocvent presupune că cheia străină folosită în user_profile este numele tabelului referit + _id. Din nou, dacă doriți să schimbați acest comportament, îl puteți suprascrie:

Utilizatorul de clasă se extinde Elocvent funcția publică user_profile () return $ this-> has_one ('User_Profile', 'user_profile_user_id');

Să spunem că vrem să definim relația dintre a Utilizator si a lui Fotografie încărcări. Acesta este un One-to-many relație, spre deosebire de Utilizator-la-Profilul utilizatorului relație care a fost Unu la unu. Știm asta Utilizator are multe Fotografie încărcări, astfel:

user-ul de clasă extinde elocvent public funcții photos () return $ this-> has_many ("Photo");  ... class Photo extinde Elocvent public function user () return $ this-> belongs_to ('Utilizator');

Principala diferență aici cu are unul este că funcția pe care o vom folosi pentru a extrage a Utilizatorfotografiile vor reveni acum mulțime de Fotografie obiecte. Deci, dacă vrem să aducem toate a Utilizatorfotografiile, am putea face:

$ photos = Utilizator :: găsi ($ user_id) -> photos; foreach ($ fotografii ca $ foto) ...

Nu, referindu-mă la fotografii ca o proprietate nu este o tipografie. Laravel ne dă un fel de zahăr frumos. De asemenea, am putea face:

$ photos = Utilizator :: găsi ($ user_id) -> photos () -> get ();

Mant-la-multe relații

Acesta este un pic cam complicat, dar odată implementat, este ușor de manevrat Mulți-to-many relațiile dintre modele. Să ne imaginăm, de exemplu, că, din nou, aveți a Utilizator model, iar fiecare dintre acești utilizatori poate avea mai multe funcții Grupuri. A grup poate avea, de asemenea, mai multe Utilizatori. Vom folosi trei tabele pentru a reprezenta aceste relații particulare:

Utilizatori - unde sunt toți utilizatorii noștri
Grupuri - unde sunt toate grupurile noastre
Utilizator de grup - care listează toți utilizatorii dintr-un grup

Structura de masă convențională elocvent va căuta va fi ceva de genul:

utilizatori
- id
- ... alte coloane
Grupuri
- id
- ... alte coloane
GROUP_USER
- id
- numele de utilizator
- group_id
- ... alte coloane

O altă convenție pe care o menționăm aici este aceea că tabela intermediară, GROUP_USER, este numele singular al celor două tabele pe care le conectează, aranjate în ordine alfabetică cu o subliniere. Ca întotdeauna, suntem liberi să ignorăm acest lucru.

Iată cum codul va arăta în interiorul fiecăruia dintre modelele pentru aceste trei tabele:

() // dacă am fi vrut să suprascriem convenția de numire implicită // pentru tabela intermediară, o putem face așa: // return $ this-> has_many_and_belongs_to ('Group', ' group_listings'); returnați $ this-> has_many_and_belongs_to ('Grup');  ... clasa Group extinde Eloquent public function users () // daca vrem sa suprascriem conventia de numire implicita // pentru tabela intermediara, o putem face asa: // return $ this-> has_many_and_belongs_to ('User ',' group_listings '); returnați $ this-> has_many_and_belongs_to ('Utilizator');  ... clasa Group_User extinde elocvent public function group () return $ this-> has_one ('Group');  funcția publică funcția () return $ this-> has_one ("Utilizator");

Cu acest lucru, putem profita de funcțiile de relație ale lui Eloquent:

// Obțineți grupuri de utilizatori $ groups = User :: find ($ user_id) -> groups; // Obțineți toți utilizatorii dintr-un grup $ users = Group :: find ($ group_id) -> users;

Pasul 1 - Crearea bazei de date Instapics

Continuând cu aplicația noastră web, Instapics, Să începem prin crearea bazei de date a aplicației noastre. Pentru a face acest lucru, să notăm funcționalitățile dorite ale aplicației:

Utilizatorii se pot conecta și se pot înregistra pentru un cont
Utilizatorii pot urmări alți utilizatori pentru a vedea fotografiile pe care le-au încărcat
Utilizatorii pot încărca propria fotografie și pot aplica un filtru
Utilizatorii pot comenta și pot face fotografii

Din aceasta putem deduce tabelele bazei de date de care avem nevoie:

utilizatori
- id (One-to-One cu user_profiles.user_id, Multi-to-Many cu relații de sine cu relații personale.follower_id și follow_id, One-to-Many cu photos.user_id și photo_comments.user_id)
- e-mail
- parola
- creat la
- updated_at
profilurile utilizatorilor
- id
- user_id (One-to-One cu utilizatori.id)
- Nume
- fotografie de profil
relaţii
- id
- follower_id (One-to-One cu utilizatori.id)
- follow_id (One-to-One cu utilizatori.id)
- creat la
- updated_at
fotografii
- id (One-to-Many cu photo_comments.user_id)
- user_id (One-to-One cu utilizatori.id)
- Locație
- Descriere
- creat la
- updated_at
photo_comments
- id
- user_id (One-to-One cu utilizatori.id)
- photo_id (One-to-One cu photos.id)
- mesaj
- creat la
- updated_at

Să mergem mai departe și să creăm aceste mese. Pentru acest proiect, voi folosi MySQL; nu ezitați să copiați și să lipiți aceste comenzi.

CREAȚI DATABASE "instapics"; UTILIZAREA "instapicilor"; CREATE TABLE 'instapics'. 'Utilizator' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'email' VARCHAR (100) NOT NULL, 'password' VARCHAR (100) NOT NULL, 'created_at' DATETIME NOT NULL, 'updated_at' DATETIME NU NULL, KEY PRIMARY ('id'), INDICAT UNIC 'Index_email' ('email')) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'User_profiles' ('id' INTEGER UNSIGNED NU NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'name' TEXT NOT NULL, 'profile_photo' TEXT NOT NULL, KEY PRIMARY INDEX "Index_user_id" ('user_id'), CONSTRAINT 'FK_user_profiles_user_id' FOREIGN KEY 'FK_user_profiles_user_id' ('user_id') REFERINȚELE utilizatorilor '(' id ') pe DELETE CASCADE LA UPCATE CASCADE) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Relații' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'follower_id' INTEGER UNSIGNED NOT NULL, 'follow_id' INTEGER UNSIGNED NOT NULL, 'created_at' DATETIME NULL, 'updated_at' DATETIME NOT NULL, PRIMARY KEY ('id'), INDICAT UNIQUE 'Index_follower_id_followed_id' ('follower_id', 'followed_id'), CONSTRAINT 'FK_relationships_follower_id' FOREIGN KEY 'FK_relationships_follower_id' ('follower_id') REFERINȚE '' '' '' DELETE CASCADE ON UPDATE CASCADE, CONSTRAINT 'FK_relationships_followed_id' FOREIGN KEY 'FK_relationships_followed_id' ('follow_id') REFERINȚE "utilizatori" ('id') pe DELETE CASCADE PE UPDATE CASCADE) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Photos' ('id' INTEGER UNSIGNED NU NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'locație' TEXT NOT NULL, 'description' DATETIME NULL, 'DATETIME NUL NULL, KEY PRIMARY (' id '), CONSTRAINT' FK_photos_user_id 'FOREIGN KEY' FK_photos_user_id '(' user_id ') REFERINȚE' '' '' '' 'DELETE CASCADE ON UPCATE CASCADE' 'ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Photo_comments' ('id' INTEGER UNSIGNED NU NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'photo_id' INTEGER UNSIGNED NOT NULL, 'message_TEXT NOT NULL' created_at 'DATETIME NOT NULL' ('id') REFERINȚE 'utilizatori' ('id') pe DELETE CASCADE LA UPCATE CASCADE, CONSTRAINT 'FK_photo_comments_photo_id' KEY FOREIGN (FUNCTIONAL) FK_photo_comments_user_id ' 'FK_photo_comments_photo_id' ('photo_id') REFERINȚELE "fotografii" ('id') pe DELETE CASCADE LA UPCATE CASCADE) MOTOR = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;

Alternativ, ați putea folosi migrațiile, dar le vom examina într-o lecție viitoare.

Pasul 2 - Configurați configurarea bazei de date Laravel

Înainte de a face ceva cu modelele Laravel, trebuie să configurați configurația bazei de date a instalației Laravel. Deschis application / config / database.php, pentru a găsi unele dintre aceste setări:

profil - setarea la aceasta Adevărat va loga toate vremurile SQL query în jurnalele Laravel. Lasă asta ca Adevărat deocamdata.
aduce - tipul de date returnate de la DOP. Valoarea implicită este DOP :: FETCH_CLASS și ar trebui să rămână așa.
Mod implicit - acesta este numele setărilor de conectare utilizate de aplicație. Numele se referă la indexul din conexiuni $ array de mai jos
conexiuni - o matrice asociativă a conexiunilor posibile pentru aplicația dvs..
- conducător auto - tipul de server de bază de date. Acesta poate fi pgsql, SQLite, MySQL sau sqlsrv
- gazdă - numele gazdei serverului de baze de date
- Bază de date - numele bazei de date
- nume de utilizator - numele de utilizator pentru a fi utilizat pe serverul de baze de date
- parola - parola de utilizat pe serverul de baze de date
- charset - set de caractere pentru a fi utilizat pe serverul de baze de date
- prefix - prefixul tabelului în baza de date, dacă există
Redis - dacă intenționezi să îl folosești pe Laravel Redis bibliotecă, puteți configura informațiile despre server aici.

În scopul acestui tutorial, vom folosi MySQL. Ta database.php fișier ar trebui să arate ceva de genul acesta (am eliminat comentariile, dar ar trebui să fie bine să păstreze):

retur array ('profile' => true, 'fetch' => PDO :: FETCH_CLASS, 'default' => 'mysql', 'connections' => array ('mysql' ',' username '=>' root ',' password '=>' (yourpassword) ',' charset '=>' utf8 ' prefix '=>', '),' redis '=> array (' default '=> ));

Pasul 3 - Crearea primului model Laravel

Începeți prin crearea unui model Laravel în interiorul aplicatii / modele pliant. Crea user.php în interiorul și adăugați următorul cod:

Utilizatorul de clasă extinde elocvent

Acum, pe baza analizei noastre asupra a ceea ce Utilizatorrelațiile sunt, trebuie să codificăm metodele de relație pentru toate acestea:

user-ul de clasă extinde Eloquent // setarea timestampului $ la true astfel Eloquent // va seta automat valorile create_at // și updated_at static public $ timestamps = true; funcția publică user_profile () return $ this-> has_one ('User_Profile');  următorii funcționari publici () return $ this-> has_many_and_belongs_to ('Utilizator', 'relații', 'follow_id', 'follower_id');  funcție publică după () return $ this-> has_many_and_belongs_to ('Utilizator', 'relații', 'follower_id', 'followed_id');  funcții publice funcții () return $ this-> has_many ("Photo");  funcția publică photo_comment () return $ this-> has_many ('Photo_Comment');

În mod evident, folosim câteva funcții avansate Multe-până-Multe aici, datorită structurii tabelului modelului nostru de adepți (adică utilizatori tabelul face trimitere la relaţii tabel care face referire la utilizatori tabelul din nou). has_many_and_belongs_to funcția are următoarea semnătură de metodă:

/ ** * Obțineți interogarea pentru o relație multi-multi. * * @parametru parcelar $ model * @param string $ table * @param string $ străin * @param string $ alt * @ relație relație * / funcția publică has_many_and_belongs_to ($ model, $ table = null, $ foreign = null, $ other = null)

Acest lucru ne permite, de fapt, să creăm un model care are o relație Multe-Multe cu ea însăși (adică utilizatorii urmăresc alți utilizatori). Folosim adepți și ca urmare a nume de metode pe Utilizator model pentru a ne permite să obținem următorii utilizatori ai unui utilizator sau să îi primim pe toți utilizatorii pe care le urmărește un singur utilizator.

Urmărind Utilizator model, creați celelalte modele. Când ați terminat, ar trebui să aveți:

cerere / modele / photo.php
cerere / modele / photo_comment.php
cerere / modele / relationship.php
cerere / modele / user.php
cerere / modele / user_profile.php

Aceste fișiere vor fi în repozitoriul Git al tutorialului, deci dacă preferați să le descărcați, le puteți găsi aici: https://github.com/nikkobautista/laravel-tutorial

Pasul 4 - Creați funcțiile utilizatorilor pentru Instapics

Să începem să folosim modelele noastre prin crearea unor funcții de utilizator pe care le vom avea nevoie în aplicație. Primul pas: înregistrarea utilizatorului. Din tutorialul anterior, am creat deja o Formular de înregistrare / de conectare pe pagina de pornire. Chiar acum, nu face nimic, dar hai să o facem pe a Utilizator controlor, autentifica acțiune. Crea application / controllere / user.php cu următorul cod:

class User_Controller extinde Base_Controller funcția publică action_authenticate ()

Deschis cerere / opinii / home / index.blade.php și căutați formularul de autentificare. Actualizați formularul Linia 18 să se prezinte la action_authenticate () metodă:

Revenind la User_Controller, hai să introducem un cod action_authenticate ():

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'); dacă ($ new_user == 'pe') try $ user = new User (); $ user-> email = $ email; $ user-> parola = Hash :: make ($ password); $ User-> Salvare (); Auth :: autentificare (utilizator $); returnează Redirect :: către ('dashboard / index');  captură (Excepție $ e) echo "Faield pentru a crea un utilizator nou!";  altceva $ credentials = array ('username' => $ email, 'password' => parola $); dacă (Auth :: tentativă ($ credentials)) returnează Redirect :: la ('dashboard / index');  altceva echo "Nu sa putut autentifica!";

Haideți să deslușim ceea ce am făcut până acum:

Noi folosim Intrare biblioteca pentru a obține datele din formularul trimis
În cazul în care $ new_user steag a fost verificat, vom crea un nou Utilizator, folosind hașiș bibliotecă pentru a genera o parolă criptată.
Conectați-vă la noul Utilizator cu Auth bibliotecă
În cazul în care $ new_user steagul nu a fost verificat, creăm un $ datele de conectare array, și să o utilizați cu Auth bibliotecă.
Dacă Auth :: această încercare este adevărat, înseamnă că acreditările au fost corecte și că suntem conectați
Altfel, înseamnă că acreditările au fost greșite.
În ambele scenarii, redirecționați către Tablou de bord controlor, index acționa atunci când a reușit, și echo un mesaj de eșec dacă nu.

Biblioteca de intrare

Funcția de bază a Intrare biblioteca este pentru a permite recuperarea datelor din formular. De exemplu, în Utilizator controler, am folosit Intrare :: get ( 'e-mail'); pentru a obține valoarea de e-mail din formular. Este important să rețineți că obține metoda este folosită pentru toate tipurile de cereri și nu doar pentru $ _GET mulțime.

Puteți citi mai multe despre biblioteca de intrare aici: http://laravel.com/docs/input#input

Biblioteca Auth

Laravel vine cu propriul său mecanism de autentificare Auth bibliotecă. Poate face următoarele caracteristici în ceea ce privește autentificarea utilizatorilor.

Crearea unei parole de tip hashed

Putem folosi hașiș cum ar fi:

$ parola = Hash :: make ($ plaintext_password);

Această metodă creează o parolă salată și hashed pentru un utilizator, utilizând cheia de criptare pe care am setat-o în fișierul de configurare. Pentru a verifica dacă un hash este corect, puteți utiliza:

dacă (Hash :: verificați ($ plaintext_password, $ hashed_password) == true) echo 'Parola este corectă';

Conectarea la un utilizator

Pentru aceasta, folosim Auth bibliotecii atentat, încercare metodă. Înainte de asta, însă, construim un $ datele de conectare array, care este o matrice asociativă cu a nume de utilizator și parola indici:

$ credentials = array ('username' => '[email protected]', 'password' =>'password '); dacă (Auth :: tentativă ($ credentials) == true) echo 'Utilizatorul este conectat';  altceva echo 'Credentials failed';

Este important să rețineți că odată ce o încercare este "reușită", utilizatorul este conectat automat.

Înregistrați un utilizator în / out

Uneori, va trebui să vă conectăm un utilizator fără a utiliza atentat, încercare (cum ar fi atunci când vă conectați la un utilizator dintr-un link în interiorul unui e-mail sau post-înregistrare). Putem face asta cu Auth :: autentificare metodă:

Auth :: autentificare (utilizator $); // unde $ user este un obiect utilizator Auth :: login (42); // unde 42 este ID-ul utilizatorului

Pe de altă parte, avem și noi un Auth :: logout pentru conectarea utilizatorilor:

Auth :: logout ();

Aceasta va termina sesiunea utilizatorului.

Recuperarea datelor utilizatorului conectat

Auth :: utilizator ne permite să preluăm obiectul utilizator înregistrat, precum și orice informație atașată acestuia:

$ email = Auth :: user () -> email; $ created_at = Autor: :: user () -> created_at;

Configurarea `Auth` bibliotecă

Auth biblioteca trebuie să fie configurată înainte de a fi utilizată (deși setările implicite vor funcționa cu majoritatea proiectelor, ca aceasta). Variabilele de configurare sunt:

conducător auto - aceasta poate fi și ea elocvent sau fluent. Dezvoltatorii pot scrie propriile drivere prin extinderea Conducător auto clasă în laravel / autorizare / drivere.
nume de utilizator - acesta este numele coloanei a ceea ce reprezintă "numele de utilizator" al utilizatorului în tabela de baze de date.
model - atunci când se utilizează elocvent, aceasta este clasa de model care Auth utilizarea bibliotecii
masa - când se utilizează driverul de autentificare Fluent, aceasta determină tabela de baze de date pentru utilizatorii din aplicație

Proiectul nostru, Instapics, utilizează valorile implicite în auth.php fișier de configurare, deci nu trebuie să schimbăm nimic în el.

Revenind la proiect, încercați să testați caracteristicile de conectare / înregistrare ale Instapics! Destul de bine, nu? Veți observa totuși că nu avem nimic în Tablou de bord controler încă, deci hai să lucrăm la următoarea.

Pasul 5 - Creați tabloul de bord Instapics

Primul lucru pe care trebuie să-l facem este să creați Tablou de bord controler, cu index acțiune. Creați fișierul application / controllere / dashboard.php și introduceți următorul cod:

clasa Dashboard_Controller extinde Base_Controller funcția publică action_index () $ photos = Auth :: user () -> photos () -> order_by ('created_at', 'desc' > get (); retur View :: make ('dashboard.index', array ('photos' => $ photos));

Acum trebuie să creăm pagina index a tabloului de bord. Crea cerere / vederi / tablou de bord / index.blade.php și adăugați următoarele:

@layout ("layouts / main") @ secțiune ("navigare") @parent Deconectare
 @endsection @ section ('conținut')     Urmaritori
 
  @forelse (Auth :: user () -> adepți ca $ follower)  mail)) s = 25 & d = retro "alt =" În urma "title =" $ follow-> email 
 @gol Nu urmăriți pe nimeni.
 @endforelse 
 
 
 
  Fotografiile tale
 @forelse (fotografii $ ca fotografie foto)   $ foto-> descriere
 
 @gol  AWWW!
 Se pare că nu aveți încă nicio fotografie. Încărcați unul nou?
 
 @endforelse 
 
 @endsection

Actualizați pagina de bord, ar trebui să vedeți acest lucru:

Privind un pic gol? Adăugați această funcție la Tablou de bord controler, și rulați-l prin accesarea tablou de bord / insert_test_data pe browser-ul dvs.:

funcția publică action_insert_test_data () $ logged_in_user = Auth :: user (); pentru ($ x = 0; $ x < 10; $x++ )  $email = rand().'@gmail.com'; $user = new User(); $user->email = $ email; $ user-> parola = Hash :: make ($ email); $ User-> Salvare (); $ Logged_in_user-> fani () -> atașați ($ user-> id); dacă ($ x> 5) $ logged_in_user-> după () -> atașați ($ user-> id);  $ photos = array (array ('user_id' => $ logged_in_user-> id, 'locație' => 'http://farm6.staticflickr.com/5044/5319042359_68fb1f91b4.jpg', 'description' => Amintiri, Fata în Beret Negru (http://www.flickr.com/photos/cloudy-day/) ', array (' user_id '=> $ logged_in_user-> id,' locație '=>' http: //farm3.staticflickr.com/2354/2180198946_a7889e3d5c.jpg ',' description '=>' Rascals, Tannenberg (http://www.flickr.com/photos/tannenberg/) '), array (' user_id '=> $ logged_in_user-> id, 'locație' => 'http://farm7.staticflickr.com/6139/5922361568_85628771cd.jpg', 'description' => 'Sunset, Funset, Nikko Bautista (http://www.flickr. com / fotografii / nikkobautista /) ')); $ Logged_in_user-> (fotografii) -> salvați (fotografii $);

Când actualizați pagina, veți vedea cum arată datele introduse:

Concluzie

În a doua parte a noastră Laravel serie, am aflat:

Unele fundaluri despre ce sunt "Modelele"
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 bibliotecilo

Cod