Bygg Web Apps fra grunnen av med Laravel - The Eloquent ORM

I denne Nettuts + mini-serien bygger vi et webprogram fra grunnen, mens du dykker inn i et flott nytt PHP-rammeverk som raskt tar opp damp, kalt Laravel.

I denne leksjonen jobber vi på en integrert del av et hvilket som helst webprogram: Modeller. Underveis lærer vi om Laravels fantastiske ORM-implementering: Eloquent.

Anmeldelse

Velkommen tilbake til vår Webprogrammer fra grunnen til Laravel serie! I den første opplæringen av serien lærte vi mye om Laravel og dens filosofi:

Hva Laravel er
Hva gjør Laravel forskjellig fra andre PHP-rammer
Hvor å laste ned Laravel
Hvordan sette opp Laravel
Hvordan Laravel's Routing system fungerer
Noen andre funksjoner i Laravel's Routing system
Hvordan lage din første Laravel Controller
Noen ekstra funksjoner med Laravel's Controllers
Hvordan lage din første Laravel View
Slik bruker du Laravel's Blade Templating Engine

Hvis du ikke har lest det ennå, bør du ta en titt på den forrige opplæringen og gi den en lesning - dette vil gjøre det lettere å forstå filosofien bak Laravel og det meste av det vi diskuterer i denne opplæringen.

I denne andre delen av Laravel-serien skal vi bygge en avgjørende del av testprogrammet vårt, Instapics, som er modellimplementeringen. Uten at du kommer til å, la oss komme i gang!

Hva er "Modeller"?

Jeg har allerede snakket litt om hva modeller er i en av mine tidligere artikler, Zend Framework fra Scratch-Models og Integrating Doctrine ORM, for å unngå å gjenta meg selv, skal jeg skrive innholdet av det jeg skrev før her. Du er velkommen til å referere til den andre opplæringen og lese mer om hvilke modeller som er der.

Sammendrag:

Modeller er representanter for databasen, og bør være der alle forretningslogikkene i et program ligger
Controllers kommuniserer med Modeller og ber dem om å hente informasjon de trenger
Denne informasjonen sendes deretter av en kontrollør til visningen og gjengis
Det er veldig sjeldent at en modell direkte samhandler med en visning, men noen ganger kan det skje når det er nødvendig
Modeller kan snakke med andre modeller og er ikke selvforsynte. De har forhold som knytter seg til hverandre
Disse forholdene gjør det enklere og raskere for en kontrollør å få informasjon, siden det ikke må samhandle med ulike modeller - modellene kan gjøre det selv

Modeller i Laravel, eller i de fleste rammer, er utviklet på samme måte. Forskjellen er at Laravel gir oss en enkel måte å bygge disse modellene ved å gi oss generelle metoder som de fleste modeller trenger - Eloquent ORM.

Eloquent ORM

En ORM er en objektrelasjonsmapper, og Laravel har en som du absolutt vil elske! Den heter "Eloquent", fordi den lar deg arbeide med databasobjektene og relasjonene dine ved hjelp av en veltalende og uttrykksfulle syntaks.

Eloquent ORM er Laravels innebygde ORM-implementering. Etter min mening er det en av de beste ORM-implementasjonene jeg har sett så langt - rivaling selv Lære ORM. Det er utrolig elegant, og bruker standardkonvensjoner for å redusere konfigurasjonen.

konvensjoner

For eksempel antar man ved bruk av en Eloquent-modell at tabellen modellen representerer, har en id felt. De id er den primære nøkkelen for enhver plate, og brukes av de fleste av Eloquents metoder.

En annen ting som Eloquent påtar seg, er at tabellnavnet ditt er flertallsformen til modellen din. For eksempel, din Bruker modellen vil referere til brukere bord. Siden dette kanskje ikke alltid er standard for noen, gir Laravel en måte å overstyre dette: bruk bare $ table flagg:

klassen Brukeren utvider Eloquent offentlig statisk $ table = 'my_users';

Dette vil instruere Laravel om ikke å bruke konvensjonen og i stedet bruke den angitte tabellen.

Til slutt kan Laravel også automatisere opprettelsen og oppdateringen av tidsstempler for oss. For å gjøre det, legg til en created_at og / eller updated_at kolonne i tabellen, og sett inn $ timestamp flagg i modellen:

