Prototypage rapide d'applications en PHP à l'aide d'un Micro Framework

Regardons les choses en face: nous avons tous de bonnes idées pour une application Web. Que vous les écriviez sur du papier ou que vous vous en souveniez en utilisant votre mémoire eidétique, vous voulez savoir si votre idée est vraiment viable ou non..

Dans ce tutoriel, nous utiliserons un micro-framework, un langage de templates et un ORM pour développer rapidement un prototype d'application..

Étape 1: Introduction et configuration

Nous avons tous eu ce sentiment. Vous savez, celui pour lequel vous savez que vous avez une excellente idée d’application Web, mais vous n’avez pas le temps de créer un prototype rapide et de tester si cette idée fonctionnera vraiment. En utilisant un micro-framework, un langage de templates et un ORM, vous pourriez le faire fonctionner en quelques minutes.

Pour ce tutoriel, nous utiliserons l'excellent micro-framework Slim, le langage de modélisation Twig et l'ORM Paris et Idiorm. Notre exemple d'application sera un blog. Vous avez probablement déjà créé un blog, mais nous sommes ici pour en savoir plus sur les micro-frameworks, et un blog convient parfaitement.!

La première chose à faire est de récupérer ces packages sur leurs sites Web respectifs:

Slim 1.5.02 (version stable)
Extras Slim
Rameau 1.1
Paris et l'Idiorm

Maintenant que tous les packages sont téléchargés sur votre ordinateur, il est temps de configurer votre structure de répertoires. Nous allons placer les fichiers dans le dossier racine de notre site. Votre dossier de projet doit donc ressembler à ceci:

"N'oubliez pas d'inclure le fichier .htaccess fourni avec Slim."

Maintenant que notre projet est structuré, allez-y, supprimez le contenu de Slim index.php file - nous écrirons notre propre un peu plus tard. Vous pouvez également tout supprimer, sauf le TwigView.php fichier de classe dans le package extras Slim.

Étape 2: amorcer

Notre index.php fichier agira comme un bootstrap, ce qui permettra à Slim, Twig, Paris et Idiorm de travailler ensemble. Slim redirigera ici toutes les demandes vers notre application, en recherchant les modèles d'itinéraire correspondants, puis en envoyant la réponse appropriée. Ce fichier contiendra éventuellement toute la configuration et la logique de notre application.

La première chose à faire est d’inclure toutes les bibliothèques qui feront que la magie opère. Ajouter ce qui suit au index.php fichier d'amorçage:

Si tout va bien, une demande à votre application ne doit absolument rien faire, ce qui est excellent!

Maintenant, mettons Twig en marche. En utilisant le package extras Slim, nous pouvons laisser Slim configurer un environnement Twig pour nous. Tout ce qu’il a besoin de savoir, c’est le répertoire dans lequel se trouve Twig, ajoutons-le à notre bootstrap. Allez aussi de l'avant et créez un répertoire de modèles nommé des modèles dans la racine du site pendant que vous y êtes.

 // Configuration TwigView :: $ twigDirectory = __DIR__. '/ Twig / lib / Twig /';

