Crea app Web da zero con Laravel - L'ORM eloquente

In questa mini serie Nettuts +, creeremo un'applicazione web da zero, mentre ci immergiamo in un nuovo framework PHP che sta rapidamente prendendo piede, chiamato Laravel.

In questa lezione, lavoreremo su una parte integrante di qualsiasi applicazione web: i Modelli. Lungo la strada, apprenderemo dell'impressionante implementazione ORM di Laravel: Eloquent.

Revisione

Bentornato al nostro Applicazioni Web da Scratch con Laravel serie! Nel primo tutorial della serie, abbiamo imparato molto su Laravel e la sua filosofia:

Che cos'è Laravel
Ciò che rende Laravel diverso dagli altri framework PHP
Dove scaricare Laravel
Come configurare Laravel
Come funziona il sistema di routing di Laravel
Alcune altre funzionalità del sistema di routing di Laravel
Come creare il tuo primo controller Laravel
Alcune funzionalità aggiuntive con i controller di Laravel
Come creare il tuo primo Laravel View
Come usare Laravel's Blade Templating Engine

Se non l'hai ancora letto, dovresti dare un'occhiata al tutorial precedente e dargli una lettura - questo renderà più facile capire la filosofia di Laravel e la maggior parte di ciò che discuteremo in questo tutorial.

In questa seconda parte della serie di Laravel, creeremo una parte cruciale della nostra applicazione web di test, Instapics, che è l'implementazione del modello. Senza ulteriori indugi, iniziamo!

Cosa sono i "Modelli"?

Ho già parlato un po 'di cosa Modelli sono in uno dei miei articoli precedenti, Zend Framework di Scratch - Modelli e Integrazione di Doctrine ORM, quindi per evitare di ripetermi, scriverò il succo di ciò che ho scritto prima qui. Sentiti libero di fare riferimento all'altro tutorial e leggi di più su cosa ci sono i Modelli.

Sommario:

I modelli sono rappresentanti del Database e dovrebbero essere dove risiede tutta la logica di business di un'applicazione
I controllori comunicano con i modelli e chiedono loro di recuperare le informazioni di cui hanno bisogno
Questa informazione viene quindi passata da un Controller alla vista e viene renderizzata
È molto raro che un modello interagisca direttamente con una vista, ma a volte può accadere quando necessario
I modelli possono parlare con altri modelli e non sono autonomi. Hanno relazioni che si intrecciano l'una con l'altra
Queste relazioni rendono più semplice e veloce per un Controller ottenere informazioni, poiché non deve interagire con Modelli diversi - i Modelli possono farlo da soli

I modelli in Laravel o nella maggior parte dei framework sono sviluppati allo stesso modo. La differenza è che Laravel ci offre un modo semplice per costruire questi modelli, fornendoci metodi di uso generale di cui la maggior parte dei modelli avrebbe bisogno: il ORM eloquente.

L'ORM eloquente

Un ORM è un mappatore di oggetti relazionale e Laravel ne ha uno che amerai assolutamente! Si chiama "Eloquent", perché consente di lavorare con gli oggetti e le relazioni del database usando una sintassi eloquente ed espressiva.

L'ORM di Eloquent è l'implementazione ORM integrata di Laravel. A mio parere, è una delle migliori implementazioni ORM che abbia mai visto fino ad ora, rivaleggiando persino con Doctrine ORM. È incredibilmente elegante, facendo uso di convenzioni standard del settore per ridurre la configurazione.

Convegni

Ad esempio, l'utilizzo di un modello Eloquent presuppone che la tabella che il modello sta rappresentando abbia un id campo. Il id è la chiave primaria per qualsiasi record e viene utilizzata dalla maggior parte dei metodi di Eloquent.

Un'altra cosa che Eloquent presuppone correttamente è che il nome della tua tabella sia la forma plurale del tuo modello. Ad esempio, il tuo Utente il modello farà riferimento al utenti tavolo. Poiché questo potrebbe non essere sempre lo standard per alcuni, Laravel offre un modo per ignorarlo: basta usare il $ tavolo bandiera:

la classe User estende Eloquent public static $ table = 'my_users';

Questo istruirà Laravel a non utilizzare la convenzione e utilizzerà invece la tabella specificata.

Infine, Laravel può anche automatizzare la creazione e l'aggiornamento di timestamp per noi. Per fare ciò, aggiungi un created_at e / o updated_at colonna nella tabella e impostare il $ timestamp bandiera nel modello:

la classe User estende Eloquent public static $ timestamps = true;

Eloquent vedrà la bandiera e imposterà automaticamente il created_at campo sulla creazione e aggiorna il updated_at campo ogni volta che viene aggiornato un record. Molto carino, eh?

Recupero rapido

Recuperare i record è un gioco da ragazzi con i metodi di recupero di Eloquent. Ad esempio, è necessario trovare un record utente specifico? Basta fare:

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

Questo restituisce a Utente modello su cui puoi fare operazioni! Hai bisogno di usare i condizionali? Immaginiamo di voler recuperare un utente tramite indirizzo email. Per portare a termine questo compito, potresti fare qualcosa come:

$ user = User :: where ('email', '=', $ email) -> first ();

In alternativa, puoi utilizzare i metodi dinamici di Laravel:

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

Inserti e aggiornamenti facili

L'inserimento e l'aggiornamento di modelli tramite Eloquent possono essere eseguiti in tre passaggi.

Passo 1 - Ottieni / Crea il modello.

 $ user = new User (); // o ottiene un utente esistente $ user = User :: get ($ user_id);

Passo 2 - Imposta i dati

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

Passaggio 3 - Salvare
```
 $ User-> save ();
```
Fatto!

E infine, Definire le relazioni.

Eloquent rende il processo di definizione delle relazioni e il recupero di modelli correlati semplici e intuitivi.

Accidenti, lo fa! Eloquent supporta tre tipi di relazioni:

Uno a uno
Uno-a-molti
Molti-a-molti

Per definire una relazione tra i modelli, è necessario creare un metodo in entrambi i modelli che "descriva" le loro relazioni. Ad esempio, diciamo a Utente Ha uno Profilo utente. Puoi farlo definendo a profilo utente metodo nel Utente modello:

la classe User estende Eloquent public function user_profile () return $ this-> has_one ('User_Profile');

Perché Utente è il nostro modello "dominante" qui (cioè un utente ha un profilo, e non un profilo ha un utente), definiamo che un Profilo utente appartiene a un Utente:

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

Una volta che abbiamo definito queste relazioni, possiamo quindi fare:

/ * Ottieni l'oggetto User_Profile di un utente Esegue due query SQL: SELECT * FROM 'users' WHERE 'id' = $ user_id SELECT * FROM 'user_profiles' WHERE 'user_id' = $ user_id * / $ user = User :: find ($ user_id); $ user_profile = $ user-> user_profile; / * Possiamo anche farlo al contrario * / $ user_profile = User_Profile :: where ('user_id', '=', $ user_id) -> first (); $ user = $ user_profile-> user;

Una cosa che vale la pena notare qui è un'altra convenzione: Eloquent presuppone che la chiave esterna utilizzata in Profilo utente è il nome della tabella di riferimento + _ID. Di nuovo, se vuoi cambiare questo comportamento, puoi sovrascriverlo:

la classe User estende Eloquent public function user_profile () return $ this-> has_one ('User_Profile', 'user_profile_user_id');

Diciamo che vogliamo definire la relazione tra a Utente e il suo Foto uploads. Questo è un Uno-a-molti relazione, a differenza del Utente-a-Profilo utente relazione che era Uno a uno. Lo sappiamo Utente ha molti Foto caricamenti, quindi:

l'utente della classe estende Eloquent public function photos () return $ this-> has_many ('Photo');  ... classe Photo estende Eloquent public function user () return $ this-> belongs_to ('User');

