Construisez des applications Web à partir de zéro avec Laravel - L'OR éloquent

Dans cette mini-série Nettuts +, nous allons créer une application Web à partir de zéro, tout en plongeant dans un nouveau cadre génial pour PHP qui prend rapidement de l'ampleur, appelé Laravel..

Dans cette leçon, nous allons travailler sur une partie intégrante de toute application Web: les modèles. En chemin, nous en apprendrons davantage sur l'impressionnante mise en œuvre de l'ORM de Laravel: Eloquent.

La revue

Bienvenue à notre Applications Web à partir de zéro avec Laravel séries! Dans le premier tutoriel de la série, nous avons beaucoup appris sur Laravel et sa philosophie:

Laravel c'est quoi
Ce qui différencie Laravel des autres frameworks PHP
Où télécharger Laravel
Comment configurer Laravel
Comment fonctionne le système de routage de Laravel
Quelques autres fonctionnalités du système de routage de Laravel
Comment créer votre premier contrôleur Laravel
Quelques fonctionnalités supplémentaires avec les contrôleurs Laravel
Comment créer votre première vue Laravel
Comment utiliser le moteur de création de lame de Laravel

Si vous ne l'avez pas encore lu, vous devriez jeter un coup d'œil au didacticiel précédent et le lire - cela facilitera la compréhension de la philosophie de Laravel et de la plupart des sujets abordés dans ce didacticiel..

Dans cette deuxième partie de la série Laravel, nous allons construire une partie cruciale de notre application web de test, Instapics, qui est l'implémentation du modèle. Sans plus tarder, commençons!

Que sont les "modèles"?

J'ai déjà parlé un peu de ce que Des modèles sont dans un de mes articles précédents, Zend Framework de Scratch - Modèles et Integrating Doctrine ORM, alors pour éviter de me répéter, je vais écrire l'essentiel de ce que j'ai écrit auparavant. N'hésitez pas à consulter l'autre didacticiel et à en savoir plus sur les modèles disponibles..

Résumé:

Les modèles sont des représentants de la base de données. Ils doivent contenir toute la logique métier d'une application.
Les contrôleurs communiquent avec les modèles et leur demandent de récupérer les informations dont ils ont besoin
Ces informations sont ensuite transmises par un contrôleur à la vue et sont rendues.
Il est très rare qu'un modèle interagisse directement avec une vue, mais cela peut parfois arriver lorsque cela est nécessaire
Les modèles peuvent parler avec d'autres modèles et ne sont pas autonomes. Ils ont des relations qui s'entrelacent
Ces relations permettent aux contrôleurs d’obtenir des informations plus facilement et plus rapidement, car ils n’ont pas à interagir avec différents modèles - les modèles peuvent le faire eux-mêmes.

Les modèles dans Laravel, ou dans la plupart des cadres, sont développés de la même manière. La différence est que Laravel nous donne un moyen facile de construire ces modèles en nous fournissant des méthodes à usage général dont la plupart des modèles auraient besoin - la Eloquent ORM.

L'ORM Éloquent

Un ORM est un mappeur relationnel-objet, et Laravel en a un que vous allez adorer! Il s'appelle "Eloquent", car il vous permet de travailler avec vos objets de base de données et vos relations en utilisant une syntaxe éloquente et expressive..

Eloquent ORM est l'implémentation ORM intégrée de Laravel. À mon avis, c'est l'une des meilleures implémentations ORM que j'ai vues jusqu'à présent - rivalisant même avec Doctrine ORM. Il est incroyablement élégant et utilise des conventions standard pour réduire la configuration..

Conventions

Par exemple, l’utilisation d’un modèle Eloquent suppose que la table qu’il représente a une identifiant champ. le identifiant est la clé primaire de tout enregistrement et est utilisée par la plupart des méthodes Eloquent.

Eloquent suppose également que votre nom de table est la forme plurielle de votre modèle. Par exemple, votre Utilisateur le modèle référencera le utilisateurs table. Comme cela peut ne pas toujours être la norme pour certains, Laravel fournit un moyen de le remplacer: utilisez simplement le $ table drapeau:

La classe utilisateur étend Eloquent public static $ table = 'my_users';

Ceci indiquera à Laravel de ne pas utiliser la convention mais d'utiliser la table spécifiée.

Enfin, Laravel peut également automatiser la création et la mise à jour des horodatages pour nous. Pour ce faire, ajoutez un créé à et / ou updated_at colonne dans la table et définissez le $ horodatage drapeau dans le modèle:

la classe User étend Eloquent public static $ timestamps = true;

Eloquent verra le drapeau et définira automatiquement le créé à champ sur la création, et mettre à jour le updated_at champ chaque fois qu'un enregistrement est mis à jour. Plutôt cool, hein?

Récupération Rapide

La récupération des enregistrements est un jeu d'enfant avec les méthodes de récupération d'Eloquent. Par exemple, vous devez rechercher un enregistrement d'utilisateur spécifique? Il suffit de faire:

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

Cela retourne un Utilisateur modèle sur lequel vous pouvez effectuer des opérations! Besoin d'utiliser des conditionnels? Imaginons que vous souhaitiez récupérer un utilisateur par adresse électronique. Pour accomplir cette tâche, vous pouvez faire quelque chose comme:

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

Vous pouvez également utiliser les méthodes dynamiques de Laravel:

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

Inserts et mises à jour faciles

L'insertion et la mise à jour de modèles à l'aide d'Eloquent peuvent être réalisées en trois étapes..

Étape 1 - Obtenir / créer le modèle.

 $ utilisateur = nouvel utilisateur (); // ou récupère un utilisateur existant $ user = User :: get ($ user_id);

Étape 2 - Définir les données

 $ user-> email = '[email protected]'; $ utilisateur-> mot de passe = 'test1234';

Étape 3 - sauvegarder
```
 $ user-> save ();
```
Terminé!

Et enfin, définir les relations.

Eloquent rend le processus de définition des relations et de récupération des modèles associés simple et intuitif.

Bon sang c'est vrai! Eloquent prend en charge trois types de relations:

Un par un
Un à plusieurs
Plusieurs à plusieurs

Pour définir une relation entre les modèles, vous devez créer une méthode dans les deux modèles qui "décrit" leurs relations. Par exemple, disons un Utilisateur en a un Profil de l'utilisateur. Vous pouvez le faire en définissant un profil de l'utilisateur méthode dans le Utilisateur modèle:

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

Parce que Utilisateur est notre modèle "dominant" ici (c’est-à-dire qu’un utilisateur a un profil et pas un profil a un utilisateur), nous définissons le Profil de l'utilisateur appartient à une Utilisateur:

La classe User_Profile s'étend à Eloquent public function user () return $ this-> appartient_to ('User');

Une fois que nous avons défini ces relations, nous pouvons alors:

/ * Obtient l'objet User_Profile d'un utilisateur Cela exécute deux requêtes SQL: SELECT * FROM 'utilisateurs' WHERE 'id' = $ utilisateur_id SELECT * FROM 'profils_utilisateur' WHERE 'utilisateur_id' = $ utilisateur_id * / $ utilisateur = utilisateur :: find ($ user_id); $ user_profile = $ user-> user_profile; / * Nous pouvons également le faire dans le sens inverse * / $ user_profile = User_Profile :: where ('user_id', '=', $ user_id) -> first (); $ user = $ user_profile-> user;

Une autre chose à noter est une autre convention: Eloquent suppose que la clé étrangère utilisée dans Profil de l'utilisateur est le nom de la table référencée + _id. Encore une fois, si vous voulez changer ce comportement, vous pouvez le remplacer:

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

Disons que nous voulons définir la relation entre un Utilisateur et son Photo uploads. C'est un Un à plusieurs relation, contrairement à la Utilisateur-à-Profil de l'utilisateur relation qui était Un par un. Nous savons que celui Utilisateur a beaucoup Photo uploads, donc:

La classe User étend Eloquent photos de fonction publique () return $ this-> has_many ('Photo'); … La classe photo étend Eloquent fonction publique user () return $ this-> appartient_to ('Utilisateur');

La principale différence ici avec en a un est-ce que la fonction que nous allons utiliser pour récupérer un UtilisateurLes photos vont maintenant retourner un tableau de Photo objets. Donc, si nous voulions aller tous chercher UtilisateurLes photos, on pourrait faire:

$ photos = User :: find ($ user_id) -> photos; foreach ($ photos as $ photo) …

Non, se référant à Photos en tant que propriété n'est pas une faute de frappe. Laravel nous donne ce joli morceau de sucre. Nous pourrions aussi faire:

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

Relations Mant-to-Many

Celui-ci est un peu délicat, mais une fois implémenté, il est facile à manipuler Plusieurs à plusieurs relations entre les modèles. Imaginons, par exemple, que vous ayez à nouveau un Utilisateur modèle, et chacun de ces utilisateurs peut avoir plusieurs Groupes. UNE Groupe peut aussi avoir plusieurs Utilisateurs. Nous utiliserons trois tables pour représenter ces relations particulières:

Utilisateurs - table où tous nos utilisateurs sont
Groupes - table où tous nos groupes sont
Utilisateur du groupe - tableau qui répertorie tous les utilisateurs d'un groupe

La convention sur la structure de la table recherchée par Eloquent ressemblera à ceci:

utilisateurs
- identifiant
- … Autres colonnes
groupes
- identifiant
- … Autres colonnes
utilisateur_groupe
- identifiant
- identifiant d'utilisateur
- group_id
- … Autres colonnes

Une autre convention à noter ici est que la table intermédiaire, utilisateur_groupe, est le nom singulier des deux tables qu’il associe, classées par ordre alphabétique avec un tiret bas. Comme toujours, nous sommes libres de passer outre cela.

Voici comment le code apparaîtra dans chacun des modèles pour ces trois tables:

class User étend Eloquent public function groups () // si nous voulions redéfinir la convention de dénomination // par défaut pour la table intermédiaire, nous pouvons le faire comme suit: // return $ this-> has_many_and_belongs_to ('Group', ' group_listings '); return $ this-> has_many_and_belongs_to ('Groupe'); … Class Group étend Eloquent public function users () // si nous voulions remplacer la convention de dénomination par défaut // pour la table intermédiaire, nous pouvons le faire comme suit: // return $ this-> has_many_and_belongs_to ('User ',' group_listings '); return $ this-> has_many_and_belongs_to ('Utilisateur'); … Class Group_User étend Eloquent fonction publique group () return $ this-> has_one ('Groupe');  fonction publique user () return $ this-> has_one ('User');

Ceci mis en place, nous pouvons alors tirer parti des fonctions relationnelles d’Eloquent:

// Obtenir les groupes d'un utilisateur $ groups = User :: find ($ user_id) -> groups; // Obtient tous les utilisateurs d'un groupe $ users = Group :: find ($ group_id) -> users;

Étape 1 - Création de la base de données Instapics

Continuer avec notre application web, Instapics, Commençons par créer la base de données de notre application. Pour ce faire, notons les fonctionnalités souhaitées de l'application:

Les utilisateurs peuvent se connecter et s'inscrire pour un compte
Les utilisateurs peuvent suivre les autres utilisateurs pour voir les photos qu'ils ont téléchargées.
Les utilisateurs peuvent télécharger leur propre photo et y appliquer un filtre.
Les utilisateurs peuvent commenter et aimer les photos

Nous pouvons en déduire les tables de base de données nécessaires:

utilisateurs
- id (one-to-one avec user_profiles.user_id, plusieurs à plusieurs avec self à l'aide de la table intermédiaire relationships.follower_id et suivants_id, un à plusieurs avec photos.user_id et photo_comments.user_id)
- email
- mot de passe
- créé à
- updated_at
des profils d'utilisateurs
- identifiant
- user_id (One-to-One avec users.id)
- prénom
- photo de profil
des relations
- identifiant
- follower_id (One-to-One avec users.id)
- follow_id (One-to-One avec users.id)
- créé à
- updated_at
Photos
- id (un-à-plusieurs avec photo_comments.user_id)
- user_id (One-to-One avec users.id)
- emplacement
- la description
- créé à
- updated_at
photo_comments
- identifiant
- user_id (One-to-One avec users.id)
- photo_id (One-to-One avec photos.id)
- message
- créé à
- updated_at

Allons-y et créons ces tables. Pour ce projet, je vais utiliser MySQL; n'hésitez pas à copier et coller ces commandes.

CREATE DATABASE 'instapics'; UTILISEZ 'instapics'; CREATE TABLE 'instapics'. 'Users' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'email' VARCHAR (100) NOT NULL, 'mot de passe' VARCHAR (100) NOT NULL, 'created_at' DATETIME NOT NULL, 'updated_at', DATETIME NOT NULL, PRIMARY KEY ('id'), INDEX UNIQUE 'Index_email' ('email')) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE 'instapics'. 'User_profiles' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'user_id' INTEGER UNSIGNED NOT NULL, 'nom' TEXT NOT NULL, 'profile_photo' TEXT NOT NULL, PRIMARY KEY ('id', UNIQUE INDEX 'Index_user_id' ('user_id'), CONSTRAINT 'FK_user_profiles_user_id' FOREIGN KEY 'FK_user_profiles_user_id' CREATE TABLE 'instapics'. 'Relations' ('id' INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 'follower_id' INTEGER UNSIGNED NOT NULL, 'following_id' INTEGER UNSIGNED NOT NULL, 'created_at' DATETIME NOT NULL, 'updated_at', 'updated_at' et NULL, PRIMARY KEY ('id'), INDEX UNIQUE 'Index_follower_id_followed_id' ('suiveur_id', 'suivie_id'), CONTRAINT 'FK_relationships_follower_id', le résultat de la recherche est le résultat de la recherche CASCADE, CONSTRAINT 'FK_relationships_followed_id' FOREIGN KEY 'FK_relationships_followed_id' ('suivie_id') REFERENCES 'utilisateurs' ('id') SUR SUPPRIMER CASCADE SUR UPDATE CASCADE) ENGINE = InnoDB CHARACTER CLEF8gg 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' utilisateurs '(' id ') ON DELETE CASCADE IN UPDATE CASCADE) MOTEUR = InnoDB CHARAC 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' TEXT NOT NULL, 'created_at' DATETIME NULL, ' updated_at 'DATETIME NOT NULL, PRIMARY KEY (' id '), CONSTRAINT' FK_photo_comments_user_id 'FOREIGN KEY' FK_photo_comments_user_id ',' utiliser_id ')' REFERENCES '(' id ')' 'FK_photo_comments_photo_id' ('photo_id') REFERENCES 'photos' ('id') ON EFFACER LA CASCADE SUR LA MISE A JOUR CASCADE) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;