klassen Brukeren utvider Eloquent public static $ timestamps = true;

Eloquent vil se flagget og automatisk stille inn created_at feltet ved opprettelse, og oppdater updated_at feltet hver gang en plate er oppdatert. Ganske kul, hei?

Rask opphenting

Å hente poster er et snap med Eloquent's henting metoder. For eksempel må du finne en bestemt brukeroppføring? Bare gjør:

$ user = Bruker :: finn ($ user_id);

Dette returnerer a Bruker modell som du kan gjøre operasjoner på! Trenger du å bruke conditionals? La oss forestille deg at du vil hente en bruker via e-postadresse. For å oppnå denne oppgaven kan du gjøre noe som helst:

$ user = Bruker :: hvor ('email', '=', $ email) -> første ();

Alternativt kan du bruke Laravels dynamiske metoder:

$ user = Bruker :: where_email ($ email) -> første ();

Enkle innlegg og oppdateringer

Sette inn og oppdatere modeller ved hjelp av Eloquent kan oppnås i tre trinn.

Trinn 1 - Få / Lag modellen.

 $ user = ny bruker (); // eller få en eksisterende bruker $ user = User :: get ($ user_id);

Steg 2 - Angi dataene

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

Trinn 3 - Lagre
```
 $ Bruker-> Lagre ();
```
Ferdig!

Og til slutt, definere forhold.

Eloquent gjør prosessen med å definere relasjoner og hente relaterte modeller enkelt og intuitivt.

Forferdelig, det gjør det! Eloquent støtter tre typer relasjoner:

En-til-en
En-til-mange
Mange-til-mange

For å definere et forhold mellom modeller, må du lage en metode i begge modellene som "beskriver" deres relasjoner. For eksempel, la oss si a Bruker has_one Brukerprofil. Du kan gjøre det ved å definere en brukerprofil metode i Bruker modell:

klassen Brukeren utvider Eloquent offentlig funksjon user_profile () return $ this-> has_one ('User_Profile');

Fordi Bruker er vår "dominerende" modell her (dvs. en bruker har en profil, og ikke en profil har en bruker), definerer vi at a Brukerprofil tilhører en Bruker:

klasse User_Profile utvider Eloquent public function user () return $ this-> belongs_to ('User');

Når vi har definert dette forholdet, kan vi da gjøre:

/ * Få Bruker_Profile-objektet til en Bruker Dette kjører to SQL-spørringer: VELG * FRA 'brukere' hvor 'id' = $ user_id VELG * FRA 'user_profiles' WHERE 'user_id' = $ user_id * / $ user = Bruker :: finn ($ user_id); $ user_profile = $ user-> user_profile; / * Vi kan også gjøre det omvendt * / $ user_profile = User_Profile :: where ('user_id', '=', $ user_id) -> first (); $ user = $ user_profile-> bruker;

En ting verdt å merke seg her er en annen konvensjon: Eloquent forutsetter at den utenlandske nøkkelen brukes i Brukerprofil er referansetabellens navn + _id. Igjen, hvis du vil endre denne oppførselen, kan du overstyre den:

klassen Brukeren utvider Eloquent offentlig funksjon user_profile () return $ this-> has_one ('User_Profile', 'user_profile_user_id');

La oss si at vi vil definere forholdet mellom a Bruker og hans Bilde opplastinger. Dette er en En-til-mange forhold, i motsetning til Bruker-til-Brukerprofil forhold som var En-til-en. Vi vet den Bruker har mange Bilde opplastinger, så:

klassen brukeren utvider eloquent public function photos () return $ this-> has_many ('foto');  ... klasse Foto utvider Eloquent public function user () return $ this-> belongs_to ('User');

Hovedforskjellen her med has_one er det den funksjonen vi skal bruke for å hente a Brukerbilder vil nå returnere en matrise av Bilde objekter. Så, hvis vi ønsket å hente alle a Brukerbilder vi kunne gjøre:

$ photos = Bruker :: finn ($ user_id) -> bilder; foreach ($ bilder som $ bilde) ...

Nei, med henvisning til bilder som en eiendom er ikke en skrivefeil. Laravel gir oss denne fine bit sukker. Vi kan også gjøre:

$ photos = User :: find ($ user_id) -> photos () -> get ();

Mant-til-mange relasjoner

