Share
Lors de la création d'une application d'une seule page, nous devrions utiliser une sorte de cadre pour faire le travail pour nous, afin de pouvoir nous concentrer sur les fonctionnalités réelles. AngularJS convient parfaitement ici, car des fonctionnalités telles que l'injection de dépendance dynamique et la liaison de données bidirectionnelle sont tout simplement géniales. Parfois, nous avons également besoin d’une sorte de serveur. Si vous avez choisi PHP, alors Laravel peut être votre meilleure option, car il est facile de travailler avec et assez puissant.
Dans ce tutoriel, vous allez créer un système simple de gestion clients / transactions avec la possibilité d'ajouter et de supprimer des transactions et des clients. Ce n’est probablement pas le genre de choses que vous faites souvent, mais cela montre comment utiliser les fonctionnalités des deux frameworks..
Avant de commencer, vous devriez configurer une base de données MySQL que nous utiliserons (Laravel en supporte beaucoup plus, mais celle-ci reste la plus populaire). Vous n’avez besoin d’aucun serveur Web, car nous allons utiliser celui de PHP (mais gardez bien à l’esprit que cette solution est uniquement pour le développement et ne doit jamais être utilisée en production - il manque beaucoup de fonctionnalités nécessaires au bon fonctionnement de votre application en public). Pour cela, il nous faut au moins PHP version 5.4.0.
La première chose à faire est d'installer Laravel. Le processus complet est décrit sur le site Web de Laravel. Après cela, votre répertoire de projet devrait être créé avec tous les fichiers de Laravel. Accédez à ce répertoire dans votre ligne de commande et exécutez la commande suivante:
php artisan servir
Si tout se passe bien, vous devriez voir que le serveur de développement local a été démarré le locahost: 8000. Ouvrez votre navigateur et naviguez-y, vous devriez voir la page d'accueil de Laravel:
Maintenant, nous pouvons procéder à l'application réelle.
Les modèles dans Laravel sont comme dans n'importe quel autre framework MVC. Il utilise l’ORM Eloquent pour vous faciliter la tâche. Vous n’aurez probablement jamais besoin de réécrire une requête SQL (à moins que vous souhaitiez quelque chose que Eloquent ne prend pas en charge). À l'aide des migrations, vous pouvez modifier la structure de la base de données avec la possibilité d'annuler les modifications en cas de problème. Vous pouvez en savoir plus sur les migrations dans la documentation.
Dans notre application, nous allons utiliser deux modèles:
Accentsconagua
Client - tiendra les données du clientTransaction - tiendra les informations sur une transactionCommençons par créer des migrations pour eux. Si vous ne l’avez pas déjà fait, arrêtez le serveur que nous avons démarré plus tôt (Ctrl + C).
Commencez par appeler cette commande:
php artisan migrate: make create_customers_table
Cela créera un fichier de migration avec une structure de base pour vous. Maintenant, naviguez vers app / base de données / migrations. Il devrait y avoir un fichier avec son nom commençant par un horodatage et se terminant par "create_customers_table". Laravel a automatiquement créé cette structure de base pour vous. up () la méthode est appelée lorsque la migration est appliquée, et vers le bas() quand il est annulé.
D'abord appeler le Schema :: create () méthode. Il faut deux arguments - le nom du schéma et une fonction de rappel:
Schema :: create ('clients', fonction ($ table) Le rappel est exécuté lors de la création de la table. L'objet de table est passé en tant que $ table variable et nous manipulons la structure de la table en l'utilisant. Ajoutons une auto-incrémentation identifiant champ:
$ table-> increments ('id'); Ensuite, il y aura trois champs de chaîne pour le prénom, le nom de famille et l'adresse électronique du client:
$ table-> string ('prenom'); $ table-> string ('last_name'); $ table-> string ('email') -> unique (); Nous faisons le email champ unique en appelant le unique() méthode sur elle.
La dernière méthode concerne les horodatages:
$ table-> horodatages (); );
Cela créera deux champs de date dans le schéma: créé à et updated_at. Eloquent les utilisera pour enregistrer l’heure à laquelle l’article a été créé et mis à jour..
Enfin, le code devrait ressembler à ceci:
fonction publique up () Schema :: create ('clients', fonction ($ table) $ table-> incréments ('id'); $ table-> chaîne ('prénom_nom'); $ table-> chaîne (' nom_demois '); $ table-> chaîne (' email ') -> unique (); $ table-> timestamps ();); le vers le bas() La méthode est beaucoup plus simple - elle supprime simplement le schéma:
fonction publique down () Schema :: drop ('clients'); Le code ici sera similaire à celui du client. Commencez par appeler cette commande:
php artisan migrate: make create_transactions_table
Maintenant, localisez le fichier approprié dans le app / base de données / migrations et l'ouvrir. Comme précédemment, commencez par créer le schéma:
Schema :: create ('transactions', fonction ($ table) Ajoutez maintenant les champs pour l'identifiant, le nom de la transaction, son coût et l'identifiant du client auquel elle appartient:
$ table-> increments ('id'); $ table-> chaîne ('nom'); $ table-> float ('amount'); $ table-> integer ('customer_id'); Et bien sûr les horodatages:
$ table-> horodatages (); );
Le code final devrait ressembler à ceci:
fonction publique up () Schema :: create ('transactions', fonction ($ table) $ table-> incréments ('id'); $ table-> chaîne ('nom'); $ table-> float (' montant '); $ table-> entier (' customer_id '); $ table-> timestamps ();); Et maintenant le vers le bas() méthode:
fonction publique down () Schema :: drop ('transactions'); Maintenant, avant d'appliquer les migrations, vous devez configurer la connexion à votre base de données. Ouvrez le app / config / database.php déposer et aller à la ligne 55. Voici les données de configuration pour MySQL (il y en a peu d'autres, par exemple, vous pourriez utiliser SQLite ou Postgres):
'mysql' => array ('driver' => 'mysql', // pilote de base de données, ne touchez pas 'hôte' => 'localhost', // hôte de la base de données, généralement localhost sauf si vous avez votre base de données sur certains serveur 'base de données' => 'base de données', // nom de la base de données que vous utiliserez, il doit être créé auparavant 'nom d'utilisateur' => 'racine', // nom d'utilisateur que le script utilisera pour se connecter, je vous le déconseille vivement en utilisant l'utilisateur root pour ce 'password' => ", // le mot de passe de l'utilisateur ci-dessus, il est préférable de ne pas utiliser un 'charset' vierge = = '' utf8 ', // l'encodage de la db' collation '=>' utf8_unicode_ci ', // paramètre de classement de la base de données' prefix '=> ", // préfixe des tables de la base de données, utile si vous avez plusieurs scripts utilisant la même base de données), Une fois que vous avez rempli cela, vous êtes prêt à partir. Assurez-vous d'avoir enregistré le fichier et appelez cette commande à partir du répertoire principal de votre application (celui avec le artisan fichier dedans):
php artisan migrer
Et c'est tout. S'il n'y a pas d'erreur, cela signifie que les tables ont été créées avec succès. Vous pouvez vous connecter à votre base de données en utilisant, par exemple, phpMyAdmin pour vérifier manuellement si vous le souhaitez..
Dans Laravel, la création d'un modèle après avoir configuré votre base de données à l'aide de migrations est très rapide. Aller vers app / modèles et supprimer l'exemple User.php fichier qui est là. Maintenant, créez deux fichiers nommés Client.php et Transaction.php.
Commençons avec Client.php. Tous les modèles de Laravel doivent étendre la Éloquent classe:
classe Client étend Eloquent
Nous allons maintenant définir une relation entre le client et ses transactions. Ceci est fait en définissant une méthode publique dans le modèle avec le nom de la propriété que nous aimerions y avoir (dans ce cas transactions):
transactions de fonction publique ()
Maintenant, dans le corps de la fonction, il n'y aura qu'une seule ligne:
return $ this-> hasMany ('Transaction'); Cela indique à Eloquent qu'il devrait fournir toutes les transactions avec N ° de client du client sous une propriété nommée transactions.
Maintenant, nous ferons à peu près la même chose pour les transactions, mais nous inverserons la relation pour rendre le propriétaire de la transaction accessible via le serveur Web. client propriété:
class Transaction étend Eloquent public function client () return $ this-> apartTo ('Client'); Ceci est fait en utilisant le $ this-> appartientTo () méthode du modèle.
Maintenant, pour utiliser réellement les modèles, nous devons créer des contrôleurs pour eux. Dirigez-vous vers le app / contrôleurs répertoire, supprimez le HomeController.php seulement - BaseController.php est important car nos contrôleurs l’étendront. Maintenant, créez deux fichiers: CustomerController.php et TransactionController.php.
Ce contrôleur gérera tout ce qui concerne les clients - en ajoutant, supprimant et affichant une liste d’entre eux. Commencez par définir la classe:
la classe CustomerController étend BaseController
Nous utiliserons la fonctionnalité de Laravel appelée contrôleurs RESTful. Cela facilite la création de routes car il suffit de définir l’URI de base et Laravel gérera tout pour nous. Pour cela, vous devez démarrer les noms de fonction avec le verbe HTTP approprié, puis poursuivre avec le nom de la sous-route (à l’aide de camelCase). Ainsi, par exemple, si nous avions une méthode nommée getNames et l'URI de base serait /les clients, alors la méthode sera accessible à / clients / noms.
le getIndex (), postIndex (), deleteIndex () Les méthodes etc. seront mappées sur la route par défaut (dans ce cas, /les clients).
Définissons maintenant notre premier itinéraire: obtenir le client par son identifiant:
fonction publique getIndex ()
Récupérons l’identifiant des paramètres de la requête (Laravel fournit un bon Contribution classe pour faire face à cela, de sorte que vous n'avez pas à utiliser $ _GET, $ _POST et $ _FILES):
$ id = Input :: get ('id'); Et recherchez l'utilisateur dans la base de données en utilisant cet identifiant:
retour Client :: find ($ id);
Chaque méthode du contrôleur doit renvoyer une valeur qui est une chaîne ou a une __toString () méthode. Dans ce cas, le Client le modèle renvoyé sera converti en JSON avant l'envoi.
Maintenant, retournons une liste de tous les utilisateurs (celle-ci sera accessible sous / clients / tous):
fonction publique getAll () return Customer :: all ();
Comme vous pouvez le constater, tous les clients peuvent utiliser le modèle tout() méthode.
Maintenant la partie la plus longue, en ajoutant un nouveau client:
fonction publique postIndex ()
D'abord, vérifions si toutes les informations nécessaires ont été fournies. Nous pouvons le faire en utilisant le Entrée :: a () méthode:
if (Input :: has ('first_name', 'last_name', 'email')) Mettons tous les champs d'entrée dans le $ input variable pour éviter d'appeler Entrée :: get () encore et encore. Cela peut être fait en utilisant Entrée :: all ():
$ input = Input :: all ();
Ensuite, nous vérifierons si l’une des entrées est vide. Si tel est le cas, nous renverrons une erreur HTTP 400 Bad Request avec un message plus détaillé:
if ($ input ['first_name'] == "|| $ input ['last_name'] ==" || $ input ['email'] == ") return Response :: make ('Vous devez remplir tous les champs des champs d'entrée ', 400); Comme nous voulions renvoyer un code d’état autre que 200 au lieu de simplement renvoyer le message sous forme de chaîne, nous avons utilisé Réponse :: make (), qui prend les données à envoyer en tant que premier paramètre et le code d'état en tant que second. Jetez un coup d'œil à la documentation si vous voulez en savoir plus sur les réponses.
Maintenant, nous créons enfin un nouveau Client modèle et alimentez-le avec les données fournies:
$ client = nouveau client; $ customer-> prenom = $ input ['prenom']; $ customer-> last_name = $ input ['last_name']; $ client-> email = $ entrée ['email'];
Après cela, nous pouvons enregistrer le modèle nouvellement créé et y répondre à la demande:
$ client-> save (); return $ customer;
Ici, nous traitons le cas si toutes les entrées n'étaient pas fournies:
else return Response :: make ('Vous devez remplir tous les champs de saisie', 400); Enfin, nous devons également être en mesure de supprimer les clients. Celui-ci est vraiment court:
fonction publique deleteIndex ()
Nous commençons par obtenir l'id du client à supprimer:
$ id = Input :: get ('id'); Ensuite, nous recherchons et supprimons le client:
$ customer = Customer :: find ($ id); $ customer-> delete ();
Après cela, nous répondons à la demande avec l'identifiant fourni:
return $ id;
Maintenant, avant de pouvoir accéder aux itinéraires, nous devons les accrocher. Ouvrez le app / routes.php fichier, supprimez tout sauf le commentaire et ajoutez cette ligne à la fin du fichier:
Route :: controller ('/ clients', 'CustomerController'); Cela dira à Laravel de router toutes les demandes à /les clients à notre CustomerController. Vous pouvez maintenant utiliser CURL pour jouer avec. Commencez par démarrer le serveur avec php artisan servir et ensuite vous pouvez, par exemple, créer un client:
curl -X POST -d "[email protected]" http: // localhost: 8000 / customers
Ensuite, vous pouvez obtenir la liste de tous les clients:
curl http: // localhost: 8000 / clients / all
Ceci, comme le modèle est très similaire à la CustomerController. Commencez par créer la classe:
La classe TransactionController étend BaseController
Définissons ensuite la méthode pour obtenir toutes les transactions pour un utilisateur:
fonction publique getIndex () $ id = Input :: get ('id'); return User :: find ($ id) -> transactions; Comme vous pouvez le constater, nous utilisons la relation définie précédemment pour obtenir les transactions (rappelez maintenant la requête que vous deviez écrire pour obtenir la même chose avec PHP et SQL simples).
La prochaine chose sera la création de transactions:
fonction publique postIndex ()
Comme précédemment, nous vérifions si toutes les informations requises sont fournies:
if (Input :: has ('nom', 'montant')) Si oui, attribuez-le à un $ input variable:
$ input = Input :: all ();
Vérifiez si l'une des valeurs fournies est vide et si c'est le cas, renvoyez une erreur:
if ($ input ['nom'] == "|| $ input ['montant'] ==") return Response :: make ('Vous devez remplir tous les champs de saisie', 400); Créez maintenant la transaction et fournissez-la avec toutes les informations fournies:
$ transaction = nouvelle transaction; $ transaction-> name = $ input ['name']; $ transaction-> montant = $ entrée ['montant'];
Nous devons maintenant l'ajouter au client approprié. Trouvons-les par l'id fourni et ajoutons le $ transaction à leur liste de transactions:
$ id = $ input ['customer_id']; User :: find ($ id) -> transactions-> save ($ transaction);
Ceci est fait en utilisant le transactions-> save () méthode fournie par Laravel. Maintenant, nous pouvons répondre avec la transaction créée:
retour $ transaction;
Et gérez le cas où aucune ou toutes les données n'ont été fournies:
else return Response :: make ('Vous devez remplir tous les champs de saisie', 400); Après cela, il existe également une méthode pour supprimer la transaction de la même manière que nous avons supprimé le client:
fonction publique deleteIndex () $ id = Input :: get ('id'); $ transaction = Transaction :: find ($ id); $ transaction-> delete (); return $ id; Maintenant, ajoutez simplement la route et vous pouvez tester le contrôleur en utilisant CURL:
Route :: controller ('/ transactions', 'TransactionController'); Bien, ceci est la fin de la première partie - dans la deuxième partie de ce tutoriel, nous allons créer le front-end en utilisant AngularJS. N'hésitez pas à ajouter d'autres fonctionnalités à votre application (telles que la modification de clients ou le tri), au cas où vous ne trouviez pas les informations que vous recherchiez, consultez la documentation de Laravel..
