Bouw webapps van Scratch with Laravel - The Weldadige ORM

In deze Nettuts + miniserie bouwen we een geheel nieuwe webtoepassing, terwijl we duiken in een geweldig nieuw PHP-framework dat snel stoom oppikt, genaamd Laravel.

In deze les werken we aan een integraal onderdeel van elke webtoepassing: de modellen. Onderweg komen we te weten over de geweldige ORM-implementatie van Laravel: Welsprekend.

Beoordeling

Welkom bij ons Webapplicaties van Scratch met Laravel serie! In de eerste tutorial van de serie hebben we veel geleerd over Laravel en zijn filosofie:

Wat Laravel is
Wat maakt Laravel anders dan andere PHP-frameworks
Waar te Laravel downloaden
Hoe Laravel in te stellen
Hoe Laravel's routing-systeem werkt
Enkele andere functies in Laravel's Routing-systeem
Hoe je je eerste Laravel Controller maakt
Enkele extra functies met Laravel's controllers
Hoe u uw eerste Laravel-weergave maakt
Hoe Laravel's Blade Templating Engine te gebruiken

Als je het nog niet hebt gelezen, moet je de vorige zelfstudie bekijken en deze lezen - dit maakt het gemakkelijker om de filosofie achter Laravel te begrijpen en de meeste dingen die we in deze zelfstudie bespreken.

In dit tweede deel van de Laravel-serie zullen we een cruciaal onderdeel van onze testwebtoepassing bouwen, Instapics, wat de Model-implementatie is. Zonder meer, laten we beginnen!

Wat zijn "Modellen"?

Ik heb al een beetje over wat gesproken modellen zijn in een van mijn vorige artikelen, Zend Framework van Scratch - Models en Integrating Doctrine ORM, dus om mezelf niet te herhalen te herhalen, zal ik de essentie schrijven van wat ik hier eerder heb geschreven. Raadpleeg de andere zelfstudie en lees meer over welke modellen er zijn.

Samenvatting:

Modellen zijn vertegenwoordigers van de database en moeten de plaats zijn waar alle bedrijfslogica van een applicatie zich bevindt
Controllers communiceren met modellen en vragen hen informatie op te halen die ze nodig hebben
Deze informatie wordt vervolgens door een controller doorgegeven aan de weergave en weergegeven
Het komt zelden voor dat een model rechtstreeks in wisselwerking staat met een weergave, maar soms kan het gebeuren wanneer dat nodig is
Modellen kunnen met andere modellen praten en zijn niet op zichzelf staand. Ze hebben relaties die met elkaar verstrengelen
Deze relaties maken het gemakkelijker en sneller voor een controller om informatie te krijgen, omdat deze niet hoeft te communiceren met verschillende modellen - de modellen kunnen dat zelf doen

Modellen in Laravel, of in de meeste raamwerken, worden op dezelfde manier ontwikkeld. Het verschil is dat Laravel ons een eenvoudige manier geeft om deze modellen te bouwen, door ons algemene methoden te bieden die de meeste modellen nodig hebben: de Weldadige ORM.

De uitbundige ORM

Een ORM is een object-relationele mapper en Laravel heeft er een waar je absoluut dol op zal zijn! Het heeft de naam "Eloquent", omdat het u toestaat om met uw databaseobjecten en -relaties te werken met behulp van een welsprekende en expressieve syntaxis.

De Eloquent ORM is de ingebouwde ORM-implementatie van Laravel. Naar mijn mening is het een van de beste ORM-implementaties die ik tot nu toe heb gezien - zelfs in de vorm van Doctrine ORM. Het is ongelooflijk elegant en maakt gebruik van standaardconventies om de configuratie te verminderen.

Conventies

Als u bijvoorbeeld een Eloquent-model gebruikt, wordt ervan uitgegaan dat de tabel die het model vertegenwoordigt, een ID kaart veld. De ID kaart is de primaire sleutel voor elk record en wordt gebruikt door de meeste methoden van Eloquent.