Denne er litt vanskelig, men når den er implementert, gjør den det lett å håndtere Mange-til-mange forhold mellom modellene. La oss for eksempel forestille deg at du igjen har en Bruker modell, og hver av disse brukerne kan ha flere grupper. EN Gruppe kan også ha flere brukere. Vi bruker tre tabeller for å representere disse spesielle forhold:

brukere - bord der alle våre brukere er
grupper - bord der alle våre grupper er
Gruppe bruker - tabell som lister ned alle brukere i en gruppe

Tabellstrukturen konvensjonen Eloquent vil se etter, vil være noe slikt:

brukere
- id
- ... andre kolonner
grupper
- id
- ... andre kolonner
GROUP_USER
- id
- bruker-ID
- group_id
- ... andre kolonner

En annen konvensjon å merke seg her er at mellombordet, GROUP_USER, er de enslige navnene på de to tabellene som den kobler sammen, ordnet alfabetisk med et understreke. Som alltid er vi fri til å tilsidesette dette.

Slik ser koden ut i hver av modellene for disse tre tabellene:

klassen brukeren utvider eloquent public function groups () // hvis vi ønsket å overstyre standard navngivningskonvensjonen // for mellomtabellen, kan vi gjøre det slik: // returnere $ this-> has_many_and_belongs_to ('Group' group_listings'); returnere $ this-> has_many_and_belongs_to ('Group');  ... klassegruppe utvider Eloquent public function users () // hvis vi ønsket å overstyre standard navngivningskonvensjonen // for mellomtabellen, kan vi gjøre det slik: // returnere $ this-> has_many_and_belongs_to ('Bruker ',' group_listings '); returnere $ this-> has_many_and_belongs_to ('User');  ... klasse Group_User utvider Eloquent public function group () return $ this-> has_one ('Group');  offentlig funksjon bruker () return $ this-> has_one ('bruker');

Med dette på plass kan vi da dra nytte av Eloquents forholdsfunksjoner:

// Få brukerens grupper $ groups = User :: find ($ user_id) -> groups; // Få alle brukere i en gruppe $ users = Group :: find ($ group_id) -> brukere;

Trinn 1 - Opprett Instapics Database

Fortsetter med vårt webprogram, Instapics, la oss begynne med å lage databasen av vår søknad. For å gjøre det, la oss skrive ned de ønskede funksjonene i programmet:

Brukere kan logge inn og registrere seg for en konto
Brukere kan følge andre brukere for å se bilder de har lastet opp
Brukere kan laste opp sitt eget bilde og bruke et filter til det
Brukere kan kommentere og like bilder

Herfra kan vi utlede databasetabellene vi trenger:

brukere
- id (One-to-One med user_profiles.user_id, mange til mange med selvtillit ved hjelp av mellomliggende tabellrelasjoner.follower_id og followed_id, One-to-Many med photos.user_id og photo_comments.user_id)
- e-post
- passord
- created_at
- updated_at
user_profiles
- id
- user_id (One-to-One med users.id)
- Navn
- Profilbilde
forhold
- id
- follower_id (One-to-One med users.id)
- followed_id (One-to-One med users.id)
- created_at
- updated_at
bilder
- id (One-to-Many med photo_comments.user_id)
- user_id (One-to-One med users.id)
- plassering
- beskrivelse
- created_at
- updated_at
photo_comments
- id
- user_id (One-to-One med users.id)
- photo_id (One-to-One med photos.id)
- budskap
- created_at
- updated_at

La oss gå videre og lage disse tabellene. For dette prosjektet skal jeg bruke MySQL; vær så snill å kopiere og lime inn disse kommandoene.