Vous pouvez également utiliser les migrations, mais nous les passerons en revue dans une leçon future..

Étape 2 - Configuration de la configuration de la base de données de Laravel

Avant de faire quoi que ce soit avec les modèles Laravel, nous devons configurer la configuration de la base de données de notre installation Laravel. Ouvrir application / config / database.php, pour trouver certains de ces paramètres:

profil - mettre ceci à vrai enregistrera tous les temps d'interrogation SQL dans les journaux Laravel. Laissez ceci comme vrai pour l'instant.
aller chercher - le type de données renvoyées par PDO. La valeur par défaut est PDO :: FETCH_CLASS et devrait être laissé comme si.
défaut - c'est le nom des paramètres de connexion utilisés par l'application. Le nom fait référence à l'index dans le $ connexions tableau juste en dessous
les liaisons - un tableau associatif des connexions possibles pour votre application.
- chauffeur - le type de serveur de base de données. Cela peut être pgsql, sqlite, mysql ou sqlsrv
- hôte - le nom d'hôte de votre serveur de base de données
- base de données - le nom de la base de données
- Nom d'utilisateur - nom d'utilisateur à utiliser sur le serveur de base de données
- mot de passe - mot de passe à utiliser sur le serveur de base de données
- jeu de caractères - jeu de caractères à utiliser sur le serveur de base de données
- préfixe - préfixe de table sur la base de données, le cas échéant
redis - si vous envisagez d'utiliser Laravel Redis bibliothèque, vous pouvez configurer les informations du serveur ici.

