Share
Il est difficile de nier le fait que la communauté PHP est enthousiasmée par Laravel 4. Entre autres choses, le framework exploite la puissance de Composer, ce qui signifie qu'il est capable d'utiliser n'importe quel package ou script de Packagist..
En attendant, Laravel propose des "Bundles", qui nous permettent de modulariser le code pour une utilisation dans des projets futurs. Le répertoire de bundle est rempli d'excellents scripts et packages que vous pouvez utiliser dans vos applications. Dans cette leçon, je vais vous montrer comment en construire un.!
Les offres groupées offrent un moyen simple de regrouper les codes associés. Si vous connaissez CodeIgniter, les bundles ressemblent beaucoup à "Sparks". Ceci est évident quand vous regardez la structure des dossiers.
Créer un paquet est assez simple. Pour illustrer ce processus, nous construirons un passe-partout pour panneau d’administration que nous pourrons utiliser dans les projets futurs. Tout d'abord, nous devons créer un répertoire "admin" dans notre dossier "bundles". Essayez de répliquer la structure du dossier à partir de l'image ci-dessus.
Avant de commencer à ajouter quelque chose à notre paquet, nous devons d'abord l'enregistrer auprès de Laravel. Ceci est fait dans votre application bundles.php fichier. Une fois que vous avez ouvert ce fichier, vous devriez voir un tableau être retourné. nous devons simplement ajouter notre forfait et définir un manipuler. Cela deviendra l'URI dans lequel nous accéderons à notre panneau d'administration.
Accentsconagua
'admin' => array ('handles' => 'admin') Ici, j’ai nommé le mien "admin", mais n’hésitez pas à appeler le vôtre comme vous le souhaitez.
Une fois que nous avons cette configuration, nous devons créer un start.php fichier. Ici, nous allons configurer quelques éléments, tels que nos espaces de noms. Si cela ne vous dérange pas, vous n'avez pas réellement besoin d'un fichier de démarrage pour que votre ensemble fonctionne, comme prévu..
La classe de chargement automatique de Laravel nous permet de faire plusieurs choses: mapper notre contrôleur de base et charger les espaces de noms.
Autoloader :: map (array ('Admin_Base_Controller' => Bundle :: path ('admin'). 'Controllers / base.php',)); Autoloader :: namespaces (array ('Admin \ Models' => Bundle :: path ('admin'). 'Models', 'Admin \ Libraries' => Bundle :: path ('admin'). 'Libraries', ) Namespacing garantira que nous n'entrons pas en conflit avec d'autres modèles ou bibliothèques déjà inclus dans notre application. Vous remarquerez que nous n'avons pas choisi de ne pas utiliser d'espaces de noms pour nos contrôleurs afin de faciliter les choses..
Pour le panneau d'administration, nous allons tirer parti de Bootstrap de Twitter, alors allez en prendre une copie. Nous pouvons faire ceci dans un Publique dossier à l'intérieur de notre forfait afin de publier sur notre application plus tard.
Lorsque vous êtes prêt à les publier, exécutez la commande suivante via artisan.
php artisan bundle: publ admin
Cela copiera la structure du dossier et les fichiers sur le liasses répertoire dans notre Publique dossier, à la racine de l’installation de Laravel. Nous pouvons ensuite l'utiliser dans le contrôleur de base de notre groupe.
Il est toujours judicieux de configurer un contrôleur de base et d’allonger à partir de là. Ici, nous pouvons configurer des contrôleurs reposants, définir la mise en page et inclure tous les actifs. Nous avons juste besoin d'appeler ce fichier, base.php, et le placer dans le répertoire de notre contrôleur.
Tout d'abord, faisons de l'entretien ménager. Nous voudrons bien sûr utiliser les contrôleurs reposants de Laravel.
public $ reposant = vrai;
Et nous allons spécifier une mise en page que nous allons créer sous peu. Si vous n'êtes pas habitué à la disposition des contrôleurs, alors vous êtes prêt pour un régal.
public $ layout = 'admin :: layouts.main';
Le nom du paquet, suivi de deux points, est un paradigme à Laravel, nous en verrons plus dans le futur, alors gardez un œil sur.
Lorsque vous gérez des actifs au sein de notre groupe, nous pouvons procéder comme prévu et spécifier le chemin à partir de la racine du dossier public. Heureusement, Laravel est là pour nous faciliter la vie. Dans notre construction, nous devons spécifier le paquet avant d'ajouter à nos conteneurs d'actifs.
Asset :: container ('header') -> bundle ('admin'); Asset :: container ('footer') -> bundle ('admin'); Si vous ne connaissez pas les conteneurs de ressources, ne vous inquiétez pas. ce ne sont que des sections d'une page où vous souhaitez héberger vos actifs. Ici, nous allons inclure des feuilles de style dans l'en-tête et des scripts dans le pied de page..
Désormais, nous pouvons facilement inclure nos styles et scripts d’amorçage. Notre contrôleur de base complet doit ressembler à:
La classe Admin_Base_Controller étend le contrôleur public $ restful = true; public $ layout = 'admin :: layouts.main'; fonction publique __construct () parent :: __ construct (); Asset :: container ('header') -> bundle ('admin'); Asset :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); Asset :: container ('footer') -> bundle ('admin'); Asset :: container ('footer') -> add ('jquery', 'http://code.jquery.com/jquery-latest.min.js'); Asset :: container ('footer') -> add ('bootstrapjs', 'js / bootstrap.min.js'); / ** * Méthode unique pour les demandes qui ne peuvent pas être mises en correspondance. * * @param chaîne $ méthode * @param tableau $ paramètres * @return Réponse * / fonction publique __call ($ méthode, $ paramètres) return Response :: error ('404'); Nous avons également introduit la requête fourre-tout du contrôleur de base de l'application pour renvoyer une réponse 404 si une page était introuvable..
Avant de faire autre chose, créons le fichier pour cette mise en page, views / layout / main.blade.php, donc nous ne rencontrons pas d'erreurs plus tard.
Alors que nous construisons un panneau d’administration, nous allons vouloir garder les gens à l’écart. Heureusement, nous pouvons utiliser le système intégré de Laravel Auth classe pour y arriver avec facilité…
Premièrement, nous devons créer notre table. Je vais utiliser "administrateurs" comme nom de table, mais vous pouvez le changer si vous le souhaitez. Artisan va générer une migration et l'afficher dans le répertoire des migrations de notre groupe. Il suffit de lancer ce qui suit dans la ligne de commande.
php artisan migrate: make admin :: create_admins_table
Si vous ne connaissez pas bien le générateur de schéma, je vous recommande de consulter la documentation. Nous allons inclure quelques colonnes:
Nous allons également inclure les horodatages par défaut, afin de suivre les meilleures pratiques.
/ ** * Apporter des modifications à la base de données. * * @retour void * / public function up () Schema :: create ('admins', fonction ($ table) $ table-> increments ('id'); $ table-> chaîne de caractères ('nom', 200 ); $ table-> chaîne ('nom d'utilisateur', 32) -> unique (); $ table-> chaîne ('mot de passe', 64); $ table-> chaîne ('email', 320) -> unique () ; $ table-> string ('role', 32); $ table-> timestamps ();); / ** * Annule les modifications dans la base de données. * * @return void * / public function down () Schema :: drop ('admins'); Maintenant que notre structure de base de données est en place, nous devons créer un modèle associé pour la table. Ce processus est essentiellement identique à la manière dont nous pourrions accomplir cela dans notre application principale. Nous créons le fichier et le modèle en nous basant sur la forme singulière de notre nom de table - mais nous devons nous assurer que l'espace de nom est correct.
espace de noms Admin \ Models; utilisez \ Laravel \ Database \ Eloquent \ Model comme Eloquent; classe Admin étend Eloquent
Ci-dessus, nous nous sommes assurés d'utiliser l'espace de noms que nous avons défini dans start.php. De plus, pour que nous puissions correctement référencer Eloquent, nous créons un alias.
Pour que notre offre soit entièrement autonome, nous devrons étendre auth. Cela nous permettra de définir une table juste pour vous connecter à notre panneau d'administration, et ne pas interférer avec l'application principale.
Avant de créer notre pilote personnalisé, nous allons créer un fichier de configuration dans lequel vous pourrez choisir si vous souhaitez utiliser le logiciel. Nom d'utilisateur ou email colonnes de la table de base de données.
return array ('username' => 'username', 'password' => 'password',); Si vous voulez modifier les colonnes que nous allons utiliser, ajustez simplement les valeurs ici.
Nous devons ensuite créer le pilote. Appelons-le "AdminAuth" et incluons-le dans notre dossier de bibliothèques. Comme nous étendons Auth, nous n'avons besoin que d'écraser quelques méthodes pour que tout fonctionne, comme prévu.
espace de noms Admin \ Libraries; utilisez Admin \ Models \ Admin comme Admin, Laravel \ Auth \ Drivers \ Eloquent comme Eloquent, Laravel \ Hash, Laravel \ Config; La classe AdminAuth s'étend Eloquent / ** * Récupère l'utilisateur actuel de l'application. * * Si l'utilisateur est un invité, null doit être renvoyé. * * @param int | objet $ token * @return mixed | null * / fonction publique retrieve ($ token) // Nous renvoyons un objet ici si le jeton transmis est un entier (ID) // ou si nous sommes passés un objet modèle du type correct if (filter_var ($ token, FILTER_VALIDATE_INT)! == false) return $ this-> model () -> find ($ token); else if (get_class ($ token) == nouvel administrateur) return $ token; / ** * Essayez de connecter un utilisateur à l'application. * * @param array $ arguments * @return void * / tentative de fonction publique ($ arguments = array ()) $ utilisateur = $ ceci-> modèle () -> où (fonction ($ requête) utilise ($ arguments) $ username = Config :: get ('admin :: auth.username'); $ requête-> où ($ username, '=', $ arguments ['username']]); foreach (array_except ($ arguments, array (' nom d'utilisateur ',' mot de passe ',' rappelez-vous ')) en tant que $ column => $ val) $ requête-> où ($ column,' = ', $ val);) -> first (); // Si les informations d'identification correspondent à ce qui se trouve dans la base de données, nous // connectons simplement l'utilisateur à l'application et nous nous en souviendrons si demandé. $ password = $ arguments ['password']; $ password_field = Config :: get ('admin :: auth.password', 'password'); if (! is_null ($ user) et Hash :: check ($ password, $ user -> $ password_field)) return $ this-> login ($ user-> get_key (), array_get ($ arguments, 'rappelez-vous ')); return false; function function model () retour new admin; Maintenant que nous avons créé le pilote, nous devons en informer Laravel. Nous pouvons utiliser Auth étendre méthode pour le faire dans notre start.php fichier.
Auth :: extend ('adminauth', function () retour new Admin \ Libraries \ AdminAuth;); Une dernière chose à faire est de configurer Auth pour l’utiliser au moment de l’exécution. Nous pouvons le faire dans le constructeur de notre contrôleur de base avec ce qui suit.
Config :: set ('auth.driver', 'adminauth'); Avant de pouvoir acheminer quoi que ce soit, nous devons créer un contrôleur. Créons notre contrôleur de tableau de bord, comme nous le verrons après la connexion.
Comme nous voulons que cela apparaisse à la racine de notre paquet (c'est-à-dire le descripteur que nous avons défini précédemment), nous devrons l'appeler home.php. Laravel utilise le mot clé 'home' pour établir ce que vous voulez afficher à la racine de votre application ou de votre bundle..
Étendez votre contrôleur de base et créez une vue d'index. Pour l'instant, retournez simplement 'Hello World' pour que tout fonctionne correctement.
La classe Admin_Home_Controller étend Admin_Base_Controller fonction publique get_index () return 'Hello World';
Maintenant que notre contrôleur est configuré, nous pouvons y accéder. Créer un routes.php dans votre forfait, si vous ne l'avez pas déjà fait. Semblable à notre application principale, chaque groupe peut avoir son propre fichier de routes qui fonctionne de manière identique..
Route :: controller (array ('admin :: home',)); Ici, j'ai enregistré le contrôleur domestique, que Laravel attribuera automatiquement à /. Plus tard, nous ajouterons notre contrôleur de connexion au tableau.
Si vous vous dirigez vers / admin (ou quel que soit le descripteur que vous avez défini précédemment) dans votre navigateur, alors vous devriez voir 'Hello World'.
Créons le contrôleur de connexion, cependant, plutôt que d’étendre le contrôleur de base, nous étendrons le contrôleur principal de Laravel. La raison derrière cette décision deviendra évident sous peu.
Parce que nous n’étendons pas, nous devons définir quelques éléments avant de commencer - à savoir des mises en page reposantes, le bon pilote d’authentification et nos actifs..
La classe Admin_Login_Controller étend le contrôleur public $ restful = true; fonction publique __construct () parent :: __ construct (); Config :: set ('auth.driver', 'adminauth'); Asset :: container ('header') -> bundle ('admin'); Asset :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); Créons aussi notre vue. Nous allons utiliser Blade - le moteur de templates de Laravel - pour accélérer les choses un peu. Dans votre répertoire de vues d'ensemble, créez un répertoire "login" et un fichier "index.blade.php"..
Nous allons insérer une structure de page HTML standard et faire écho aux actifs.
S'identifier Asset :: container ('header') -> styles ()
Maintenant, vérifions que la vue est en cours de création dans le contrôleur. Comme nous utilisons des contrôleurs reposants, nous pouvons tirer parti du verbe 'get' dans notre méthode.
fonction publique get_index () return View :: make ('admin :: login.index'); Impressionnant! Nous sommes maintenant bien pour commencer à construire notre forme, que nous pouvons créer avec le Forme classe.
Form :: open () Form :: label ('nom d'utilisateur', 'Nom d'utilisateur') Form :: text ('nom d'utilisateur') Form :: label ('mot de passe' , 'Password') Form :: password ('password') Form :: submit ('Login', array ('class' => 'btn btn-success')) Form :: token () Form :: close () 
Ci-dessus, nous avons créé un formulaire qui s'affichera lui-même (exactement ce que nous voulons), ainsi que divers éléments de formulaire et libellés qui vont avec. L'étape suivante consiste à traiter le formulaire.
Comme nous postons le formulaire sur lui-même et utilisons des contrôleurs reposants, nous devons simplement créer le post_index méthode et l'utiliser pour traiter notre login. Si vous n'avez jamais utilisé Auth auparavant, allez jeter un coup d'œil à la documentation avant de poursuivre..
fonction publique post_index () $ creds = array ('username' => Input :: get ('username'), 'password' => Input :: get ('password'),); if (Auth :: tentative ($ creds)) return Redirect :: to (URL :: to_action ('admin :: home @ index')); else return Redirect :: back () -> avec ('error', true); Si les informations d'identification sont correctes, l'utilisateur sera redirigé vers le tableau de bord. Sinon, ils seront redirigés avec une erreur que nous pouvons vérifier dans la vue de connexion. Comme il ne s’agit que de données de session et non d’erreurs de validation, il suffit de mettre en œuvre une vérification simple..
@if (Session :: get ('error')) Désolé, votre nom d'utilisateur ou votre mot de passe était incorrect. @fin si Nous devrons également déconnecter les utilisateurs. alors créons un get_logout méthode et ajoutez ce qui suit. Cela déconnectera les utilisateurs, puis les redirigera lors de la visite. / admin / login / logout.
fonction publique get_logout () Auth :: logout (); return Redirect :: to (URL :: to_action ('admin :: home @ index')); La dernière chose à faire est d’ajouter le contrôleur de connexion à notre fichier de routes..
Route :: controller (array ('admin :: home', 'admin :: login',)); Pour empêcher les gens de contourner notre écran de connexion, nous devons filtrer nos itinéraires pour déterminer s’ils sont des utilisateurs autorisés. Nous pouvons créer le filtre dans notre routes.php, et l'attacher à notre contrôleur de base, pour filtrer avant que l'itinéraire ne soit affiché.
Route :: filter ('auth', function () if (Auth :: guest ()) renvoie Redirect :: to (URL :: to_action ('admin :: login'));); A ce stade, tout ce qui reste à faire est d'appeler cela dans le constructeur de notre contrôleur de base. Si nous étendions notre contrôleur de connexion à partir de notre base, nous aurions une boucle infinie qui finirait par expirer.
$ this-> filter ('avant', 'auth'); Plus tôt, nous avons créé notre main.blade.php disposition; maintenant, nous allons faire quelque chose avec. Obtenons une page HTML et nos actifs en cours.
$ title Asset :: container ('header') -> styles ()$ contentAsset :: container ('footer') -> scripts ()
Vous remarquerez que j'ai également évoqué quelques variables: $ title et $ contenu. Nous pourrons utiliser les méthodes magiques de notre contrôleur pour transmettre des données à ceux-ci. J'ai aussi sauté $ contenu à l'intérieur du conteneur div que Bootstrap fournira le style pour.
Ensuite, créons la vue pour notre tableau de bord. Comme nous allons imbriquer cela, nous avons seulement besoin de mettre le contenu que nous voulons mettre dans notre conteneur.
Bonjour
Ceci est notre vue du tableau de bord
Enregistrer ceci sous index.blade.php dans le vues / tableau de bord répertoire à l'intérieur de votre paquet.
Nous devons maintenant configurer notre contrôleur pour tirer parti de la disposition et afficher les fichiers que nous venons de créer. Dans le get_index méthode que nous avons créée précédemment, ajoutez ce qui suit.
$ this-> layout-> title = 'Tableau de bord'; $ this-> layout-> nest ('content', 'admin :: dashboard.index'); Titre est une méthode magique que nous pouvons alors faire écho en tant que variable dans notre mise en page. En utilisant nid, nous sommes en mesure d'inclure une vue à l'intérieur de la mise en page directement à partir de notre contrôleur.
Afin d'accélérer les choses, Laravel nous fournit un moyen simple d'exécuter du code à partir de la ligne de commande. Celles-ci sont appelées "tâches"; c'est une bonne idée d'en créer un pour ajouter facilement un nouvel utilisateur à la base de données.
Nous devons simplement nous assurer que le fichier porte le nom de notre tâche et le placer dans le répertoire des tâches de notre groupe. Je vais appeler ça setup.php, comme nous allons l'utiliser juste après l'installation du paquet.
utilisez Laravel \ CLI \ Command en tant que commande; utilisez Admin \ Models \ Admin en tant qu'administrateur; classe Admin_Setup_Task fonction publique exécutée ($ arguments) if (vide ($ arguments) || count ($ arguments)) < 5) die("Error: Please enter first name, last name, username, email address and password\n"); Command::run(array('bundle:publish', 'admin')); $role = (!isset($arguments[5])) ? 'admin' : $arguments[5]; $data = array( 'name' => $ arguments [0]. ". $ arguments [1], 'username' => $ arguments [2], 'email' => $ arguments [3], 'password' => Hash :: make ($ arguments [4 ]), 'role' => $ role,); $ user = Admin :: create ($ data); echo ($ user)? 'Admin créé avec succès!' : 'Erreur lors de la création de l'administrateur!'; Laravel passera par un tableau d'arguments; nous pouvons les compter pour nous assurer que nous obtenons exactement ce que nous voulons. Sinon, nous ferons écho à une erreur. Vous remarquerez également que nous utilisons le Commander classe à courir bundle: publier. Cela vous permettra d'exécuter n'importe quelle tâche de ligne de commande intégrée à Laravel dans votre application ou votre bundle..
L’essentiel de cette tâche est de saisir les arguments qui lui sont transmis, de hacher le mot de passe et d’insérer un nouvel administrateur dans le dossier. Les admins table. Pour exécuter ceci, nous devons utiliser les éléments suivants dans la ligne de commande.
php artisan admin :: setup prenom prenom username [email protected] mot de passe
Dans ce tutoriel, nous avons créé un panneau d’administration standard facile à étendre. Par exemple, le rôles colonne que nous avons créée pourrait vous permettre de limiter ce que vos clients sont en mesure de voir.
Un paquet peut être quelque chose d'un panneau d'administration, comme celui que nous avons construit aujourd'hui, à des analyseurs syntaxiques Markdown - ou même l'ensemble du Zend Framework (je ne plaisante pas). Tout ce que nous avons couvert ici vous aidera à écrire de superbes ensembles Laravel, qui peuvent être publiés dans le répertoire des ensembles de Laravel..
En savoir plus sur la création de bundles Laravel ici sur Nettuts+.