Een ander ding dat Eloyquent terecht veronderstelt, is dat uw tabelnaam de meervoudsvorm van uw model is. Bijvoorbeeld uw Gebruiker model zal verwijzen naar de gebruikers tafel. Omdat dit voor sommigen misschien niet altijd de standaard is, biedt Laravel een manier om dit op te heffen: gebruik gewoon de $ table vlag:

class User breidt Eloquent uit public static $ table = 'my_users';

Dit zal Laravel instrueren om de conventie niet te gebruiken en in plaats daarvan de gespecificeerde tabel te gebruiken.

Ten slotte kan Laravel ook het maken en bijwerken van tijdstempels voor ons automatiseren. Voeg hiervoor een toe gemaakt bij en / of updated_at kolom in de tabel en stel de $ timestamp vlag in het model:

class User breidt Eloquent uit public static $ timestamps = true;

Weldadig ziet de vlag en stelt automatisch de gemaakt bij veld bij het maken en update het updated_at veld telkens wanneer een record wordt bijgewerkt. Best cool, he?

Snel ophalen

Ophalen van records is een fluitje van een cent met de ophaalmethoden van Eloquent. U moet bijvoorbeeld een specifiek gebruikersrecord vinden? Gewoon doen:

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

Dit levert a Gebruiker model waarop je operaties kunt uitvoeren! Moet conditionals worden gebruikt? Laten we ons voorstellen dat u een gebruiker per e-mailadres wilt ophalen. Om deze taak te volbrengen, zou je iets als kunnen doen:

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

Als alternatief kunt u de dynamische methoden van Laravel gebruiken:

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

Eenvoudige invoegingen & updates

Het invoegen en bijwerken van modellen met behulp van Eloquent kan in drie stappen worden voltooid.

Stap 1 - Maak / Maak het model.

 $ user = new User (); // of krijg een bestaande gebruiker $ user = User :: get ($ user_id);

Stap 2 - Stel de gegevens in

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

Stap 3 - Opslaan
```
 $ Gebruiksvriendelijkheid> save ();
```
Gedaan!

En ten slotte, relaties definiëren.

Eloquent maakt het proces van het definiëren van relaties en het ophalen van gerelateerde modellen eenvoudig en intuïtief.

Verdomd goed toch! Eloquent ondersteunt drie soorten relaties:

Een op een
Een te veel
Veel te veel

Om een relatie tussen modellen te definiëren, moet u een methode maken in beide modellen die hun relaties "beschrijven". Laten we bijvoorbeeld zeggen a Gebruiker heeft een Gebruikersprofiel. U kunt dat doen door a te definiëren gebruikersprofiel methode in de Gebruiker model:

class User breidt Eloquent uit public function user_profile () return $ this-> has_one ('User_Profile');

Omdat Gebruiker is ons "dominante" model hier (dat wil zeggen, een gebruiker heeft een profiel en geen profiel heeft een gebruiker), we definiëren dat een Gebruikersprofiel hoort bij een Gebruiker:

class User_Profile breidt Eloquent uit public function user () return $ this-> belong_to ('User');

Zodra we deze relatie hebben gedefinieerd, kunnen we het volgende doen:

/ * Verkrijg het User_Profile-object van een gebruiker Dit voert twee SQL-query's uit: SELECT * FROM 'gebruikers' WHERE 'id' = $ user_id SELECT * FROM 'user_profiles' WHERE 'user_id' = $ user_id * / $ user = User :: find ($ user_id); $ user_profile = $ user-> user_profile; / * We kunnen het ook andersom doen * / $ user_profile = User_Profile :: where ('user_id', '=', $ user_id) -> first (); $ user = $ user_profile-> gebruiker;

Een ding dat het vermelden waard is, is een andere conventie: Eloquent gaat ervan uit dat de externe sleutel is gebruikt in Gebruikersprofiel is de naam van de tabel waarnaar wordt verwezen + _ID kaart. Nogmaals, als u dit gedrag wilt wijzigen, kunt u het overschrijven:

class User breidt Eloquent uit public function user_profile () return $ this-> has_one ('User_Profile', 'user_profile_user_id');