Le prochain composant de notre pile est Paris et Idiorm, notre ORM. Il utilise l'objet PDO PHP intégré, vous pouvez donc utiliser Postgres ou SQLite pour votre prototype, mais pour ce tutoriel, nous utiliserons MySQL. Assurez-vous de lui donner les informations d'identification de base de données appropriées:

 ORM :: configure ('mysql: host = localhost; nombase = blog'); ORM :: configure ('nom d'utilisateur', 'racine'); ORM :: configure ('mot de passe', ");

Enfin, faisons en sorte que Slim soit opérationnel. C'est assez compliqué, je pense que vous serez d'accord:

 // Démarrer Slim. $ app = new Slim (array ('view' => new TwigView));

Un mot d'avertissement. Si vous essayez d'exécuter votre application maintenant, vous risquez d'obtenir une erreur cryptique. Ne paniquez pas! Nous allons résoudre cela dans un instant en ajoutant quelques itinéraires.

Étape 3: routage

Ajouter des itinéraires dans Slim est simple. Tout ce que Slim a besoin de savoir, c’est la méthode de demande d’itinéraire (par exemple, GET, POST, PUT, etc.), l’URI à laquelle répondre, et comment y répondre. Nous allons d’abord préciser les routes de base de notre application et créer les entrailles du prototype plus loin dans ce tutoriel..

Commençons par créer un itinéraire de page d'accueil:

 // Accueil du blog. $ app-> get ('/', function () use ($ app) );

Ici, nous demandons à Slim de répondre à toute demande GET renvoyant à la racine de notre application. Le paramètre de fermeture finale contiendra éventuellement la logique pour générer la sortie de page.

Ajoutons un autre itinéraire pour afficher un article de blog individuel:

 // Voir le blog. $ app-> get ('/ view / (: id)', fonction ($ id) use ($ app) );

Remarquez la différence ici? Dans notre paramètre d'URI, nous avons ajouté un slug (: id), qui indique à Slim de s'attendre à une valeur à la fin de l'URI.

Si vous avez déjà utilisé un autre framework PHP, vous connaissez probablement ce concept. Si vous ne l'êtes pas, notre exemple correspondrait / vue / 1, / vue / 2 etc.

Nous avons également transmis ce paramètre à notre fonction de fermeture afin que nous puissions également l'utiliser dans notre logique d'application. Notez comment nous avons également passé notre variable d’application dans la portée des fermetures, avec le utilisation déclaration? Cela nous permet d’accéder aux composants internes de Slim, que nous utiliserons pour récupérer les données de la requête et restituer les réponses..

Nos routes d'administration devront utiliser différentes méthodes de requête, ajoutons-les donc dans:

 // Accueil Admin. $ app-> get ('/ admin', function () use ($ app) ); // Admin Add. $ app-> get ('/ admin / add', function () use ($ app) ); // Add Admin - POST. $ app-> post ('/ admin / add', function () use ($ app) ); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', fonction ($ id) use ($ app) ); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', fonction ($ id) use ($ app) ); // Admin Delete. $ app-> get ('/ admin / delete / (: id)', fonction ($ id) use ($ app) );

Vous remarquerez que nous avons quelques itinéraires POST ici. Plus tard, nous les utiliserons pour traiter les formulaires dans notre centre d'administration..

Enfin, nous ferions mieux de dire à Slim de lancer notre application.

 $ app-> run ();

Étape 4: Modèles

Paris et Idiorm facilitent la création de modèles pour représenter vos données, tout en effectuant l'essentiel des travaux difficiles, ce qui est excellent pour le prototypage rapide. Nous allons stocker nos modèles dans un répertoire nommé des modèles, alors allez-y et créez ce répertoire. À l'intérieur, créez la base Article modèle dans un fichier appelé Article.php:

Assez simple, hein? Paris et Idiorm vont extraire toutes les informations nécessaires du nom de la classe du modèle et de la table de base de données. Pendant que nous y sommes, nous devrions probablement créer la base de données et ajouter quelques exemples de données:

 CREATE DATABASE 'blog' DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; UTILISER 'blog'; CREATE TABLE IF NOT PAS EXISTS 'article' ('id' int (10) non signé NOT NULL AUTO_INCREMENT, 'horodatage' datetime NOT NULL, 'titre' varchar (128) NOT NULL, 'résumé' varchar (128) NOT NULL, 'contenu 'text NOT NULL,' author 'varchar (128) NON NULL, PRIMARY KEY (' id ')) ENGINE = MyISAM DEFAULT CHARSET = utf8; INSERT INTO 'article' ('id', 'horodatage', 'titre', 'résumé', 'contenu', 'auteur') VALEURS (1, '2011-07-28 02:03:14', 'Hello World ! ',' Lorem ipsum dolor sit amet, consectetur elit adipisicing, est devenu membre du gouvernement temporel et labore et dolore magna aliqua. Ut ',' Lorem ipsum dolor asie, a été procecté par le public et dolore grandiose. Tout ce que vous devez faire, votre exercice, votre activité physique et vos loisirs, sont bien connus, et il en est de même pour ce qui est de la sécurité. deserunt mollit anim id est laborum. ',' Mr White '), (2,' 2011-07-28 02:03:14 ',' More Hello World! ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed Est-ce que vous devez être incarcéré temporairement dans votre travail et votre dolore magna aliqua? Ut, Lorem ipsum dolor sit amet, consectetur élit adipisicing, a fait eiusmod tempor incididunt ut labore et dolore magna aliqua. Tout en un minimum de poids, l’exercice de nos exercices en cours de travail, mais il n’existe que d’excellents résultats. Duis aute irure dolor in reprrehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ',' M. Green ');

Enfin, comme nous utiliserons le modèle Article dans chaque page, nous l'inclurons dans notre bootstrap, juste après l'endroit où nous avons chargé nos bibliothèques:

 // Les modèles nécessitent 'modèles / Article.php';

Étape 5: Application front end

Maintenant que nos routes d’application sont toutes définies et que nos modèles sont configurés, il est temps de commencer à créer des pages. Notre interface de blog va être assez simple, avec une liste de tous les articles de blog et une page pour afficher des articles individuels..

En utilisant l’interface fluable chaînable fournie par Paris et Idiorm, nous pouvons rapidement construire des requêtes de base de données, sans écrire de code SQL brut. Extrayons tous les articles de la page d'accueil à l'aide de la fermeture de l'itinéraire:

 $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many ();

Nous commençons par appeler la méthode model factory, qui distribuera un objet model du type Article. De là, nous avons une interface fluide, ce qui signifie que nous pouvons chaîner nos commandes ensemble. Ici, nous obtenons tous les articles de la base de données, classés par ordre temporel, par ordre décroissant, puis nous disons à Paris que nous voulons que de nombreux articles soient renvoyés. Le résultat de cette requête est un tableau d'objets de modèle Article..

Pour que nos résultats apparaissent dans le navigateur, nous devons générer un modèle. Slim fournit une méthode de rendu simple pour le faire. Le premier paramètre est le modèle à restituer, et le second paramètre est un tableau associatif de données à mettre à la disposition du modèle, qui dans notre cas correspond à nos objets article..

 return $ app-> render ('blog_home.html', array ('articles' => $ articles));

Nous allons écrire nos modèles en utilisant Twig, qui fournit une structure de balises claire et simple avec des fonctionnalités d'héritage que nous pouvons utiliser pour mettre en page facilement une page Web sans utiliser de PHP. C'est parfait pour le prototypage, car cela signifie que vous devez vous concentrer sur la mise en forme de la sortie de la page, au lieu de patauger dans du code spaghetti PHP et HTML entremêlé..

Nous avons besoin d’un fichier d’agencement de base - un fichier HTML de base dans votre dossier de modèles appelé layout.html ça ira.

    % block page_title% % endblock%    % block content% % endblock%

Remarquez les balises de bloc Twig? Les blocs sont des régions nommées que vous pouvez renseigner avec du contenu. Nous allons peupler ces blocs dans nos modèles de page individuels.

Voici un rapide cours intensif sur Twig pour commencer.

Toute variable ou expression dans est automatiquement échappé et répercuté, tandis que le %% les balises vous permettent d'utiliser des instructions d'exécution telles que if else conditionals ou for loops.

Voyons comment créer pas à pas le modèle de page d’accueil de blog. N'oubliez pas de créer un nouveau modèle appelé blog_home.html dans votre dossier de modèles.

La première chose que nous voulons que notre modèle fasse est d’étendre notre mise en page. le s'étend La balise permet à Twig de savoir que notre modèle héritera de la layout.html fichier:

 % extend 'layout.html'%

Maintenant, nous pouvons utiliser la même syntaxe de bloc que celle utilisée précédemment pour remplir notre mise en page. Définissons le titre de la page:

 % block page_title% Mon blog % endblock%

Twig va peupler le titre de la page région dans la mise en page, avec ce que nous avons défini dans notre modèle. Pour illustrer davantage la puissance de Twig, créons le bloc de contenu et utilisons quelques fonctionnalités supplémentaires de Twig:

% block content% % pour un article dans des articles% % else%

Il n'y a actuellement aucun article.

% endif% % endblock%

Rappelez-vous que nous avons passé notre tableau d'articles récupérés à notre modèle plus tôt? Ceci est maintenant disponible dans le modèle avec le nom des articles. À l’aide des balises logiques Twigs, nous parcourons les des articles variable pour vérifier si elle existe et si elle n’existe pas, nous émettons un message d’avertissement poli. Nous consolidons un pour boucle et autre conditionnel dans un ensemble de balises pour gérer facilement un tableau vide.

Présentons une liste d'articles de blog sur la page d'accueil pour nous familiariser avec la syntaxe de Twig en boucle et en sortie:

% block content% % pour un article dans des articles%

article.title par article.author

Résumé de l'article

% autre %

Il n'y a actuellement aucun article.

% endfor% % endblock%

La syntaxe de la boucle for est l'inverse de l'instruction foreach de PHP - nous utilisons simplement le mot clé dans, au lieu de comme. Cette boucle à travers notre gamme de article objets, rendant chacun disponible sous forme de variable appelée article dans la boucle.

Dans la boucle, nous utilisons le balises, qui feront écho à une valeur échappée. Oui, Twig échappe automatiquement à votre sortie, donc plus d'écriture htmlentities ()! Nous avons également accès à l'attribut title de nos articles à l'aide d'un point (.), au lieu de la flèche PHP habituelle (->). Si vous avez écrit Javascript ou Python, vous devez vous familiariser avec cette syntaxe..

Alors, maintenant que nous avons notre page d'accueil de base, voyons les détails.

 // Voir le blog. $ app-> get ('/ view / (: id)', fonction ($ id) utiliser ($ app) $ article = Modèle :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound (); return $ app-> render ('blog_detail.html', array ('article' => $ article)););

En utilisant Paris, nous pouvons rapidement saisir un article par son identifiant à l'aide du find_one () méthode. Sinon Article une instance d'objet est renvoyée, nous avertissons l'application Slim que la page n'a pas été trouvée, ce qui déclenchera automatiquement une erreur 404.

Si l'article est trouvé, nous le transmettons à notre modèle de détail, qui se présente comme suit:

% extend 'layout.html'% % block page_title% article.title % endblock% % block content%

le titre de l'article

Publié: article.timestamp | date ('jS F Y') par article.author

article.content

Retour à la page d'accueil

% endblock%

En utilisant les filtres Twigs intégrés, nous pouvons accéder à certaines fonctions de base de PHP, telles que rendez-vous amoureux() dans nos modèles. L'attribut de classe article.timestamp est automatiquement attribué à notre filtre de date en tant que premier paramètre et notre chaîne de format de date devient le deuxième paramètre.

Nous avons maintenant un front-end fonctionnel, bien que simple, mais il n'a pas fallu longtemps pour le rendre opérationnel. Paris facilite vraiment l'extraction de vos données de la base de données et, comme nous le verrons lors de la création de notre centre d'administration, cela facilite l'insertion et la mise à jour des enregistrements..

Étape 6: application en bout de chaîne

Travaillons sur un centre d'administration pour notre blog, que nous structurerons sous l'URI / admin. Comme nous avons déjà configuré toutes les routes, écrivons la logique de la page principale du centre d'administration. Ce sera identique à notre page principale de liste de blogs, le code ci-dessous devrait donc avoir un sens complet:

 // Accueil Admin. $ app-> get ('/ admin', function () use ($ app) $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many (); return $ app- > render ('admin_home.html', array ('articles' => $ articles)););

Nous utiliserons un tableau simple comportant des liens d'action pour ajouter, éditer et supprimer des articles de blog..

Vous connaissez déjà le fonctionnement du système de région de bloc dans Twig, alors concentrons-nous simplement sur notre bloc de contenu:

% block content%

Administration de mon blog

Ajouter un article

% si articles% % pour l'article dans les articles% % endfor%

Titre	Rendez-vous amoureux	Auteur	actes
le titre de l'article	article.author	article.timestamp \| date ('jS F Y')	modifier	Effacer

% autre %

Il n'y a actuellement aucun article.

% endif% % endblock%

Dans ce modèle, nous utilisons le % if% % else% % endif% logique. Nous ne souhaitons pas afficher notre balise de table s'il n'y a pas d'articles. Nous vérifions donc son existence avant de décider quoi afficher. Nous utilisons également le filtre de date méthode à nouveau, que je pense que vous serez d'accord est assez propre et lisible.

Le centre administratif principal

Passons maintenant à la vraie chair de notre centre d'administration: manipuler du contenu. Ce dont nous avons besoin, c'est d'un formulaire contenant tous les champs nécessaires pour ajouter et éditer notre article. Heureusement, Twig prend en charge les partiels réutilisables. Nous allons donc créer un formulaire partiel appelé article_form.html:

  action_name Article
  Titre: 
  
  Auteur: 
  
  Résumé: 
 article.summary | default ('') 
  Contenu: 
 article.content | default ('')

Un partial est simplement un modèle réutilisable, il peut toujours contenir la logique standard de Twig. Dans notre modèle de formulaire, nous utilisons le défaut filter, qui fournit une valeur par défaut si la variable filtrée est vide ou inexistante. Dans le cas de nos champs de formulaire, nous générerons une chaîne vide si aucun des attributs de l'article n'est présent. Nous nous attendons également à ce que deux variables rendent notre formulaire partiellement opérationnel. Le premier appelé nom_action décrit simplement l’action de formulaire pour nos utilisateurs (par exemple, ajouter ou modifier) et la seconde action_url est utilisé comme action de formulaire.

Vous aurez sans doute remarqué comment la logique de cette page est divisée en deux routes, une pour GET et une pour POST, ce qui signifie que nous devrons écrire une fonction pour gérer chaque méthode. Notre itinéraire GET doit simplement rendre la page - rien de trop délicat. Nous dirons simplement à Twig de rendre un nouveau modèle:

 // Admin Add. $ app-> get ('/ admin / edit / (: id)', fonction ($ id) return $ app-> render ('admin_input.html', array ('nom_action' '=>' Ajouter ',' action_url '=>' / admin / add ')););

Nous passons les deux variables attendues par notre formulaire partiel dans le modèle. En parlant de cela, laissez-moi vous expliquer comment utiliser le partiel dans notre admin_input.html modèle:

 % include 'article_form.html'%

Je suis sûr que vous avez probablement deviné que ce serait aussi simple que cela. Nous avons juste besoin d'inclure le partiel dans l'une de nos régions de bloc Twig, puis il apparaîtra. Il aura également accès à toutes les variables comprises dans la portée de son modèle principal (c'est-à-dire les deux variables que nous avons passées). Twig possède de superbes contrôles de portées variables et des fonctionnalités de sécurité en sandbox, mais il est préférable de les conserver un autre jour.

Notre modèle de saisie final est assez simple (voir ci-dessous) et fonctionnera également lorsque nous construirons nos contrôles d'édition. Je suppose que vous vous demandez pourquoi nous nous sommes dérangés avec un partiel dès le départ, si nos formulaires d'ajout et d'édition utilisent le même modèle. La raison en est que cela permet de réutiliser le formulaire ailleurs pendant le prototypage, si cela devenait nécessaire..

 % extend 'layout.html'% % block page_title% action_name Article % endblock% % block content% % include 'article_form.html'% % endblock%

Ajouter un formulaire d'article

Travaillons sur cette route POST. Ce que nous devons faire, c'est récupérer les données postées et les stocker dans un objet article. Nous ne nous soucions pas de vérifier les erreurs dans notre exemple car nous ne faisons que prototyper notre idée. Nous ferons en sorte que Paris distribue ou crée un nouveau article objet:

 $ article = Model :: factory ('Article') -> create ();

Nous pouvons maintenant commencer à renseigner l'article à partir des données postées. Nous allons récupérer les données POST de notre objet d'application Slim, qui fournit une méthode d'assistance pratique via son objet de requête:

 $ article-> title = $ app-> request () -> post ('title'); $ article-> auteur = $ app-> requête () -> post ('auteur'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('contenu'); $ article-> timestamp = date ('Y-m-d H: i: s');

Paris veille à échapper à toutes nos interventions lors de la sauvegarde, ce qui est pratique si vous décidiez jamais de mettre en scène votre prototype pour que d'autres puissent y accéder. Il ne reste plus qu'à dire à Paris de sauvegarder le record.

 $ article-> save ();

Enfin, nous demandons à notre application Slim de nous ramener à la page principale du tableau de bord de l’administrateur à l’aide de la touche réorienter méthode d'assistance:

 $ app-> redirect ('/ admin');

Sur notre méthode GET de modification de route, qui est simplement une fusion des choses que nous avons apprises en construisant notre page de détail de blog et notre page d’ajout d’administrateur. Premièrement, nous devons charger l'article que nous sommes en train de modifier, en récupérant l'enregistrement avec Paris:

 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound ();

Paris distribue une instance d'objet article correspondant à l'ID d'enregistrement d'article reçu dans notre clôture, ou false si aucun n'existe. Nous vérifions ensuite si nous avons récupéré une instance, sinon nous disons à Slim de générer une erreur 404.

Nous demandons maintenant à Slim de restituer le modèle d'entrée, comme dans notre route d'ajout, mais en passant à l'objet article chargé et à l'URL d'action correcte:

 return $ app-> render ('admin_input.html', array ('action_name' => 'Edit', 'action_url' => '/ admin / edit /'. $ id, 'article' => $ article));

Notre itinéraire de modification POST fonctionne presque de la même manière que le ajouter route, à l'exception que nous devons vérifier si l'article peut être chargé avant de continuer et de mettre à jour ses attributs:

 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound ();  $ article-> title = $ app-> request () -> post ('title'); $ article-> auteur = $ app-> requête () -> post ('auteur'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('contenu'); $ article-> timestamp = date ('Y-m-d H: i: s'); $ article-> save (); $ app-> redirect ('/ admin');

Nous allons terminer notre centre d'administration en construisant la route de suppression. Pour ce faire, nous allons d'abord récupérer l'enregistrement, comme nous l'avons fait précédemment sur la page de détail de notre blog:

 $ article = Model :: factory ('Article') -> find_one ($ id);

Si Paris a chargé un article, nous devons le supprimer, puis renvoyer l'utilisateur à la page principale de l'administrateur. Paris simplifie au maximum la suppression d'un enregistrement:

 if ($ article instanceof Article) $ article-> delete ();  $ app-> redirect ('/ admin');

Et avec cela notre prototype de centre d'administration de base est terminé.

Étape 7: Utiliser un middleware

Notre centre d'administration est maintenant terminé. C'est assez basique puisqu'il ne s'agit que d'un prototype, mais nous voulons toujours une forme d'autorisation pour le protéger des regards indiscrets. Slim nous permet d'insérer un middleware dans nos routes. Cela signifie que nous pouvons créer des fonctions appelées avant la fermeture de la réponse de notre route..

Nous pouvons utiliser HTTP Basic Auth pour protéger notre centre d'administration. De toute évidence, nous utiliserions quelque chose d'un peu plus sécurisé sur un site actif, mais pour notre prototype, c'est très bien. Au sommet de notre index.php Créons deux constantes contenant notre nom d'utilisateur et notre mot de passe:

 // Détails d'authentification. define ('USERNAME', 'admin'); define ('MOT DE PASSE', 'mot de passe');

Après avoir créé notre instance d'application Slim, nous allons créer une fermeture, que nous lierons à une variable pour contenir notre contrôle de middleware d'autorisation:

 // Auth Check. $ authCheck = function () use ($ app) ;

Si vous n'avez jamais utilisé HTTP Basic Auth en PHP auparavant, c'est très simple. Nous pouvons utiliser le $ _SERVER array pour vérifier quelles informations d'identification ont été envoyées à partir du navigateur Web de l'utilisateur et les comparer à nos constantes. Nous ferons cela à l'intérieur de notre nouvelle fermeture. La première chose que nous devons faire dans notre fonction de vérification d'authentification consiste à déterminer si des informations d'identification d'authentification ont été envoyées et, le cas échéant, de vérifier si elles correspondent à nos constantes:

 $ authRequest = isset ($ _ SERVER ['PHP_AUTH_USER'], $ _SERVER ['PHP_AUTH_PW']); $ authUser = $ authRequest && $ _SERVER ['PHP_AUTH_USER'] === USERNAME; $ authPass = $ authRequest && $ _SERVER ['PHP_AUTH_PW'] === PASSWORD;

Nous ne faisons que vérifier si les valeurs d'authentification existent et correspondent, puis stocker les résultats dans certaines variables. En supposant que l'une ou l'autre de ces variables soit fausse, nous savons que nous devons inciter l'utilisateur à s'autoriser:

 if (! $ authUser ||! $ authPass) $ app-> response () -> en-tête ('Authentification WWW: royaume de base =' Administration de mon blog '', ''); $ app-> response () -> en-tête ('HTTP / 1.1 401 non autorisé', ''); $ app-> response () -> body ('Veuillez entrer des informations d'identification d'administration valides.
'); $ app-> response () -> send (); sortie;

Nous vérifions si nos références d'authentification sont correctes. Si ce n'est pas le cas, nous renvoyons une réponse avec les en-têtes et le message d'avertissement appropriés. Comme vous l'avez vu précédemment, nous pourrions accéder à l'objet de demande du framework Slim pour accéder à nos données POST. Nous pouvons également accéder à l'objet de réponse interne, ce qui nous permet d'insérer facilement nos en-têtes et d'écraser le corps de l'objet de réponse Slim avec un simple message d'avertissement HTML, avant de forcer le script à quitter..

Dans Slim, vous pouvez ajouter plusieurs callables à une route et les exécuter dans l'ordre indiqué. Cela signifie que nous pouvons facilement empêcher l'accès à toutes nos routes en ajoutant la fermeture de vérification d'authentification avant la fermeture de la réponse:

 // Accueil Admin. $ app-> get ('/ admin', $ authCheck, function () use ($ app) //?); // Admin Add. $ app-> get ('/ admin / add', $ authCheck, function () use ($ app) //?); // Add Admin - POST. $ app-> post ('/ admin / add', $ authCheck, function () use ($ app) //?); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', $ authCheck, function ($ id) use ($ app) //?); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', $ authCheck, function ($ id) use ($ app) //?); // Admin Delete. $ app-> get ('/ admin / delete / (: id)', $ authCheck, function ($ id) use ($ app) //?);

Et voilà, notre centre d'administration est maintenant protégé. Toute personne qui tente d'y accéder verra un message d'avertissement et on lui demandera ses informations d'identification.

Étape 8: Résumé

Espérons que ce tutoriel vous ait montré à quel point il est rapide et facile de mettre en place un prototype avec un micro-framework, un ORM et un langage de template, tout en maintenant une bonne séparation des problèmes et du code lisible..

Un langage de gabarit puissant peut empêcher vos vues de devenir un mélange de code spaghetti PHP et HTML illisible, et comment un ORM parlant couramment peut rendre les actions fastidieuses de CRUD rapides et simples..

Ce ne sont là que quelques-unes des nombreuses choses cool que vous pouvez faire avec Slim, Twig et Paris. Si vous creusez plus loin, vous pouvez ajouter des relations à vos modèles avec Paris, ajouter des extraits de macros dans Twig pour accélérer le développement de vos modèles et utiliser le routage basé sur le nom avec Slim pour rendre la liaison entre le contenu de votre site Web et les URL changeantes..

Joyeux prototypage et merci beaucoup pour la lecture!

Code