La principale differenza qui con Ha uno è la funzione che useremo per recuperare a UtenteLe foto ora restituiranno un schieramento di Foto oggetti. Quindi, se volessimo recuperare tutto a UtenteLe foto di, potremmo fare:

$ foto = Utente :: trova ($ user_id) -> foto; foreach ($ foto come $ foto) ...

No, riferendosi a fotografie come una proprietà non è un errore di battitura. Laravel ci regala questo bel pezzetto di zucchero. Potremmo anche fare:

$ foto = Utente :: trova ($ user_id) -> photos () -> get ();

Rapporti Mant-to-Many

Questo è un po 'complicato, ma una volta implementato, lo rende facile da gestire Molti-a-molti relazioni tra modelli. Immaginiamo, per esempio, che tu, di nuovo, abbia un Utente modello, e ciascuno di questi utenti può avere più gruppi. UN Gruppo può anche avere più utenti. Utilizzeremo tre tabelle per rappresentare queste relazioni particolari:

utenti - tavolo dove sono tutti i nostri utenti
gruppi - tavolo dove sono tutti i nostri gruppi
Utente del gruppo - tabella che elenca tutti gli utenti di un gruppo

La convenzione sulla struttura della tabella che Eloquent cercherà sarà qualcosa del genere:

utenti
- id
- ... altre colonne
gruppi
- id
- ... altre colonne
group_user
- id
- ID utente
- group_id
- ... altre colonne

Un'altra convenzione da notare qui è che il tavolo intermedio, group_user, sono i nomi singolari delle due tabelle che sta connettendo, disposte in ordine alfabetico con un carattere di sottolineatura. Come sempre, siamo liberi di scavalcare questo.

Ecco come apparirà il codice all'interno di ciascuno dei modelli per queste tre tabelle:

classe User estende Eloquent public function groups () // se vogliamo sovrascrivere la convenzione di denominazione predefinita // per la tabella intermedia, possiamo farlo in questo modo: // return $ this-> has_many_and_belongs_to ('Group', ' group_listings'); restituire $ this-> has_many_and_belongs_to ('Group');  ... class Group estende Eloquent public function users () // se vogliamo sovrascrivere la convenzione di denominazione predefinita // per la tabella intermedia, possiamo farlo in questo modo: // return $ this-> has_many_and_belongs_to ('User ',' group_listings '); restituire $ this-> has_many_and_belongs_to ('User');  ... class Group_User estende Eloquent public function group () return $ this-> has_one ('Group');  public function user () return $ this-> has_one ('User');

Con questo, possiamo quindi sfruttare le funzioni di relazione di Eloquent:

// Ottieni gruppi di utenti $ groups = User :: find ($ user_id) -> groups; // Ottieni tutti gli utenti in un gruppo $ users = Group :: find ($ group_id) -> users;

Passaggio 1: creazione del database Instapics

Proseguendo con la nostra applicazione web, Instapics, iniziamo creando il database della nostra applicazione. Per fare ciò, annotiamo le funzionalità desiderate dell'applicazione:

Gli utenti possono accedere e registrarsi per un account
Gli utenti possono seguire altri utenti per vedere le foto che hanno caricato
Gli utenti possono caricare la propria foto e applicare un filtro
Gli utenti possono commentare e apprezzare le foto

Da ciò, possiamo dedurre le tabelle del database di cui avremo bisogno:

utenti
- id (One-to-One con user_profiles.user_id, Many-to-Many con self utilizzando le relazioni della tabella intermedias.follower_id e follows_id, One-to-Many con photos.user_id e photo_comments.user_id)
- e-mail
- parola d'ordine
- created_at
- updated_at
profili utente
- id
- user_id (One-to-One con users.id)
- nome
- Foto profilo
relazioni
- id
- follower_id (One-to-One con users.id)
- follows_id (One-to-One with users.id)
- created_at
- updated_at
fotografie
- id (One-to-Many con photo_comments.user_id)
- user_id (One-to-One con users.id)
- Posizione
- descrizione
- created_at
- updated_at
photo_comments
- id
- user_id (One-to-One con users.id)
- photo_id (One-to-One con photos.id)
- Messaggio
- created_at
- updated_at