Pour les besoins de ce tutoriel, nous utiliserons MySQL. Votre database.php Le fichier devrait ressembler à ceci (j'ai supprimé les commentaires, mais ils devraient pouvoir être conservés):

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

Étape 3 - Création de votre premier modèle Laravel

Commencez par créer un modèle Laravel à l’intérieur du application / modèles dossier. Créer user.php à l'intérieur, et ajoutez le code suivant:

La classe User étend Eloquent

Maintenant, sur la base de notre examen de ce que le UtilisateurLes relations sont, nous devons coder les méthodes de relation pour chacun d'eux:

class User étend Eloquent // en définissant $ timestamp sur true afin que Eloquent // définisse automatiquement les valeurs created_at // et updated_at public static $ $ timestamps = true; fonction publique user_profile () return $ this-> has_one ('User_Profile');  public function followers () return $ this-> has_many_and_belongs_to ('Utilisateur', 'relations', 'suivi_id', 'suiveur_id');  fonction publique following () return $ this-> has_many_and_belongs_to ('Utilisateur', 'relations', 'id_du_procédé', 'id_succédé');  photos de fonction publique () return $ this-> has_many ('Photo');  fonction publique photo_comment () return $ this-> has_many ('Photo_Comment');

De manière remarquable, nous utilisons ici certaines fonctionnalités avancées Plusieurs-à-Plusieurs, en raison de la structure de table de notre modèle suiveur (c’est-à-dire le utilisateurs le tableau fait référence à la des relations tableau qui référence le utilisateurs table à nouveau). le has_many_and_belongs_to function a la signature de méthode suivante:

/ ** * Récupère la requête pour une relation plusieurs à plusieurs. * * @param string $ modèle * @param string $ table * @param chaîne $ foreign * @param chaîne $ other * @return Relation * / fonction publique has_many_and_belongs_to ($ model, $ table = null, $ foreign = null, $ other = null)

Cela nous permet en fait de créer un modèle qui entretient une relation plusieurs à plusieurs avec lui-même (les utilisateurs suivent les autres utilisateurs). Nous utilisons suiveurs et Suivant noms de méthodes sur le Utilisateur modèle pour nous permettre d’obtenir les abonnés d’un utilisateur ou tous les utilisateurs qu’un seul utilisateur suit, respectivement.

Suivant le Utilisateur modèle, créez les autres modèles. Lorsque vous avez terminé, vous devriez avoir:

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

Ces fichiers seront dans le référentiel Git du tutoriel. Si vous préférez les télécharger, vous pouvez les trouver ici: https://github.com/nikkobautista/laravel-tutorial

Étape 4 - Créer les fonctions utilisateur pour Instapics

Commençons par utiliser nos modèles en créant certaines des fonctions utilisateur dont nous aurons besoin dans l'application. Tout d'abord: l'enregistrement de l'utilisateur. À partir du tutoriel précédent, nous avons déjà créé un Formulaire d'inscription / connexion sur la page d'accueil. Pour le moment, cela ne fait rien, mais relions-le à un Utilisateur manette, authentifier action. Créer application / controllers / user.php avec le code suivant:

class User_Controller étend Base_Controller fonction publique action_authenticate ()

Ouvrir application / views / home / index.blade.php et cherchez le formulaire de connexion. Mettre à jour le formulaire sur Ligne 18 soumettre à la action_authenticate () méthode:

Retour à la User_Controller, plaçons du code dans action_authenticate ():

class User_Controller étend Base_Controller fonction publique action_authenticate () $ email = Input :: get ('email'); $ password = Input :: get ('mot de passe'); $ new_user = Input :: get ('new_user', 'off'); if ($ new_user == 'on') try $ user = new User (); $ utilisateur-> email = $ email; $ utilisateur-> mot de passe = Hash :: make ($ mot de passe); $ user-> save (); Auth :: login ($ user); return Redirect :: to ('tableau de bord / index');  catch (Exception $ e) echo "Faield pour créer un nouvel utilisateur!";  else $ credentials = array ('username' => $ email, 'password' => $ password); if (Auth :: tentative ($ credentials)) return Redirect :: to ('tableau de bord / index');  else echo "Echec de la connexion!";

Décrivons ce que nous avons fait jusqu'ici:

Nous utilisons le Contribution bibliothèque pour obtenir les entrées du formulaire soumis
Si la $ new_user le drapeau a été coché, nous créons un nouveau Utilisateur, en utilisant le Hacher bibliothèque pour générer un mot de passe crypté.
Connectez-vous à la nouvelle Utilisateur avec le Auth bibliothèque
Si la $ new_user le drapeau était décoché, nous créons un $ informations d'identification tableau, et l'utiliser avec le Auth bibliothèque.
Si Auth :: tentative est vrai, cela signifie que les informations d'identification étaient correctes et nous sommes connectés
Sinon, cela signifie que les informations d'identification étaient fausses.
Dans les deux scénarios, redirigez vers le Tableau de bord manette, indice action en cas de succès, et renvoie un message d'échec sinon.

La bibliothèque d'entrée

La fonction de base de la Contribution La bibliothèque doit permettre la récupération des données de formulaire. Par exemple, dans le Utilisateur contrôleur, nous avons utilisé Input :: get ('email'); pour obtenir la valeur email du formulaire. Il est important de noter que le obtenir Cette méthode est utilisée pour tous les types de requêtes et pas seulement pour $ _GET tableau.

Vous pouvez en savoir plus sur la bibliothèque d’entrée ici: http://laravel.com/docs/input#input

La bibliothèque d'auth

Laravel est livré avec son propre mécanisme d’authentification, le Auth bibliothèque. Il peut faire les fonctionnalités suivantes en ce qui concerne l'authentification de l'utilisateur.

Créer un mot de passe haché

Nous pouvons utiliser le Hacher bibliothèque comme si:

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

Cette méthode crée un mot de passe salé et haché pour un utilisateur, à l'aide de la clé de cryptage définie dans le fichier de configuration. Pour vérifier si un hachage est correct, vous pouvez utiliser:

if (Hash :: check ($ texte_de_passetexte, $ mot_de_passe_hashed) == true) echo 'Le mot de passe est correct.';

Se connecter à un utilisateur

Pour cela, nous utilisons le Auth bibliothèque tentative méthode. Avant cela, cependant, nous construisons un $ informations d'identification tableau, qui est un tableau associatif avec un Nom d'utilisateur et mot de passe index:

$ credentials = array ('username' => '[email protected]', 'motdepasse' => 'votre mot de passe'); if (Auth :: tentative ($ credentials) == true) echo 'L'utilisateur est connecté';  else echo 'Les informations d'identification ont échoué';

Il est important de garder à l'esprit qu'une fois la tentative "réussie", l'utilisateur est automatiquement connecté..

Connecter un utilisateur in / out

Parfois, nous devrons connecter un utilisateur sans utiliser le tentative méthode (par exemple, lors de la connexion d’un utilisateur à partir d’un lien contenu dans un courrier électronique, ou après l’enregistrement). Nous pouvons le faire avec le Auth :: login méthode:

Auth :: login ($ user); // où $ user est un objet User Auth :: login (42); // où 42 est l'ID de l'utilisateur

D'autre part, nous avons aussi un Auth :: déconnexion méthode de déconnexion des utilisateurs:

Auth :: logout ();

Cela mettra fin à la session de l'utilisateur.

Récupérer les données de l'utilisateur connecté

le Auth :: utilisateur Cette méthode nous permet de récupérer l’objet utilisateur connecté, ainsi que toutes les informations qui lui sont associées:

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

Configuration du `Auth` bibliothèque

le Auth La bibliothèque doit être configurée avant de l’utiliser (bien que les valeurs par défaut fonctionnent avec la plupart des projets, comme celui-ci). Les variables de configuration sont:

chauffeur - cela peut être soit éloquent ou courant. Les développeurs peuvent écrire leurs propres pilotes en étendant la Chauffeur cours en laravel / auth / drivers.
Nom d'utilisateur - c'est le nom de colonne de ce qui représente le "nom d'utilisateur" de votre utilisateur dans la table de base de données.
modèle - lorsqu’on utilise Eloquent, c’est la classe modèle que le Auth utilisations de la bibliothèque
table - lors de l'utilisation du pilote d'authentification Fluent, cela détermine la table de base de données pour les utilisateurs de l'application

Notre projet, Instapics, utilise les valeurs par défaut dans le auth.php fichier de configuration, nous n'avons donc pas besoin de changer quoi que ce soit.

Pour revenir au projet, essayez de tester les fonctionnalités de connexion / enregistrement d’Instapics! Assez chouette, hein? Vous remarquerez que nous n'avons rien dans le Tableau de bord contrôleur encore, alors travaillons sur cette prochaine.

Étape 5 - Créer le tableau de bord Instapics

La première chose à faire est de créer le Tableau de bord contrôleur, avec le indice action. Créer le fichier application / controllers / dashboard.php et mettre dans le code suivant:

class Dashboard_Controller étend Base_Controller fonction publique action_index () $ photos = Auth :: user () -> photos () -> order_by ('created_at', 'desc') -> order_by ('id', 'desc') - > get (); return View :: make ('dashboard.index', array ('photos' => $ photos));

Nous devons maintenant créer la page d'index du tableau de bord. Créer application / views / dashboard / index.blade.php et ajoutez ce qui suit:

@layout ('layouts / main') @section ('navigation') @parent Connectez - Out
 @endsection @section ('content')     Suiveurs
 
  @forelse (Auth :: user () -> followers en tant que $ follower)   
 @vide Vous n'avez pas d'adeptes.
 @endforelse 
 
  Suivant
 
  @forelse (Auth :: user () -> suivant comme $ suivant)   
 @vide Vous ne suivez personne.
 @endforelse 
 
 
 
  Tes photos
 @forelse ($ photos as $ photo)   $ photo-> description
 
 @vide  Awww!
 On dirait que vous n'avez pas encore de photos. Télécharger un nouveau?
 
 @endforelse 
 
 @endsection

Actualisez la page du tableau de bord, vous devriez voir ceci:

Vous cherchez un peu nu? Ajoutez ceci au Tableau de bord contrôleur et exécutez-le en accédant à tableau de bord / insert_test_data sur votre navigateur:

fonction publique a



		
			
	   
	




Code