CREATE DATABASE 'instapics'; BRUK 'instapics'; CREATE TABLE 'instapics'. 'Brukere' ('id' INTEGER UNSIGNED IKKE NULL AUTO_INCREMENT, 'email' VARCHAR (100) IKKE NULL, 'passord' VARCHAR (100) IKKE NULL, 'created_at' DATETID IKKE NULL, 'updated_at' DATETIME IKKE NULL, PRIMARY KEY ('id'), UNIQUE INDEX 'Index_email' ('email')) MOTOR = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'User_profiles' ('id' INTEGER UNSIGNED IKKE NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED IKKE NULL, 'navn' TEKST IKKE NULL, 'profile_photo' TEKST IKKE NULL, PRIMARY KEY ('id'), UNIQUE INDEX 'Index_user_id' ('user_id'), CONSTRAINT 'FK_user_profiles_user_id' Utenlands nøkkel 'FK_user_profiles_user_id' ('user_id') REFERANSER 'brukere' ('id') DELETE CASCADE ON UPDATE CASCADE) MOTOR = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Relations' ('id' INTEGER UNSIGNED IKKE NULL AUTO_INCREMENT, 'follower_id' INTEGER UNSIGNED IKKE NULL, 'followed_id' INTEGER UTSIGNERT IKKE NULL, 'created_at' DATETID IKKE NULL, 'updated_at' DATETID IKKE NULL, PRIMARY KEY ('id'), UNIQUE INDEX 'Index_follower_id_followed_id' ('follower_id', 'followed_id'), CONSTRAINT 'FK_relationships_follower_id' Utenlandske nøkkelen 'FK_relationships_follower_id' ('follower_id') REFERANSER 'brukere' ('id') OM DELETE CASCADE ON UPDATE CASCADE, CONSTRAINT 'FK_relationships_followed_id' FOREIGN KEY 'FK_relationships_followed_id' ('followed_id') REFERANSER 'brukere' ('ID') OM DELETE CASCADE ON UPDATE CASCADE) MOTOR = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Photos' ('id' INTEGER UNSIGNED IKKE NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED IKKE NULL, 'plassering' TEKST IKKE NULL, 'beskrivelse' TEKST IKKE NULL, 'created_at' DATETID NOT NULL, 'updated_at 'DATOID IKKE NULL, PRIMÆR NØKKEL (' ID '), KONSTRAINT' FK_photos_user_id 'Utenlandsnøkkel' FK_photos_user_id '(' user_id ') REFERANSER' Brukernes '(' ID ') DELETE CASCADE PÅ OPPDATERING CASCADE) MOTOR = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Photo_comments' ('id' INTEGER UNSIGNED IKKE NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED IKKE NULL, 'photo_id' INTEGER UNSIGNED NOT NULL, 'melding' TEKST IKKE NULL, 'created_at' DATETIME NOT NULL, ' updated_at 'DATETID IKKE NULL, PRIMARY KEY (' id '), CONSTRAINT' FK_photo_comments_user_id 'Utenlandsnøkkel' FK_photo_comments_user_id '(' user_id ') REFERANSER' brukere '(' id ') PÅ DELETE CASCADE OM OPPDATERING CASCADE, CONSTRAINT' FK_photo_comments_photo_id 'UDENLANDSKE KEY 'FK_photo_comments_photo_id' ('photo_id') REFERANSER 'photos' ('id') PÅ DELETE CASCADE ON UPDATE CASCADE) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;

Alternativt kan du bruke migrasjoner, men vi vurderer dem i en fremtidig leksjon.

Trinn 2 - Konfigurer Laravel Database Configuration

Før du gjør noe med Laravel-modeller, må vi konfigurere Laravel-installasjonens databasekonfigurasjon. Åpen application / konfig / database.php, for å finne noen av disse innstillingene:

profil - sette dette til ekte vil logge alle SQL querie tider inn i Laravel loggene. La dette være som ekte for nå.
hente - typen av returnerte data fra BOB. Standardverdien er PUD :: FETCH_CLASS og bør bli igjen som så.
misligholde - Dette er navnet på forbindelsesinnstillingene som brukes av programmet. Navnet refererer til indeksen i $ tilkoblinger array like nedenfor
tilkoblinger - et assosiativt utvalg av mulige tilkoblinger for søknaden din.
- sjåfør - databasetjenertypen. Dette kan være pgsql, SQLite, mysql eller sqlsrv
- vert - vertsnavnet til databaseserveren din
- database - databasenavnet
- brukernavn - brukernavn for bruk på databaseserveren
- passord - passord for bruk på databaseserveren
- charset - charset å bruke på databaseserveren
- prefiks - tabell prefiks i databasen, hvis noen
Redis - hvis du planlegger å bruke Laravel's Redis bibliotek, kan du konfigurere serverinformasjonen her.

I forbindelse med denne opplæringen bruker vi MySQL. Din database.php filen skal se slik ut (jeg fjernet kommentarene, men de burde være fine å beholde):