Andiamo avanti e creare queste tabelle. Per questo progetto, userò MySQL; sentiti libero di copiare e incollare questi comandi.

CREATE DATABASE 'instapics'; USA 'instapics'; CREATE TABLE 'instapics'. 'Users' ('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 NOT NULL, PRIMARY KEY ('id'), UNICO INDICE 'Index_email' ('email')) ENGINE = InnoDB SET CARATTERE utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'User_profiles' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'name' TEXT NOT NULL, 'profile_photo' TESTO NON NULL, PRIMARY KEY ('id'), UNICO INDICE 'Index_user_id' ('user_id'), CONSTRAINT 'FK_user_profiles_user_id' FOREIGN KEY 'FK_user_profiles_user_id' ('user_id') REFERENCES 'users' ('id') ON DELETE CASCADE ON UPDATE CASCADE) ENGINE = InnoDB SET CARATTERE utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Relationships' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'follower_id' INTEGER UNSIGNED NOT NULL, 'follows_id' INTEGER UNSIGNED NOT NULL, 'created_at' DATETIME NOT NULL, 'updated_at' DATETIME NOT NULL, PRIMARY KEY ('id'), INDICE UNICO 'Index_follower_id_followed_id' ('follower_id', 'followed_id'), CONSTRAINT 'FK_relationships_follower_id' FOREIGN KEY 'FK_relationships_follower_id' ('follower_id') REFERENCES 'users' ('id') ON DELETE CASCADE ON UPDATE CASCADE, CONSTRAINT 'FK_relationships_followed_id' FOREIGN KEY 'FK_relationships_followed_id' ('followed_id') REFERENCES 'users' ('id') ON DELETE CASCADE ON UPDATE CASCADE) ENGINE = InnoDB SET CARATTERE utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Photos' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'location' TEXT NOT NULL, 'description' TEXT NOT NULL, 'created_at' DATETIME NOT NULL, 'updated_at 'DATETIME NOT NULL, PRIMARY KEY (' id '), CONSTRAINT' FK_photos_user_id 'FOREIGN KEY' FK_photos_user_id '(' user_id ') REFERENCES' users '(' id ') ON DELETE CASCADE ON UPDATE CASCADE) ENGINE = InnoDB SET CARATTERE utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'Photo_comments' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'photo_id' INTEGER UNSIGNED NOT NULL, 'message' TESTO NON NULL, 'created_at' DATETIME NOT NULL, ' updated_at 'DATETIME NOT NULL, PRIMARY KEY (' id '), CONSTRAINT' FK_photo_comments_user_id 'FOREIGN KEY' FK_photo_comments_user_id '(' user_id ') REFERENCES' users '(' id ') ON DELETE CASCADE ON UPDATE CASCADE, CONSTRAINT' FK_photo_comments_photo_id 'FOREIGN KEY 'FK_photo_comments_photo_id' ('photo_id') REFERENCES 'foto' ('id') ON DELETE CASCADE ON UPDATE CASCADE) ENGINE = InnoDB SET CARATTERE utf8 COLLATE utf8_general_ci;

In alternativa, puoi utilizzare le migrazioni, ma le esamineremo in una lezione futura.

Passaggio 2: configurazione del database di Laravel

Prima di fare qualsiasi cosa con i modelli Laravel, dobbiamo configurare la configurazione del nostro database di installazione di Laravel. Aperto application / config / database.php, per trovare alcune di queste impostazioni:

profilo - impostando questo a vero registrerà tutti i tempi di interrogazione SQL nei log di Laravel. Lascia questo come vero per adesso.
andare a prendere - il tipo di dati restituiti da PDO. Il valore predefinito è PDO :: FETCH_CLASS e dovrebbe essere lasciato così.
predefinito - questo è il nome delle impostazioni di connessione utilizzate dall'applicazione. Il nome si riferisce all'indice nel $ connessioni array appena sotto
connessioni - un array associativo delle possibili connessioni per la tua applicazione.
- autista - il tipo di server di database. Questo può essere pgsql, sqlite, mysql o SQLSRV
- ospite - il nome host del server del database
- Banca dati - il nome del database
- nome utente - nome utente da utilizzare sul server del database
- parola d'ordine - password da utilizzare sul server di database
- charset - charset da utilizzare sul server di database
- prefisso - prefisso tabella sul database, se presente
Redis - se pensi di usare Laravel Redis libreria, è possibile impostare le informazioni sul server qui.

Ai fini di questo tutorial, useremo MySQL. Il tuo database.php il file dovrebbe apparire in questo modo (ho rimosso i commenti, ma dovrebbero essere a posto per mantenerli):

return array ('profile' => true, 'fetch' => PDO :: FETCH_CLASS, 'default' => 'mysql', 'connections' => array ('mysql' => array ('driver' => 'mysql ',' host '=>' localhost ',' database '=>' instapics ',' username '=>' root ',' password '=>' (yourpassword) ',' charset '=>' utf8 ',' prefisso '=> ",),),' redis '=> array (' default '=> array (' host '=>' 127.0.0.1 ',' port '=> 6379,' database '=> 0), ));

Passaggio 3: creazione del primo modello Laravel

Inizia creando un modello Laravel all'interno del applicazione / modelli cartella. Creare user.php dentro e aggiungi il seguente codice:

l'utente della classe estende Eloquent

Ora, basato sulla nostra recensione di ciò che il UtenteLe relazioni sono, abbiamo bisogno di codificare i metodi di relazione per tutti loro:

class User estende Eloquent // impostando $ timestamp su true in modo che Eloquent // imposti automaticamente i valori created_at // e updated_at public static $ timestamp = true; public function user_profile () return $ this-> has_one ('User_Profile');  public function followers () return $ this-> has_many_and_belongs_to ('User', 'relationships', 'follows_id', 'follower_id');  public function following () return $ this-> has_many_and_belongs_to ('User', 'relationships', 'follower_id', 'followed_id');  public function photos () return $ this-> has_many ('Photo');  public function photo_comment () return $ this-> has_many ('Photo_Comment');

Notevolmente, facciamo uso di alcune funzionalità avanzate Molti-a-Molti qui, a causa della struttura della tabella del nostro modello di follower (cioè il utenti i riferimenti della tabella relazioni tabella che fa riferimento al utenti tavolo di nuovo). Il has_many_and_belongs_to la funzione ha la seguente firma del metodo:

/ ** * Ottieni la query per una relazione molti-a-molti. * * @param stringa $ modello * @param stringa $ tabella * @param stringa $ esterna * @param stringa $ altra * @return Relazione * / funzione pubblica has_many_and_belongs_to ($ modello, $ tabella = null, $ foreign = null, $ altro = null)

Questo in realtà ci consente di creare un modello che ha una relazione molti-a-molti con sé stesso (ad esempio, gli utenti seguono altri utenti). Noi usiamo seguaci e a seguire i nomi dei metodi su Utente modello per consentirci di ottenere i follower di un utente o ottenere tutti gli utenti che un singolo utente sta seguendo, rispettivamente.

Seguendo il Utente modello, crea gli altri modelli. Al termine, dovresti avere:

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

Questi file si troveranno nel repository Git del tutorial, quindi se preferisci scaricarli, puoi trovarli qui: https://github.com/nikkobautista/laravel-tutorial

Passaggio 4: creare le funzioni utente per Instapics

Iniziamo ad usare i nostri modelli creando alcune delle funzioni utente di cui avremo bisogno nell'applicazione. Primo: registrazione dell'utente. Dal tutorial precedente, abbiamo già creato un Modulo di registrazione / accesso sulla home page. In questo momento, non sta facendo nulla, ma colleghiamo a Utente controllore, autenticare azione. Creare application / controller / user.php con il seguente codice:

class User_Controller estende Base_Controller public function action_authenticate ()

Aperto application / views / home / index.blade.php e cerca il modulo di accesso. Aggiorna il modulo su Linea 18 presentare al action_authenticate () metodo:

Tornando al User_Controller, inseriamo del codice action_authenticate ():

class User_Controller estende Base_Controller public function action_authenticate () $ email = Input :: get ('email'); $ password = Input :: get ('password'); $ new_user = Input :: get ('new_user', 'off'); if ($ new_user == 'on') try $ user = new User (); $ utente-> email = $ email; $ user-> password = Hash :: make ($ password); $ User-> save (); Auth :: login ($ user); return Redirect :: to ('dashboard / index');  catch (Exception $ e) echo "Faield per creare un nuovo utente!";  else $ credentials = array ('username' => $ email, 'password' => $ password); if (Auth :: attempt ($ credentials)) return Redirect :: to ('dashboard / index');  else echo "Impossibile accedere!";

Analizziamo ciò che abbiamo fatto fin qui:

Noi usiamo il Ingresso libreria per ottenere gli input dal modulo inviato
Se la $ new_user la bandiera è stata controllata, ne creiamo una nuova Utente, usando il hash libreria per generare una password crittografata.
Accedi al nuovo Utente con il auth biblioteca
Se la $ new_user la bandiera era deselezionata, noi creiamo a $ credenziali array e usarlo con auth biblioteca.
Se Auth :: tentativo è vero, significa che le credenziali erano corrette e abbiamo effettuato l'accesso
Altrimenti, significa che le credenziali erano sbagliate.
In entrambi gli scenari, reindirizzare a Cruscotto controllore, indice azione in caso di successo, ed echo un messaggio di errore se non.

La libreria di input

La funzione di base del Ingresso libreria è per consentire il recupero dei dati del modulo. Ad esempio, nel Utente controller, abbiamo usato Ingresso :: get ( 'e-mail'); per ottenere il valore email dal modulo. È importante notare che il ottenere il metodo è usato per tutti i tipi di richieste e non solo per il $ _GET schieramento.

Puoi leggere di più sulla libreria di input qui: http://laravel.com/docs/input#input

La biblioteca di Auth

Laravel viene fornito con un proprio meccanismo di autenticazione, il auth biblioteca. Può fare le seguenti funzionalità per quanto riguarda l'autenticazione dell'utente.

Creazione di una password con hash

Possiamo usare il hash biblioteca così:

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

Questo metodo crea una password salata e hash per un utente, utilizzando la chiave di crittografia che abbiamo impostato nel file di configurazione. Per verificare se un hash è corretto, puoi usare:

if (Hash :: check ($ plaintext_password, $ hashed_password) == true) echo 'La password è corretta.';

Accesso a un utente

Per questo, usiamo il auth La biblioteca di tentativo metodo. Prima di ciò, però, costruiamo a $ credenziali array, che è un array associativo con a nome utente e parola d'ordine indici:

$ credentials = array ('username' => '[email protected]', 'password' => 'yourpassword'); if (Auth :: attempt ($ credentials == true) echo 'L'utente ha effettuato l'accesso';  else echo 'Credentials failed';

È importante tenere presente che, una volta che un tentativo è "riuscito", l'utente viene automaticamente registrato.

Accedi a un utente in / out

A volte, dovremo accedere a un utente senza utilizzare il tentativo metodo (ad esempio quando si accede a un utente da un collegamento all'interno di un'e-mail o dopo la registrazione). Possiamo farlo con il Auth :: login metodo:

Auth :: login ($ user); // dove $ user è un oggetto User Auth :: login (42); // dove 42 è l'ID dell'utente

D'altra parte, abbiamo anche un Auth :: Logout metodo per la registrazione degli utenti:

Auth :: il logout ();

Questo interromperà la sessione dell'utente.

Recupero dei dati dell'utente connesso

Il Auth :: utente metodo ci permette di recuperare l'oggetto utente connesso, così come ogni informazione ad esso allegata:

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

Configurare il `auth` biblioteca

Il auth la libreria deve essere configurata prima di usarla (sebbene i valori predefiniti funzionino con la maggior parte dei progetti, come questo). Le variabili di configurazione sono:

autista - questo può essere o eloquente o fluente. Gli sviluppatori possono scrivere i propri driver estendendo il autista classe in laravel / auth / drivers.
nome utente - questo è il nome della colonna di qualunque cosa rappresenta il "nome utente" dell'utente nella tabella del database.
modello - quando si usa Eloquent, questa è la classe del modello che il auth libreria usa
tavolo - quando si utilizza il driver di autenticazione Fluent, questo determina la tabella del database per gli utenti nell'applicazione

Il nostro progetto, Instapics, utilizza i valori predefiniti in auth.php file di configurazione, quindi non abbiamo bisogno di cambiare nulla in esso.

Tornando al progetto, prova a testare le funzionalità di login / registrazione di Instapics! Abbastanza carino, eh? Noterai però che non abbiamo nulla in Cruscotto controller ancora, quindi lavoriamo su quello successivo.

Passaggio 5: creare la dashboard Instapics

La prima cosa che dobbiamo fare è creare il Cruscotto controller, con il indice azione. Crea il file application / controller / dashboard.php e inserisci il seguente codice:

class Dashboard_Controller estende Base_Controller public function action_index () $ photos = Auth :: user () -> photos () -> order_by ('created_at', 'desc') -> order_by ('id', 'desc') - > get (); return View :: make ('dashboard.index', array ('photos' => $ foto));

Ora dobbiamo creare la pagina indice di Dashboard. Creare application / views / cruscotto / index.blade.php e aggiungi quanto segue:

@layout ('layouts / main') @section ('navigazione') @parent Disconnettersi
 @endsection @ section ('contenuto')     Seguaci
 
  @forelse (Auth :: user () -> followers come $ follower)   
 @vuoto Non hai seguaci.
 @endforelse 
 
  A seguire
 
  @forelse (Auth :: user () -> following as $ following)   
 @vuoto Non stai seguendo nessuno.
 @endforelse 
 
 
 
  Le tue foto
 @forelse ($ foto come $ foto)   $ foto-> descrizione
 
 @vuoto  awww!
 Sembra che tu non abbia ancora nessuna foto. Carica uno nuovo?
 
 @endforelse 
 
 @endsection

Aggiorna la pagina dashboard, dovresti vedere questo:

Stai cercando un po 'nudo? Aggiungi questo al Cruscotto controller ed eseguirlo accedendo cruscotto / insert_test_data sul tuo browser:

funzione pubblica action_insert_test_data () $ logged_in_user = Auth :: user (); for ($ x = 0; $ x < 10; $x++ )  $email = rand().'@gmail.com'; $user = new User(); $user->email = $ email; $ user-> password = Hash :: make ($ email); $ User-> save (); $ Logged_in_user-> seguaci () -> allegare ($ user-> id); if ($ x> 5) $ logged_in_user-> following () -> attach ($ user-> id);  $ photos = array (array ('user_id' => $ logged_in_user-> id, 'location' => 'http://farm6.staticflickr.com/5044/5319042359_68fb1f91b4.jpg', 'description' => 'Dusty Ricordi, La ragazza nel berretto nero (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' => 'Sunset, Funset, Nikko Bautista (http://www.flickr. it / photos / nikkobautista /) ')); $ Logged_in_user-> foto () -> save ($ foto);

Quando aggiorni la pagina, vedrai come appare con i dati di esempio inseriti:

Conclusione

Nella seconda parte del nostro laravel serie, abbiamo imparato:

Qualche retroscena su cosa sono i "Modelli"

Codice