Laten we zeggen dat we de relatie tussen een Gebruiker en zijn Foto uploads. Dit is een Een te veel relatie, in tegenstelling tot de Gebruiker-naar-Gebruikersprofiel relatie die was Een op een. We kennen die Gebruiker heeft veel Foto uploadt, dus:

class User breidt Eloquent uit public function photos () return $ this-> has_many ('Photo');  ... class Photo breidt Eloquent uit public function user () return $ this-> belong_to ('User');

Het belangrijkste verschil hier met heeft een is dat de functie die we zullen gebruiken om a op te halen Gebruikerde foto's komen nu terug rangschikking van Foto voorwerpen. Dus als we alle a wilden ophalen Gebruiker's foto's, kunnen we doen:

$ photos = User :: find ($ user_id) -> foto's; foreach ($ foto's als $ foto) ...

Nee, verwijzend naar foto's als een eigenschap is geen typfout. Laravel geeft ons dit leuke stukje suiker. We zouden ook kunnen doen:

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

Mant-to-many relaties

Deze is een beetje lastig, maar eenmaal geïmplementeerd, maakt het het gemakkelijk te hanteren Veel te veel relaties tussen modellen. Laten we ons bijvoorbeeld voorstellen dat u, opnieuw, een Gebruiker model, en elk van deze gebruikers kan meerdere hebben groepen. EEN Groep kan ook meerdere hebben gebruikers. We gebruiken drie tabellen om deze specifieke relaties te representeren:

gebruikers - tabel waar al onze gebruikers zijn
groepen - tafel waar al onze groepen zijn
Groepsgebruiker - tabel met alle gebruikers in een groep

De conventie waar de tafelstructuur van Eloquent op zal letten, is zoiets als dit:

gebruikers
- ID kaart
- ... andere kolommen
groepen
- ID kaart
- ... andere kolommen
group_user
- ID kaart
- gebruikersnaam
- group_id
- ... andere kolommen

Een andere conventie die hier op te merken is, is dat de tussentafel, group_user, zijn de enkelvoudige namen van de twee tabellen die het verbindt, alfabetisch gerangschikt met een onderstrepingsteken. Zoals altijd zijn we vrij om dit te overschrijven.

Hier ziet u hoe de code in elk van de modellen voor deze drie tabellen verschijnt:

class User breidt Eloquent public function groups () // uit als we de standaard benamingconventie // voor de tussentabel willen overschrijven, we kunnen het als volgt doen: // return $ this-> has_many_and_belongs_to ('Group', ' group_listings); return $ this-> has_many_and_belongs_to ('Group');  ... class Group breidt Eloquent uit public function users () // als we de standaardbenamingconventie voor de tussenliggende tabel willen negeren // kunnen we het als volgt doen: // return $ this-> has_many_and_belongs_to ('User ',' group_listings '); return $ this-> has_many_and_belongs_to ('User');  ... class Group_User breidt Eloquent uit public function group () return $ this-> has_one ('Group');  public function user () return $ this-> has_one ('User');

Met dit op zijn plaats, kunnen we dan profiteren van de relatie-functies van Eloquent:

// Krijg de groepen van een gebruiker $ groups = User :: find ($ user_id) -> groups; // Haal alle gebruikers in een groep $ users = Group :: find ($ group_id) -> users;

Stap 1 - De Instapics-database maken

Verder gaan met onze webapplicatie, Instapics, laten we beginnen met het creëren van de database van onze applicatie. Om dit te doen, laten we de gewenste functionaliteiten van de applicatie noteren:

Gebruikers kunnen inloggen en zich aanmelden voor een account
Gebruikers kunnen andere gebruikers volgen om foto's te zien die ze hebben geüpload
Gebruikers kunnen hun eigen foto uploaden en er een filter op toepassen
Gebruikers kunnen opmerkingen plaatsen en van foto's houden

Hieruit kunnen we de databasetabellen afleiden die we nodig hebben:

gebruikers
- id (One-to-One met user_profiles.user_id, Many-to-Many met zelfgebruikende tussentabelrelaties.follower_id en gevolgd_id, One-to-Many met photos.user_id en photo_comments.user_id)
- e-mail
- wachtwoord
- gemaakt bij
- updated_at
gebruikersprofielen
- ID kaart
- user_id (One-to-One met gebruikers.id)
- naam
- profielfoto
relaties
- ID kaart
- follower_id (één op één met gebruikers.id)
- gevolgd_id (een-op-een met gebruikers.id)
- gemaakt bij
- updated_at
foto's
- id (One-to-Many met photo_comments.user_id)
- user_id (One-to-One met gebruikers.id)
- plaats
- Omschrijving
- gemaakt bij
- updated_at
photo_comments
- ID kaart
- user_id (One-to-One met gebruikers.id)
- photo_id (One-to-One met photos.id)
- bericht
- gemaakt bij
- updated_at

Laten we doorgaan en deze tabellen maken. Voor dit project zal ik gebruiken MySQL; voel je vrij om deze commando's te kopiëren en te plakken.

CREATE DATABASE 'instapics'; GEBRUIK 'instapics'; MAAK TAFEL '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'), UNIQUE INDEX 'Index_email' ('email')) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; MAAK TAFEL 'instapics'. 'User_profiles' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'naam' TEXT NOT NULL, 'profile_photo' TEXT NOT NULL, PRIMARY KEY ('id'), UNIEK INDEX 'Index_user_id' ('user_id'), CONSTRAINT 'FK_user_profiles_user_id' FOREIGN KEY 'FK_user_profiles_user_id' ('user_id') REFERENTIES 'gebruikers' ('id') OP VERWIJDEREN CASCADE OP UPDATE CASCADE) MOTOR = InnoDB KARAKTER SET utf8 COLLATE utf8_general_ci; MAAK TAFEL 'instapics'. 'Relaties' ('id' INTEGER NIET GEGEVEN NIET NULL AUTO_INCREMENT, 'follower_id' INTEGER NIET GEGEVEN NIET NULL, 'following_id' INTEGER NIET GEGEVEN NIET NULL, 'created_at' DATETIME NOT NULL, 'updated_at' DATETIME NOT NULL, PRIMARY KEY ('id'), UNIQUE INDEX 'Index_follower_id_followed_id' ('follower_id', 'follows_id'), CONSTRAINT 'FK_relationships_follower_id' FOREIGN KEY 'FK_relationships_follower_id' ('follower_id') REFERENCES 'users' ('id') OP VERWIJDEREN CASCADE OP UPDATE CASCADE, CONSTRAINT 'FK_relationships_followed_id' FOREIGN KEY 'FK_relationships_followed_id' ('follows_id') REFERENTIES 'gebruikers' ('id') OP VERWIJDEREN CASCADE OP UPDATE CASCADE) MOTOR = InnoDB KARAKTER SET utf8 COLLATE utf8_general_ci; MAAK TAFEL '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 ') REFERENTIES' gebruikers '(' id ') OP VERWIJDEREN CASCADE OP UPDATE CASCADE) MOTOR = InnoDB KARAKTER SET utf8 COLLATE utf8_general_ci; CREËER TAFEL 'instapics'. 'Photo_comments' ('id' INTEGER NIET GEGEVEN NIET NULL AUTO_INCREMENT, 'user_id' INTEGER NIET GEGEVEN NIET NULL, 'photo_id' INTEGER NIET GEGEVEN NIET NULL, 'message' TEXT NOT 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 ') OP VERWIJDEREN CASCADE OP UPDATE CASCADE, CONSTRAINT' FK_photo_comments_photo_id 'BUITENLANDSE SLEUTEL 'FK_photo_comments_photo_id' ('photo_id') REFERENTIES 'photos' ('id') OP VERWIJDEREN CASCADE OP UPDATE CASCADE) MOTOR = InnoDB KARAKTER SET utf8 COLLATE utf8_general_ci;

Je kunt ook migraties gebruiken, maar we zullen die in een volgende les bespreken.

Stap 2 - Stel Laravel's databaseconfiguratie in

Voordat we iets doen met Laravel-modellen, moeten we de databaseconfiguratie van onze Laravel-installatie instellen. Open application / config / database.php, om enkele van deze instellingen te vinden:

profiel - dit instellen op waar logt alle SQL-querie-tijden in de Laravel-logboeken. Laat dit zo waar voor nu.
halen - het type geretourneerde gegevens van PDO. Standaardwaarde is BOB :: FETCH_CLASS en zou zo moeten worden achtergelaten.
standaard - dit is de naam van de verbindingsinstellingen die door de toepassing worden gebruikt. De naam verwijst naar de index in de $ verbindingen array net onder
verbindingen - een associatieve array van de mogelijke verbindingen voor uw toepassing.
- bestuurder - het type databaseserver. Dit kan zijn pgsql, sqlite, mysql of sqlsrv
- gastheer - de hostnaam van uw databaseserver
- databank - de databasenaam
- gebruikersnaam - gebruikersnaam om te gebruiken op de databaseserver
- wachtwoord - wachtwoord om te gebruiken op de databaseserver
- charset - tekenset om te gebruiken op de databaseserver
- voorvoegsel - tabelvoorvoegsel op de database, indien aanwezig
redis - als je van plan bent Laravel's te gebruiken Redis bibliotheek, kunt u hier de serverinformatie instellen.

Voor deze tutorial gebruiken we MySQL. Jouw database.php bestand moet er ongeveer zo uitzien (ik heb de opmerkingen verwijderd, maar het zou goed moeten zijn om dit te bewaren):

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

Stap 3 - Uw eerste Laravel-model maken

Begin met het maken van een Laravel-model in de application / modellen map. creëren user.php binnen en voeg de volgende code toe:

class User breidt Eloquent uit

Nu, op basis van onze beoordeling van wat de GebruikerDe relaties zijn, we moeten de relatie-methoden coderen voor al deze:

class User breidt Eloquent uit // setting $ timestamp to true, dus Eloquent // zal automatisch de created_at // en updated_at values public static $ timestamps = true instellen; public function user_profile () return $ this-> has_one ('User_Profile');  openbare functie-volgers () return $ this-> has_many_and_belongs_to ('Gebruiker', 'relaties', 'gevolgd_id', 'follower_id');  public function following () return $ this-> has_many_and_belongs_to ('User', 'relationships', 'follower_id', 'follows_id');  openbare functiefoto's () return $ this-> has_many ('Photo');  public function photo_comment () return $ this-> has_many ('Photo_Comment');

Merkbaar maken we hier gebruik van een aantal geavanceerde Many-to-Many-functies, vanwege de tabelstructuur van ons volgermodel (d.w.z. de gebruikers tabel verwijst naar de relaties tabel die verwijst naar de gebruikers tafel opnieuw). De has_many_and_belongs_to functie heeft de volgende methodehandtekening:

/ ** * Ontvang de vraag voor een veel-op-veel relatie. * * @param string $ model * @param string $ table * @param string $ foreign * @param string $ other * @return Relationship * / public function has_many_and_belongs_to ($ model, $ table = null, $ foreign = null, $ other = null)

Hiermee kunnen we eigenlijk een model maken dat een veel-op-veel-relatie met zichzelf heeft (dat wil zeggen dat gebruikers andere gebruikers volgen). We gebruiken volgelingen en volgend op methode namen op de Gebruiker model om ons in staat te stellen volgers van een gebruiker te krijgen of om alle gebruikers te krijgen die een enkele gebruiker volgt.

Volgens de Gebruiker model, maak de andere modellen. Als je klaar bent, zou je moeten hebben:

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

Deze bestanden staan in de Git-repository van de tutorial, dus als je ze liever downloadt, kun je deze hier vinden: https://github.com/nikkobautista/laravel-tutorial

Stap 4 - Creëer de gebruikersfuncties voor instapics

Laten we onze modellen gaan gebruiken door enkele van de gebruikersfuncties te maken die we in de applicatie nodig hebben. Ten eerste: gebruikersregistratie. Van de vorige zelfstudie hebben we al een gemaakt Registratie / aanmeldingsformulier op de startpagina. Op dit moment doet het niets, maar laten we het aansluiten op a Gebruiker controleur, waarmerken actie. creëren application / controllers / user.php met de volgende code:

class User_Controller breidt Base_Controller uit public function action_authenticate ()

Open application / views / home / index.blade.php en zoek naar het inlogformulier. Werk het formulier bij Lijn 18 indienen bij de action_authenticate () methode:

Teruggaan naar de User_Controller, laten we wat code plaatsen action_authenticate ():

class User_Controller breidt Base_Controller uit public function action_authenticate () $ email = Input :: get ('email'); $ wachtwoord = Input :: get ('wachtwoord'); $ new_user = Input :: get ('new_user', 'off'); if ($ new_user == 'on') try $ user = new User (); $ user-> email = $ email; $ user-> password = Hash :: make ($ wachtwoord); $ Gebruiksvriendelijkheid> save (); Auth :: login ($ user); return Redirect :: to ('dashboard / index');  catch (Uitzondering $ e) echo "Faield om nieuwe gebruiker te maken!";  else $ credentials = array ('gebruikersnaam' => $ email, 'password' => $ wachtwoord); if (Auth :: poging ($ credentials)) return Redirect :: to ('dashboard / index');  else echo "Aanmelden mislukt!";

Laten we opsplitsen wat we hier tot nu toe gedaan hebben:

Wij gebruiken de Invoer bibliotheek om de invoer van het ingediende formulier te krijgen
Als het $ new_user vlag is gecontroleerd, we maken een nieuwe Gebruiker, de ... gebruiken hachee bibliotheek om een gecodeerd wachtwoord te genereren.
Log in op het nieuwe Gebruiker met de Auth bibliotheek
Als het $ new_user vlag is uitgeschakeld, we maken een $ credentials array, en gebruik het met de Auth bibliotheek.
Als Auth :: poging is waar, dit betekent dat de inloggegevens correct waren en dat we zijn ingelogd
Anders betekent dit dat de inloggegevens verkeerd waren.
In beide scenario's omleiden naar de Dashboard controleur, inhoudsopgave actie wanneer succesvol, en echo een foutmelding als dat niet het geval is.

De invoerbibliotheek

De basisfunctie van de Invoer bibliotheek is om het ophalen van formuliergegevens mogelijk te maken. Bijvoorbeeld in de Gebruiker controller, we hebben gebruikt Input :: te krijgen ( 'e-mail'); om de e-mailwaarde van het formulier te krijgen. Het is belangrijk op te merken dat de krijgen methode wordt gebruikt voor alle typen verzoeken en niet alleen voor de $ _GET rangschikking.

Je kunt hier meer lezen over de Input-bibliotheek: http://laravel.com/docs/input#input

De Auth-bibliotheek

Laravel wordt geleverd met een eigen authenticatiemechanisme, de Auth bibliotheek. Het kan de volgende functies uitvoeren met betrekking tot gebruikersauthenticatie.

Een gehasht wachtwoord maken

We kunnen gebruik maken van de hachee bibliotheek zoals zo:

$ wachtwoord = hash: make ($ plaintext_password);

Met deze methode wordt een gezouten en gehasht wachtwoord voor een gebruiker gemaakt met behulp van de coderingssleutel die we in het configuratiebestand hebben ingesteld. Om te controleren of een hash correct is, kunt u het volgende gebruiken:

if (Hash :: check ($ plaintext_password, $ hashed_password) == true) echo 'Wachtwoord is correct.';

Inloggen bij een gebruiker

Hiervoor gebruiken we de Auth bibliotheek poging methode. Maar daarvoor hebben we een $ credentials array, een associatieve array met een gebruikersnaam en wachtwoord indexen:

$ credentials = array ('gebruikersnaam' => '[email protected]', 'password' => 'yourpassword'); if (Auth :: poging ($ credentials) == true) echo 'Gebruiker is ingelogd';  else echo 'Inloggegevens mislukt';

Het is belangrijk om in gedachten te houden dat wanneer een poging "succesvol" is, de gebruiker automatisch is ingelogd.

Loggin een gebruiker in / uit

Soms moeten we een gebruiker aanmelden zonder de poging methode (zoals wanneer u zich aanmeldt bij een gebruiker vanaf een link in een e-mail of na registratie). We kunnen dat doen met de Auth :: login methode:

Auth :: login ($ user); // waarbij $ user een User-object is Auth :: login (42); // waarbij 42 de ID van de gebruiker is

Aan de andere kant hebben we ook een Auth :: logout methode voor het loggen van gebruikers:

Auth :: logout ();

Hiermee wordt de sessie van de gebruiker beëindigd.

De ingelogde gebruikersgegevens ophalen

De Auth :: gebruiker Met deze methode kunnen we het ingelogde gebruikersobject en alle bijbehorende informatie ophalen:

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

De. Configureren `Auth` bibliotheek

De Auth bibliotheek moet worden geconfigureerd voordat deze wordt gebruikt (hoewel de standaardinstellingen bij de meeste projecten werken, zoals deze). De configuratievariabelen zijn:

bestuurder - dit kan een van beide zijn welsprekend of vloeiend. Ontwikkelaars kunnen hun eigen stuurprogramma's schrijven door het Bestuurder klasse in laravel / auth / drivers.
gebruikersnaam - dit is de kolomnaam van wat dan ook de 'gebruikersnaam' van uw gebruiker in de databasetabel vertegenwoordigt.
model- - bij het gebruik van Eloquent is dit de modelklasse die de Auth bibliotheek gebruikt
tafel - bij het gebruik van de Fluent-authenticatie-driver bepaalt dit de databasetabel voor de gebruikers in de toepassing

Ons project, Instapics, gebruikt de standaardwaarden in de auth.php configuratiebestand, dus we hoeven er niets in te veranderen.

Ga terug naar het project en probeer de login- / registratiefuncties van Instapics uit! Behoorlijk handig, hé? Je zult echter merken dat we niets hebben in de Dashboard controller, dus laten we daar nu aan werken.

Stap 5 - Creëer het Instapics-dashboard

Het eerste dat we moeten doen is het maken van de Dashboard controller, met de inhoudsopgave actie. Maak het bestand aan application / controllers / dashboard.php en zet in de volgende code:

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

Nu moeten we de indexpagina van het Dashboard maken. creëren application / views / dashboard / index.blade.php en voeg het volgende toe:

@layout ('lay-outs / main') @section ('navigatie') @parent Uitloggen
 @endsection @section ('inhoud')     Volgers
 
  @forelse (Auth :: user () -> volgers als $ volger)   
 @leeg Je hebt geen volgers.
 @endforelse 
 
  Volgend op
 
  @forelse (Auth :: user () -> volgt als $ volgende)   
 @leeg Je volgt niemand.
 @endforelse 
 
 
 
  Jouw foto's
 @forelse ($ foto's als $ foto)   $ foto-> beschrijving
 
 @leeg  Awww!
 Het lijkt erop dat je nog geen foto's hebt. Upload een nieuwe?
 
 @endforelse 
 
 @endsection

Ververs de dashboardpagina, je zou dit moeten zien:

Lijkt een beetje kaal? Voeg dit toe aan de Dashboard controller, en voer het uit door toegang te krijgen tot dashboard / insert_test_data in uw browser:

public function action_insert_test_data () $ logged_in_user = Auth :: user (); voor ($ x = 0; $ x < 10; $x++ )  $email = rand().'@gmail.com'; $user = new User(); $user->email = $ email; $ user-> password = Hash :: make ($ email); $ Gebruiksvriendelijkheid> save (); $ Logged_in_user-> volgers () -> bevestigen ($ gebruikers-> 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 Herinneringen, The Girl in the Black Beret (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, N



		
			
	   
	




Code