returnere array ('profile' => true, 'fetch' => PDO :: FETCH_CLASS, 'standard' => 'mysql', 'connections' => array ('mysql' => array ('driver' => 'mysql ',' host '=' 'localhost', 'database' => 'instapics', 'brukernavn' => 'root', 'passord' => '(passordet ditt)', 'charset' => 'utf8' prefix '=> ",),),' redis '=> array (' default '=> array (' vert '=>' 127.0.0.1 ',' port '=> 6379,' database '=> 0) ));

Trinn 3 - Opprette din første Laravel-modell

Begynn med å lage en Laravel-modell inne i applikasjons / modeller mappe. Skape user.php inne, og legg til følgende kode:

klassen bruker strekker seg utallige

Nå, basert på vår gjennomgang av hva Brukerrelasjoner er, vi må kodes forholdsmetodene for dem alle:

klassen brukeren utvider eloquent // setting $ timestamp til true så eloquent // vil automatisk sette created_at // og updated_at verdier offentlig statisk $ timestamps = true; offentlig funksjon user_profile () return $ this-> has_one ('User_Profile');  folkeavhengige følgere () return $ this-> has_many_and_belongs_to ('User', 'relations', 'followed_id', 'follower_id');  offentlig funksjon etter () return $ this-> has_many_and_belongs_to ('Bruker', 'relasjoner', 'følger_id', 'followed_id');  offentlige funksjonsfotografier () return $ this-> has_many ('Photo');  offentlig funksjon photo_comment () return $ this-> has_many ('Photo_Comment');

Bemerkelsesverdig gjør vi bruk av noen avanserte mange til mange funksjonaliteter her, på grunn av tabellstrukturen til vår tilhengermodell (dvs. brukere tabell refererer til forhold bord som refererer til brukere bord igjen). De has_many_and_belongs_to funksjonen har følgende metode signatur:

/ ** * Få spørringen for et mange til mange forhold. * * @param streng $ modell * @param streng $ tabell * @param streng $ utenlandsk * @param streng $ andre * @return Forhold * / offentlig funksjon har_many_and_belongs_to ($ modell, $ table = null, $ utenlandsk = null, $ andre = null)

Dette lar oss faktisk lage en modell som har et mange til mange forhold til seg selv (det vil si brukere følger andre brukere). Vi bruker etterfølgere og følgende Metodenavn på Bruker modell slik at vi kan få brukerens tilhenger eller få alle brukerne som en enkelt bruker følger, henholdsvis.

Følger Bruker modell, opprett de andre modellene. Når du er ferdig, bør du ha:

application / modeller / photo.php
application / modeller / photo_comment.php
application / modeller / relationship.php
application / modeller / user.php
application / modeller / user_profile.php

Disse filene kommer til å være i opplærings Git-arkiv, så hvis du foretrekker å laste dem ned, kan du finne dem her: https://github.com/nikkobautista/laravel-tutorial

Trinn 4 - Opprett brukerfunksjonene for Instapics

La oss begynne å bruke våre modeller ved å lage noen av brukerfunksjonene vi trenger i programmet. Først opp: Brukerregistrering. Fra den forrige opplæringen har vi allerede opprettet en Registrerings- / påmeldingsskjema på hjemmesiden. Akkurat nå gjør det ikke noe, men la oss koble det til en Bruker kontrolleren, autentisere handling. Skape application / kontrollere / user.php med følgende kode:

klasse User_Controller utvider Base_Controller offentlig funksjon action_authenticate ()

Åpen application / synspunkter / home / index.blade.php og se etter innloggingsskjemaet. Oppdater skjemaet på Linje 18 å sende til action_authenticate () metode:

Kommer tilbake til User_Controller, la oss plassere noen kode i action_authenticate ():

klasse User_Controller utvider Base_Controller offentlig funksjon action_authenticate () $ email = Input :: get ('email'); $ password = Input :: get ('passord'); $ new_user = Input :: get ('new_user', 'off'); hvis ($ new_user == 'on') prøv $ user = ny bruker (); $ user-> email = $ email; $ user-> password = Hash :: make ($ password); $ Bruker-> Lagre (); Auth :: innlogging ($ bruker); returnere omdirigering :: til ('dashbord / indeks');  fangst (Unntak $ e) echo "Faield å opprette ny bruker!";  else $ credentials = array ('brukernavn' => $ e-post, 'passord' => $ passord); hvis (Auth: forsøk ($ credentials)) return Omdirigering :: til ('dashboard / index');  else echo "Kunne ikke logge inn!";

La oss kutte ned det vi har gjort her så langt:

Vi bruker Input bibliotek for å få inngangene fra det innleverte skjemaet
Hvis $ new_user flagget ble sjekket, vi lager en ny Bruker, bruker hash bibliotek for å generere et kryptert passord.
Logg inn den nye Bruker med Auth bibliotek
Hvis $ new_user flagget var ukontrollert, vi lager en $ legitimasjon array, og bruk den med Auth bibliotek.
Hvis Auth :: forsøk er sant, det betyr at legitimasjonene var korrekte og vi er logget inn
Ellers betyr det at legitimasjonene var feil.
I begge scenariene, viderekoble til dashbord kontrolleren, index handling når det lykkes, og ekko en feilmelding hvis ikke.

Input-biblioteket

Den grunnleggende funksjonen til Input biblioteket er å aktivere gjenfinning av skjemadata. For eksempel, i Bruker kontrolleren, vi brukte Input :: får ( 'e'); for å få e-postverdien fra skjemaet. Det er viktig å merke seg at få Metoden brukes til alle typer forespørsler og ikke bare til $ _GET matrise.

Du kan lese mer om Input-biblioteket her: http://laravel.com/docs/input#input

Auth biblioteket

Laravel kommer med sin egen autentiseringsmekanisme, den Auth bibliotek. Det kan gjøre følgende funksjoner med hensyn til brukerautentisering.

Opprette et hashed-passord

Vi kan gjøre bruk av hash bibliotek slik:

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

Denne metoden oppretter et saltet og hashed-passord for en bruker, ved hjelp av krypteringsnøkkelen vi angir i konfigurasjonsfilen. For å sjekke om en hash er riktig, kan du bruke:

hvis (Hash :: sjekk ($ plaintext_password, $ hashed_password) == true) echo 'Passordet er riktig.';

Logg inn på en bruker

For dette bruker vi Auth bibliotekets forsøk metode. Før det skjønner vi imidlertid en $ legitimasjon array, som er en assosiativ array med a brukernavn og passord indekser:

$ credentials = array ('username' => '[email protected]', 'passord' => 'passordet ditt'); hvis (Auth: forsøk ($ credentials) == true) echo 'Bruker er logget inn';  ellers echo 'Referanser mislyktes';

Det er viktig å huske på at når et forsøk er "vellykket", blir brukeren automatisk logget inn.

Logg inn en bruker inn / ut

Noen ganger må vi logge inn en bruker uten å bruke forsøk metode (for eksempel når du logger inn en bruker fra en kobling inne i en e-post eller postregistrering). Vi kan gjøre det med Auth :: innlogging metode:

Auth :: innlogging ($ bruker); // hvor $ bruker er et brukerobjekt Auth :: logg inn (42); // hvor 42 er brukerens ID

På den annen side har vi også en Auth :: utlogging metode for å logge ut brukere:

Auth :: avloggingskoblingen ();

Dette vil avslutte brukerens økt.

Henter den innloggede brukerens data

De Auth :: bruker Metoden tillater oss å hente det innloggede brukerobjektet, samt all informasjon som er vedlagt den:

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

Konfigurere `Auth` bibliotek

De Auth biblioteket må konfigureres før du bruker det (selv om standardene vil fungere med de fleste prosjekter, som denne). Konfigurasjonsvariablene er:

sjåfør - dette kan enten være veltalende eller flytende. Utviklere kan skrive sine egne drivere ved å utvide Sjåfør klasse i laravel / auth / drivere.
brukernavn - Dette er kolonnenavnet av hva som helst som representerer brukerens brukernavn i databasetabellen.
modell - Når du bruker Eloquent, er dette modellklassen som Auth bibliotek bruker
bord - Når du bruker flytende autentiseringsdriveren, bestemmer dette databasetabellen for brukerne i programmet

Vårt prosjekt, Instapics, bruker standardverdiene i auth.php konfigurasjonsfil, så vi trenger ikke å endre noe i det.

Gå tilbake til prosjektet, prøv å teste innloggings- / registreringsfunksjonene til Instapics! Ganske greit, va? Du vil legge merke til at vi ikke har noe i dashbord kontrolleren ennå, så la oss jobbe med det neste.

Trinn 5 - Opprett Instapics Dashboard

Det første vi må gjøre er å lage dashbord kontrolleren, med index handling. Opprett filen application / kontrollere / dashboard.php og legg inn følgende kode:

klasse Dashboard_Controller utvider Base_Controller (offentlig funksjon action_index () $ photos = Auth :: bruker () -> bilder () -> order_by ('created_at', 'desc') -> order_by ('id', 'desc') - > får (); returnere View :: make ('dashboard.index', array ('photos' => $ photos));

Nå må vi opprette oversiktssiden for Dashboard. Skape application / visninger / dashbord / index.blade.php og legg til følgende:

@layout ('layouts / main') @section ('navigasjon') @parent Logg ut
 @endsection @section ('content')     etterfølgere
 
  @forelse (Auth :: user () -> følgere som $ tilhenger)   
 @tømme Du har ingen følgere.
 @endforelse 
 
  Følgende
 
  @forelse (Auth :: user () -> følger som $ følger)   
 @tømme Du følger ikke noen.
 @endforelse 
 
 
 
  Dine bilder
 @forelse ($ bilder som $ bilde)   $ photo-> description
 
 @tømme  awww!
 Virker som om du ikke har noen bilder enda. Last opp en ny?
 
 @endforelse 
 
 @endsection

Oppdater oversikten over dashbordet, du bør se dette:

Ser litt bart ut? Legg dette til i dashbord kontrolleren, og kjøre den ved å få tilgang til dashbord / insert_test_data på nettleseren din:

offentlig funksjon action_insert_test_data () $ logged_in_user = Auth :: bruker (); for ($ x = 0; $ x < 10; $x++ )  $email = rand().'@gmail.com'; $user = new User(); $user->e-post = $ email; $ user-> password = Hash :: lage ($ email); $ Bruker-> Lagre (); $ Logged_in_user-> tilhengere () -> feste ($ bruker-> id); hvis ($ x> 5) $ logged_in_user-> følger () -> vedlegg ($ user-> id);  $ photos = array (array ('user_id' => $ logged_in_user-> id, 'location' => 'http://farm6.staticflickr.com/5044/5319042359_68fb1f91b4.jpg', 'description' => 'Dusty Minner, jenta i den svarte bjørnen (http://www.flickr.com/photos/cloudy-day/) '), array (' user_id '=> $ logged_in_user-> id,' location '=>' http: //farm3.staticflickr.com/2354/2180198946_a7889e3d5c.jpg ',' description '=>' Rascals, Tannenberg (http://www.flickr.com/photos/tannenberg/) '), array (' user_id '=> $ logged_in_user-> id, 'location' => 'http://farm7.staticflickr.com/6139/5922361568_85628771cd.jpg', 'description' => 'Solnedgang, Funset, Nikko Bautista (http://www.flickr. com / photos / nikkobautista /) ')); $ Logged_in_user-> bilder () -> Lagre ($ bilder);

Når du oppdaterer siden, ser du hvordan det ser ut til at eksempeldataene er lagt inn:

Konklusjon

I den andre delen av vår Laravel serier, lærte vi:

Noen bakgrunn på hvilke "Modeller" er
Hva Eloquent ORM er
Slik konfigurerer du Laravel databasekonfigurasjon
Hvordan lage din første Laravel-modell
De grunnleggende funksjonene til Auth og Input-bibliotekene
Gjør bruk av Eloquent ORM i en visning

Eloquent er virkelig en fantastisk ORM-implementering - den er rask og har mange funksjoner som gjør databasens interaksjoner i alle applikasjoner så enkle som mulig.

Neste i vår Webprogrammer fra grunnen til Laravel serier, lærer vi mer om bruk av Laravel s filter, Laravel's Validering bibliotek, og hvordan å jobbe med filer i Laravel!

Hva synes du om Laravel's Eloquent ORM? Er det noe du synes er nyttig? Gi meg beskjed i kommentarene! Og, hvis du er Tuts + Premium-medlem, hold deg oppdatert for vårt kommende Laravel Essentials kurs!

Kode