FuelPHP - Guide rapide

FuelPHP est un framework d'application web open source. Il est écrit en PHP 5.3 et implémente le modèle HMVC.HMVC est Hierarchical Model-View-Controller framework cela permet de sous-demander le contrôleur, qui renvoie la page partielle comme les commentaires, les menus, etc., au lieu de la page complète comme dans MVC normal.

FuelPHP est créé avec le désir d'intégrer les meilleures pratiques à partir de cadres tels que CodeIgniter et Kohanaavec des améliorations et des idées qui lui sont propres. L'outil de migration de base de données FuelPHP et les fonctionnalités d'échafaudage sont inspirés du populaireRuby on Rails cadre.

FuelPHP exploite le power of command line via un utilitaire appelé "Oil". L'utilitaire est conçu pour accélérer le développement, augmenter l'efficacité, les tests, le débogage et la prise en charge HTML.
FuelPHP est une approche purement orientée objet. Son architecture est basée sur l'idée de modularité. Les applications peuvent être divisées en modules et chaque composant peut être étendu ou remplacé sans réécrire une seule ligne de code. Fuel prend en charge tous les analyseurs de modèles tels queSmarty, Twig, PHPTal, etc. pour analyser les vues.
FuelPHP community is largeet actif avec plus de 300 contributeurs. Sa grande communauté crée et améliore régulièrement des packages et des extensions. L'objectif principal du framework FuelPHP est de fournir flexibilité et compatibilité. C'est rapide, facile à apprendre et une solution complète pour le développement d'applications Web.
Ce qui fait de FuelPHP l'un des principaux frameworks utilisés par les développeurs PHP, c'est que - le new version of FuelPHP is reverse-compatible with its older versionsen raison de son API stable. C'est extrêmement flexible.
Packages and modulesfacilitent et simplifient la réutilisation systématique d'un code existant. FuelPHP offre des performances maximales grâce à une petite bibliothèque. Son débogage interactif permet d'éliminer facilement les erreurs de développement. De plus, son code propre et stable facilite la programmation.

FuelPHP - Caractéristiques

FuelPHP offre de nombreuses fonctionnalités pour créer une application Web à part entière. Il fournit des composants flexibles, une configuration simple, un ORM facile à utiliser, un mode de développement d'applications basé sur REST, etc. Voici quelques-unes des principales fonctionnalités -

Cadre Web flexible et axé sur la communauté
Facile à configurer et à utiliser
FuelPHP est extrêmement portable, fonctionne sur presque tous les serveurs
Système de routage URI flexible
FuelPHP fournit un support de développement d'API RESTful
Modèle ORM léger
Filtrage d'entrée et empêche l'injection SQL
Cadre d'authentification et d'autorisation sécurisé
Code réutilisable et plus facile à maintenir
Cours de chargement automatique, gestion de session et gestion des exceptions.

FuelPHP - Avantages

FuelPHP est un élégant framework HMVC PHP 5.3 qui fournit un ensemble de composants pour la création d'applications Web avec les avantages suivants:

Modular structure- Fuel ne vous oblige pas à utiliser des modules ou une structure de fichiers HMVC. Si vous souhaitez l'utiliser, le processus est assez facile à intégrer. Les applications FuelPHP sont créées dans une structure modulaire et deviennent plus faciles pour les développeurs avec des avantages évidents.
HMVC pattern - La caractéristique la plus importante de ce framework est HMVC (Hierarchical Model View Controller) qui facilite l'accès ou l'utilisation de toutes les propriétés, méthodes de classe, fonctions, fichiers de niveau supérieur.
Secure hashing function- FuelPHP prend en charge des outils de cryptographie puissants et des techniques de hachage de mot de passe. Il gère le cryptage, le décryptage et le hachage à l'aide du puissant PHPSecLib.
Scaffolding functionality- L'échafaudage est une méthode de méta-programmation pour la création d'opérations de base de données. L'échafaudage de Fuel est assez simple. Il vous permet d'obtenir une application CRUD de base avec des étapes très simples.

Les produits populaires suivants utilisent FuelPHP Framework -

Matic Technology- Fournisseur mondial de solutions de développement de logiciels personnalisés offshore. Chez Matic Technologies, ils fournissent toutes les meilleures solutions possibles via FuelPHP en fonction des exigences du client.
Kroobe- Kroobe est une société de petites annonces de réseaux sociaux. Fuel offre des coûts de développement et des services extrêmement bas à l'équipe de Kroobe pour obtenir une solution efficace.

Ce chapitre explique comment installer le framework FuelPHP sur votre machine. L'installation de FuelPHP est très simple et facile. Vous avez deux méthodes pour créer des applications FuelPHP -

La première méthode est Command line installation à l'aide de l'outil FuelPHP appelé Oil.
La deuxième méthode est Composer basedinstallation. Utilisations de FuelPHPComposer, à la fois pour l'installation et pour les dépendances de package, assurez-vous donc que le composeur est installé localement avant de poursuivre le processus.

Passons en revue chacune des méthodes une par une en détail dans les sections suivantes.

Configuration requise

Avant de passer à l'installation, les exigences système suivantes doivent être satisfaites.

Serveur Web (l'un des éléments suivants)

WAMP (Windows)
Microsoft IIS (Windows)
LAMPE (Linux)
MAMP (Macintosh)
XAMP (multi-plateforme)
Nginx (multi-plateforme)
Serveur Web de développement intégré PHP (Multi-plateforme)

Prise en charge du navigateur (l'un des éléments suivants)

IE (Internet Explorer 8+)
Firefox
Google Chrome
Safari

PHP compatibility- PHP 5.3 ou version ultérieure. Pour en tirer le meilleur parti, utilisez la dernière version.

Utilisons le serveur Web de développement intégré de PHP pour ce didacticiel. Le serveur Web de développement intégré est facile à démarrer et tout à fait adéquat pour comprendre les bases de l'application Web FuelPHP sans entrer dans la complexité du monde du serveur Web et des configurations.

Installation en ligne de commande

L'installation en ligne de commande de FuelPHP est très simple et prend au maximum cinq minutes.

Installer le paquet d'huile

Oil est un package / commande spécial fourni par le framework FuelPHP pour effectuer de nombreuses tâches nécessaires au développement de l'application FuelPHP, y compris l'installation, le développement et le test de l'application.

Pour installer le Oil package, ouvrez un shell et exécutez la commande suivante -

sudo curl https://get.fuelphp.com/oil | sh

La commande utilise curl pour télécharger et installer le package d'huile. La commande affichera un résultat similaire aux informations suivantes et installera enfin le package d'huile.

% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current 
                                 Dload  Upload   Total   Spent    Left  Speed 
100   479  100   479    0     0    353      0  0:00:01  0:00:01 --:--:--   353

Créer un nouveau projet

Pour créer un nouveau projet en utilisant Oil, utilisez la commande suivante -

oil create <project_name>

Créons un nouveau projet nommé «HelloWorld» à l'aide de la commande suivante.

oil create HelloWorld

Maintenant, vous pouvez voir une réponse similaire à la suivante et enfin créer une simple application FuelPHP squelette.

composer create-project fuel/fuel HelloWorld 
Installing fuel/fuel (1.8.0.1) 
   - Installing fuel/fuel (1.8.0.1) 
      Loading from cache  

Created project in HelloWorld  

Loading composer repositories with package information 
Updating dependencies (including require-dev) 
   - Installing composer/installers (v1.3.0) 
      Loading from cache
   - Installing fuelphp/upload (2.0.6) 
      Loading from cache  
   - Installing michelf/php-markdown (1.4.0) 
      Loading from cache  
   - Installing psr/log (1.0.2) 
      Loading from cache  
   - Installing monolog/monolog (1.18.2) 
      Loading from cache  
   - Installing phpseclib/phpseclib (2.0.0) 
      Loading from cache  
   - Installing fuel/core (1.8.0.4) 
      Loading from cache  
   - Installing fuel/auth (1.8.0.4) 
      Loading from cache  
   - Installing fuel/email (1.8.0.4) 
      Loading from cache  
   - Installing fuel/oil (1.8.0.4) 
      Loading from cache  
   - Installing fuel/orm (1.8.0.1) 
      Loading from cache  
   - Installing fuel/parser (1.8.0.4) 
      Loading from cache  
   - Installing fuel/docs (1.8.0.4) 
      Loading from cache
   ……………. 
   …………….  
   Writing lock file
   Generating autoload files

Version d'huile

Pour tester si l'huile est disponible et pour vérifier la version, utilisez la commande suivante -

$ cd HelloWorld $ php oil -v

La commande ci-dessus produit le résultat suivant -

Fuel: 1.8 running in "development" mode

Commande d'aide à l'huile

Pour obtenir la documentation d'aide de base de Oil, utilisez la commande suivante -

$ php oil help

La commande ci-dessus affichera la documentation d'aide similaire au résultat suivant -

Usage: 
   php oil [cell|console|generate|package|refine|help|server|test]  
Runtime options: 
   -f, [--force]    # Overwrite files that already exist 
   -s, [--skip]     # Skip files that already exist 
   -q, [--quiet]    # Supress status output 
   -t, [--speak]    # Speak errors in a robot voice  
Description:   
   The 'oil' command can be used in several ways to facilitate quick development, help 
   with testing your application and for running Tasks.  
Environment: 
   If you want to specify a specific environment oil has to run in, overload the 
   environment variable on the commandline: FUEL_ENV=staging php oil <commands>
More information: 
   You can pass the parameter "help" to each of the defined command to get 
   information about that specific command: php oil package help  
Documentation:   
   http://docs.fuelphp.com/packages/oil/intro.html

À partir de maintenant, vous avez une idée de la façon d'installer le carburant utilisant de l'huile. Passons en revue l'installation basée sur le compositeur dans la section suivante.

Installation basée sur Composer

La commande suivante est utilisée pour installer FuelPHP à l'aide de Composer.

$ composer create-project fuel/fuel --prefer-dist.

Clones du référentiel Git

Pour installer la dernière version de développement en tant que clones de référentiel git local, utilisez la commande suivante.

$ composer create-project fuel/fuel:dev-1.9/develop --prefer-source.

Exécution de l'application

Accédez au dossier public du répertoire du projet, exécutez l'application à l'aide du serveur de production avec la commande suivante.

$ cd path/to/HelloWorld/public
$ php -S localhost:8080 index.php

Il produit la réponse suivante.

PHP 5.5.31 Development Server started at Sun May 21 12:26:10 2017
Listening on http://localhost:8080
Document root is /Users/workspace/php-fuel/HelloWorld/public
Press Ctrl-C to quit.

Maintenant, demandez l'URL, http://localhost:8080 et cela produira le résultat suivant.

Résultat

C'est le moyen le plus simple d'exécuter l'application FuelPHP dans l'environnement de développement. Si vous créez votre application de cette manière dans l'environnement de production, vous serez confronté à des problèmes de sécurité. La méthode recommandée consiste à configurer une configuration d'hôte virtuel. Il est expliqué pour le serveur Web Apache dans la section suivante.

Configuration d'un hôte virtuel

C'est un moyen plus sûr d'accéder à l'application FuelPHP. Pour configurer un hôte virtuel, vous devez lier le fichier d'hôte virtuel apache à votre application. Dans le cas d'une application intranet, redirigez l'URL du fichier hôte système vers l'hôte virtuel.

Fichier hôte virtuel

Ouvrez l'hôte virtuel et ajoutez les modifications suivantes.

<VirtualHost *:80> 
   ServerName hello.app 
   DocumentRoot /path/to/public 
   SetEnv FUEL_ENV “development”
   
   <Directory /path/to/public> 
      DirectoryIndex index.php 
      AllowOverride All 
      Order allow,deny 
      Allow from all 
   </Directory> 
</VirtualHost>

Fichier hôte système

Maintenant, ajoutez une entrée d'hôte à votre machine à l'aide de la commande suivante.

sudo vi /etc/hosts

Ensuite, ajoutez la ligne suivante à la fin du fichier.

127.0.0.1 hello.app

Pour rendre toutes les modifications disponibles, redémarrez votre serveur Apache et demandez l'url, http://hello.app. Il produit la page d'accueil de FuelPHP.

FuelPHP est basé sur des tests de combat Model-View-Controller l'architecture avec HMVC (Hierarchical MVC)soutien. Alors que MVC fournit un développement d'applications flexible et en couches, HMVC va encore plus loin pour permettre la widgetisation de l'application Web.

La force de FuelPHP est qu'il n'applique pas de moyens spécifiques pour développer une application. Il fournit simplement une structure standard simple et facile à utiliser. Les développeurs sont libres d'utiliser l'ensemble prédéfini de fonctionnalités fournies par FuelPHP ou de le modifier chaque fois que nécessaire. Toutes les fonctionnalités fournies par FuelPHP, y compris la fonctionnalité principale, peuvent être modifiées en fonction des besoins de l'application.

Modèle

Le modèle est l'entité commerciale de l'application. Controller et View échangent des données sous la forme de Model. Le modèle permet une représentation uniforme de nos données commerciales. Il permet à la couche de base de données d'interagir avec la couche d'application Web de manière standard et fournit une option pour sélectionner, enregistrer, modifier et supprimer nos entités de base de données.

Manette

Une application MVC typique démarre à partir d'un contrôleur. Une fois qu'un utilisateur envoie une demande à l'application Web FuelPHP, l'application rassemble toutes les informations sur la demande et les envoie au contrôleur. Le contrôleur exécute la logique métier requise de la page demandée, puis appelle la vue correspondante avec les données traitées sous la forme de modèles.

Vue

La vue est la couche de présentation de l'application MVC. View décide comment montrer le modèle à l'utilisateur. Il prend en charge le rendu simple des données dans la mise en page avancée, ce qui permet au site Web de normaliser la conception sur toutes les pages. View fournit également une prise en charge de la thématisation, ce qui permet une modification rapide de la conception dans toute l'application.

Présentateur

Presenter est une fonction spéciale fournie par FuelPHP. C'est le lien entre Controller et View. Le contrôleur peut partager certaines de ses responsabilités de bas niveau telles que la récupération du modèle de la base de données, la génération de données pour la vue, etc. Le contrôleur appelle Presenter au lieu de View, qui à son tour appelle View. Presenter permet une séparation pure entre la logique métier et la couche de présentation.

MVC hiérarchique

FuelPHP fournit une option pour appeler un contrôleur à partir d'un autre contrôleur, similaire à la demande du client (navigateur). Si un contrôleur appelle un autre contrôleur, le contrôleur appelé renverra la réponse au contrôleur appelant au lieu de la restituer au client (navigateur). Cela permetwidgetizationde l'application Web. Par exemple, la section des commentaires peut être affichée comme une page autonome ainsi que comme une sous-section de la page principale (blog).

Module

L'une des principales caractéristiques de FuelPHP est qu'une section de l'application Web peut être convertie en modules, qui peuvent être partagés entre les différentes applications. Par exemple, un module de blog créé pour une application peut être réutilisé dans une autre application en copiant simplement le code du module de l'application source vers l'application cible.

Notez que créer un nouveau module est aussi simple que de développer l'application principale. La structure est similaire à l'application principale à la seule exception que le module doit coder un dossier séparé.

Paquet

FuelPHP fournit une option pour organiser le code en une seule unité appelée Package. Un package peut contenir une ou plusieurs fonctionnalités nécessaires à l'application Web. Par exemple, un composant de base de données tel que ORM, email, etc., peut être organisé dans un package et utilisé chaque fois que nécessaire.

Un package est différent d'un module en ce sens que le package ne contient aucune page Web ni aucune page Web partielle. Le package peut être utilisé dans FuelPHP ainsi que dans tout autre framework PHP.

Flux de travail

Le flux de travail du FuelPHP est simple et facile à comprendre. Il est illustré dans le diagramme suivant.

L'utilisateur envoie une demande à l'application.
Le contrôleur reçoit la demande et recueille des informations en interagissant avec le modèle, qui à son tour interagit avec la base de données.
Le contrôleur recueille des informations en interagissant avec un autre contrôleur en envoyant une sous-demande aux autres contrôleurs.
Le contrôleur envoie le modèle récupéré à la vue, qui à son tour génère la présentation et l'envoie au client en tant que réponse.
Dans certains cas, le contrôleur peut passer le contrôle au présentateur. Dans ce cas, le présentateur rassemble les informations du modèle et les envoie au client. Ici, le présentateur n'effectue aucune logique métier, sauf pour récupérer le modèle de la base de données.

Dans ce chapitre, nous verrons comment créer une application simple dans le framework FuelPHP. Comme indiqué précédemment, vous savez comment créer un nouveau projet dans Fuel. Nous pouvons prendre un exemple des détails des employés.

Commençons par créer un projet nommé Employee à l'aide de la commande suivante.

oil create employee

Après avoir exécuté la commande, un employee le projet est créé avec les éléments suivants file structure -

employee 
├── CHANGELOG.md 
├── composer.json 
├── composer.lock 
├── composer.phar 
├── CONTRIBUTING.md 
├── fuel 
│   ├── app 
│   │   ├── bootstrap.php 
│   │   ├── cache 
│   │   ├── classes 
│   │   ├── config 
│   │   ├── lang 
│   │   ├── logs 
│   │   ├── migrations 
│   │   ├── modules 
│   │   ├── tasks 
│   │   ├── tests 
│   │   ├── themes 
│   │   ├── tmp 
│   │   ├── vendor 
│   │   └── views 
│   ├── core 
│   │   ├── base56.php 
│   │   ├── base.php 
│   │   ├── bootstrap.php
│   │   ├── bootstrap_phpunit.php 
│   │   ├── classes 
│   │   ├── composer.json 
│   │   ├── config 
│   │   ├── CONTRIBUTING.md 
│   │   ├── lang 
│   │   ├── phpunit.xml 
│   │   ├── tasks 
│   │   ├── tests 
│   │   ├── vendor 
│   │   └── views 
│   ├── packages 
│   │   ├── auth 
│   │   ├── email 
│   │   ├── oil 
│   │   ├── orm 
│   │   └── parser 
│   └── vendor 
│       ├── autoload.php 
│       ├── composer 
│       ├── fuelphp 
│       ├── michelf 
│       ├── monolog 
│       ├── phpseclib 
│       └── psr 
├── LICENSE.md 
├── oil 
├── public 
│   ├── assets 
│   │   ├── css 
│   │   ├── fonts 
│   │   ├── img 
│   │   └── js 
│   ├── favicon.ico 
│   ├── index.php 
│   └── web.config 
├── README.md 
└── TESTING.md  
42 directories, 21 files

Structure de l'application

Le framework FuelPHP fournit une structure d'application bien organisée. Laissez-nous vérifier certains des fichiers et dossiers importants de l'application.

fuel - Contient tous les fichiers PHP.
public - Contient tous les actifs qui sont directement accessibles via le navigateur tels que JavaScript, CSS, images, etc.
oil- Un exécutable utilisé pour exécuter des tâches de ligne de commande telles que la génération de code ou le débogage interactif au sein de votre application. C'est facultatif.
fuel/app/- Contient tous les fichiers PHP spécifiques à l'application. Il contient des modèles, des vues et des contrôleurs.
fuel/core/ - C'est là que le framework Fuel lui-même vit.
fuel/packages/- Contient tous les paquets de carburant. Par défaut, fuel contiendra trois packages: oil, auth et orm. Ces packages ne seront chargés que si vous en avez besoin.
fuel/app/config/- Contient tous les fichiers de configuration liés à l'application. Le fichier de configuration de l'application principale, le fichier config.php se trouve ici.
fuel/app/classes/- Contient tous les fichiers PHP basés sur MVC spécifiques à l'application. Il contient des contrôleurs, des modèles, des classes d'assistance, des bibliothèques, etc.
fuel/app/classes/controller/ - Les contrôleurs sont placés ici.
fuel/app/classes/model/ - Les modèles sont placés ici.
fuel/app/views/- Contient des fichiers de vue. Il n'y a pas de conventions de dénomination spécifiques pour les vues.

Ajouter un contrôleur

Comme indiqué précédemment, FuelPHP est basé sur le modèle de développement Model-View-Controller (MVC). MVC est une approche logicielle qui sépare la logique d'application de la présentation. Dans le modèle MVC, le contrôleur joue un rôle important et chaque page Web d'une application doit être gérée par un contrôleur. Par défaut, les contrôleurs sont situés dansfuel/app/classes/controller/dossier. Vous pouvez créer votre propre classe Controller ici.

Accédez à l'emplacement fuel / app / classes / controller / et créez le fichier employee.php. Pour créer un nouveau contrôleur, étendez simplement la classe Controller fournie par FuelPHP, définie comme suit.

employé.php

<?php 
   class Controller_Employee extends Controller { 
      public function action_home() { 
         
         // functionality of the home page  
         echo "FuelPHP-Employee application!"; 
      } 
   }

Maintenant, nous avons créé un contrôleur d'employé et ajouté une méthode publique, action_home, qui imprime un texte simple.

Routage

Le routage résout l'URI de la page Web en un contrôleur et une action spécifiques. Chaque page Web d'une application FuelPHP doit passer par un routage avant l'exécution réelle du contrôleur. Par défaut, chaque contrôleur peut être résolu à l'aide du modèle d'URI suivant.

<controller>/<action>

Où,

controller est le nom du contrôleur moins l'espace de noms, employé
action est le nom de la méthode moins le mot-clé action_, home

Le contrôleur nouvellement créé est accessible par http://localhost:8080/employee/home et cela produira le résultat suivant.

Résultat

Dans ce chapitre, nous allons comprendre comment configurer une application FuelPHP. Par défaut, les fichiers de configuration sont stockés dans lefuel/app/configdossier. La configuration principale de l'application estfuel/app/config/config.php. La configuration est spécifiée à l'aide du tableau associé de PHP.

Aperçu

Par défaut, tous les fichiers de configuration par défaut sont définis dans fuel/core/configdossier. Pour remplacer une configuration par défaut, ajoutez la clé correspondante dans le/fuel/app/config/config.phpfichier et modifiez la valeur. Nous pouvons utiliser la «notation par points» pour simplifier les tableaux multidimensionnels. Par exemple, les configurations suivantes ont le même objectif (charger des packages spécifiés).

array("always_load" => array("packages" => array( ... ) ) ); 
always_load.packages = array( ... );

La configuration peut être regroupée par objectif et spécifiée à l'aide de différents fichiers tels que db.php pour la configuration de la base de données, package.php pour la gestion des packages, etc.

Type de format de configuration

FuelPHP est assez flexible et fournit un format différent pour spécifier la configuration. Le format de configuration par défaut est PHP utilisant un tableau php. Les autres options sont -

INI - Configuration textuelle simple prise en charge par de nombreux logiciels, y compris le langage PHP lui-même.

[group]
key = value

YAML - Gestion de la configuration facile à comprendre, basée sur l'indentation et lisible par l'homme.

group:
   key: value

JSON - Format de fichier facile à comprendre et le plus utilisé par les développeurs.

{ 
   "group" : 
   { 
      "key": "value" 
   } 
}

Memcached- Stocke la configuration dans un serveur Memcached. Les détails du serveur Memcached peuvent être spécifiés dans le fichier de configuration principal,fuel/app/config/config.php en utilisant config.memcached entrée.

DB- Stocke la configuration dans le système RDBMS. La structure de table de la table de configuration est la suivante.

CREATE TABLE IF NOT EXISTS `config` ( 
   `identifier` char(100) NOT NULL, 
   `config` longtext NOT NULL, 
   `hash` char(13) NOT NULL, 
   PRIMARY KEY (`identifier`) 
)

Les détails de la base de données et de la table peuvent être spécifiés dans le fichier de configuration à l'aide des entrées config.database et config.table_name .

Environnement

L'environnement permet à FuelPHP de fonctionner dans différents modes en chargeant différentes configurations. FuelPHP prend en charge l'environnement suivant.

Development - \ Fuel :: DEVELOPMENT définit le mode de développement
Production - \ Fuel :: PRODUCTION définit le mode de production
Test - \ Fuel :: TEST définit le mode de test
Staging - \ Fuel :: STAGING définit le mode de mise en scène

FuelPHP prend également en charge la création d'un nouvel environnement. Cela permettra à chaque développeur d'avoir son propre paramètre de configuration et de l'activer lors du codage et du test de l'application. La configuration d'un environnement spécifique peut être ajoutée en créant simplement un dossier avec le nom de l'environnement (exemple: test) et en plaçant le fichier de configuration dans le dossier nouvellement créé, illustré ci-dessous.

. ├── config.php 
├── db.php 
├── development 
│   └── db.php 
├── production 
│   └── db.php 
├── routes.php 
├── staging 
│   └── db.php
└── test 
    └── db.php  
4 directories, 7 files

Définissez votre environnement

Il existe trois façons de configurer votre environnement.

Option 1- Définissez l'environnement avec les variables d'environnement du serveur Web. Ajoutez le code suivant dans la section hôte virtuel danshttpd.conffichier du serveur Web Apache. Il peut être ajouté.htaccess fichier ainsi.

SetEnv FUEL_ENV production

Option 2 - Définir l'environnement avec le fichier d'amorçage FuelPHP, /fuel/app/bootstrap.php

Fuel::$env = (isset($_SERVER['FUEL_ENV']

Option 3 - Définir l'environnement à l'aide d'huile

$ env FUEL_ENV = production php oil -v

Il produit le résultat suivant.

Fuel: 1.8 running in "production" mode

Controllerssont responsables du traitement de chaque demande qui entre dans l'application FuelPHP. Selon FuelPHP, les contrôleurs sont situés àfuel/app/classes/controller/. Créons d'abord un contrôleur des employés.

employé.php

<?php  
   class Controller_Employee extends Controller { 
      public function action_home() { 
         echo "FuelPHP-Employee application!"; 
      }  
      
      public function action_index() { 
         echo "This is the index method of employee controller"; 
      } 
   }

Méthodes du contrôleur

Les contrôleurs traitent une demande Web en utilisant l'un de ses action_ méthodes. Nous pouvons créer autant de méthodes action_ en fonction des besoins de l'application. La méthode action_ par défaut est action_index . La méthode action_index peut être appelée par l'une des URL suivantes.

http://localhost:8080/employee/index
http://localhost:8080/employee/

Résultat

Créons un nouveau actionmethod, action_show dans notreemployee application.

<?php  
   class Controller_Employee extends Controller { 
      public function action_home() { 
         echo "FuelPHP-Employee application!"; 
      }  
      public function action_index() { 
         echo "This is the index method of employee controller"; 
      }  
      public function action_show() { 
         echo "This is the show method of employee controller"; 
      } 
   }

La méthode action_show peut être appelée à l'aide de l'URL suivante.

http://localhost:8080/home/show

Résultat

before (), méthode

Nous pouvons créer une méthode, beforedans notre contrôleur. Cette méthode sera exécutée avant chaque appel de méthode action_ . Elle ne sera pas appelée si cette méthode s'avère ne pas exister. Cette méthode nous aide à écrire des actions courantes telles que la vérification de connexion, la récupération des données par défaut, etc.

Créons une méthode avant et imprimons un simple message texte.

public function before() { 
   echo "This message comes from <em>before()</em> method</br>"; 
}

Page d'index avec action avant

Afficher la page avec l'action avant

after (), méthode

after() méthode est similaire à before()mais exécutée après l' appel de la méthode action_ . after () prend la réponse comme entrée et renvoie l' objet de réponse .

public function after($response) { if ( ! $response instanceof Response) { 
      $response = \Response::forge($response, $this->response_status); } return $response; 
}

Si l'entrée est NULL ou non l' objet de réponse, puis créez une nouvelle réponse objet en utilisant la méthode de forge de réponse et de le retourner. Nous apprendrons la classe Response en détail dans les chapitres suivants.

Extension des contrôleurs

Nous pouvons étendre un contrôleur à partir d'un autre contrôleur. Voici la syntaxe de base.

class Controller_Employee extends Controller_Welcome { 
   // controller methods 
}

Cela aidera à partager les méthodes.

Générer un contrôleur

Le carburant a la possibilité de générer un contrôleur à l'aide de la commande Oil. Voici la syntaxe.

Syntaxe

oil g controller <controller-name>

Exemple

oil g controller sample

Après avoir exécuté la commande ci-dessus, vous verrez la réponse suivante.

Résultat

Creating view: /path/to/project/fuel/app/views/template.php 
Creating view: /path/to/project/fuel/app/views/sample/index.php 
Creating controller: /path/to/project/fuel/app/classes/controller/sample.php

Type de contrôleurs

FuelPHP fournit différents types de contrôleurs à des fins diverses. Ils sont les suivants -

Contrôleur de base
Contrôleur de modèle
Contrôleur de repos
Contrôleur hybride

Contrôleur de base

Controller est le contrôleur de base pour tous les différents types de contrôleurs disponibles dans FuelPHP. Il fournit toutes les fonctionnalités de base nécessaires pour traiter une requête Web. Il prend en charge les requêtes, les réponses, les sessions, etc. Nous les utiliserons dans tous les exemples, sauf indication contraire.

Contrôleur de modèle

Un contrôleur de modèle est une extension du contrôleur de base. Il prend en charge les modèles, prédéfinis avant () et après (). Fondamentalement, il peut être utilisé pour envelopper votre vue dans une mise en page avec un en-tête, un pied de page, une barre latérale, etc. Pour créer un contrôleur de modèle, nous devons étendre la classe Controller_Template . Par défaut, toutes les méthodes d'une classe qui étend Controller_Template doivent utiliser le modèle.

Il est défini comme suit.

class Controller_Employee extends Controller_Template { 
   public function action_index() { 
      // add methods 
   } 
}

Nous discuterons plus en détail du contrôleur de modèle dans le chapitre Vues.

Contrôleur de repos

Un contrôleur de repos est une extension du contrôleur de base. Il a un support prédéfini pour la programmation de l'API REST. Cela vous permettra de créer facilement des API.

Pour créer un contrôleur de repos, vous devez étendre la classe Controller_Rest . Il est défini comme suit.

class Controller_Employee extends Controller_Rest { 
   public function action_index() { 
      // add methods 
   } 
}

Nous discuterons plus en détail du contrôleur de repos dans le chapitre Ajax.

Contrôleur hybride

Le contrôleur hybride exécute les fonctionnalités du contrôleur REST et du contrôleur de modèle dans un seul contrôleur de base.

Les cartes de routage demandent un URI à la méthode d'un contrôleur spécifique. Dans ce chapitre, nous discuterons du concept derouting dans FuelPHP en détail.

Configuration

Le fichier de configuration des routes se trouve dans fuel/app/config/routes.php. Le défautroutes.php le fichier est défini comme suit -

<?php 
   return array ( 
      '_root_'  => 'welcome/index',   // The default route 
      '_404_'   => 'welcome/404',     // The main 404 route 
      'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'), 
   );

Ici, _root_est la route par défaut prédéfinie, qui sera mise en correspondance lorsque l'application est demandée avec le chemin racine, / par exemple http: // localhost: 8080 / . La valeur de la _root_ est le contrôleur et l'action à résoudre lorsqu'elle est mise en correspondance.welcome/indexrésout le contrôleur Controller_Welcome et la méthode d'action action_index . De même, nous avons les routes réservées suivantes.

root - La route par défaut lorsqu'aucun URI n'est spécifié.
403 - Il lance lorsque HttpNoAccessException est trouvé.
404 - Il revient lorsque la page n'est pas trouvée.
500 - Il lance lorsque HttpServerErrorException est trouvé.

Routage simple

L'itinéraire est comparé à l'URI de la demande. Si une correspondance est trouvée, la demande est acheminée vers l'URI. Le routage simple est décrit comme suit,

return array ( 
   'about'  => 'site/about', 
   'login' => 'employee/login', 
);

Ici, about correspond à http: // localhost: 8080 / about et résout le contrôleur, Controller_Site et la méthode d'action, action_about

login correspond à http: // localhost: 8080 / login et résout le contrôleur, Controller_Login et la méthode d'action, action_login

Routage avancé

Vous pouvez inclure n'importe quelle expression régulière dans vos itinéraires. Fuel prend en charge les fonctionnalités de routage avancées suivantes -

:any - Cela correspond à n'importe quoi à partir de ce point dans l'URI, ne correspond pas à «rien»
:everything - Comme: tout, mais correspond également à «rien»
:segment - Cela correspond à seulement 1 segment dans l'URI, mais ce segment peut être n'importe quoi
:num - Cela correspond à tous les nombres
:alpha - Cela correspond à tous les caractères alpha, y compris UTF-8
:alnum - Cela correspond à tous les caractères alphanumériques, y compris UTF-8

Par exemple, l'itinéraire suivant correspond à l'URI http: // localhost: 8080 / hello / FuelPHP et résout controller, Controller_Welcome et action action_hello

'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'),

La méthode d'action correspondante dans Controller_Welcome est la suivante,

public function action_hello() { 
   $this->name = Request::active()->param('name', 'World'); $message = "Hello, " . $this->name; echo $message; 
}

Ici, nous avons utilisé la classe Request pour obtenir le paramètre de nom à partir de l'URL. Si le nom n'est pas trouvé, nous utilisons World comme valeur par défaut. Nous allons apprendre la classe Request dans le chapitre Request and Response .

Résultat

Action de la méthode HTTP

FuelPHP prend en charge les routes pour correspondre aux actions préfixées par la méthode HTTP. Voici la syntaxe de base.

class Controller_Employee extends Controller { 
   public function get_index() { 
      // called when the HTTP method is GET. 
   }  
   public function post_index(){ 
      // called when the HTTP method is POST. 
   } 
}

Nous pouvons acheminer vos URL vers les contrôleurs et les actions en fonction du verbe HTTP dans le fichier de configuration comme suit.

return array ( 
   // Routes GET /employee to /employee/all and POST /employee to /employee/create 
   ‘employee’ => array(array('GET', new Route(‘employee/all')), array('POST', 
      new Route(‘employee/create'))), 
);

La requête HTTP et la réponse HTTP jouent un rôle important dans toute application Web. Nous devons obtenir les détails complets de la requête http pour la traiter correctement. Une fois traitées, nous devons envoyer les données traitées au client via une réponse http.

FuelPHP fournit une excellente Request et Responseclasse pour lire et écrire respectivement la requête HTTP et la réponse HTTP. Apprenons les deuxRequest et Response classe dans ce chapitre.

Demande

Dans une application Web typique, l'application doit analyser les détails de la demande en cours. La classe Request fournit des méthodes simples pour analyser la demande en cours à traiter par l'application. Request fournit également une option pour créer une nouvelle demande en agissant en tant que client http.

La création d'une nouvelle demande permet à l'application de demander une autre partie de l'application ou entièrement une autre application et d'afficher le résultat. Apprenons à analyser la requête entrante dans ce chapitre et apprenons à créer une nouvelle requête dans le chapitre Requête HMVC.

Analyse d'une requête

La classe Request fournit trois méthodes pour obtenir les détails de la requête http. Ils sont comme suit,

active - C'est une méthode statique, qui renvoie la requête http active actuelle.

$currentRequest = Request::active();

param - Il renvoie la valeur du paramètre spécifié. Il contient deux arguments. Le premier argument est le nom du paramètre et le deuxième argument est la valeur à renvoyer, si le paramètre n'est pas disponible dans la requête http actuelle.

$param = Request::active()->param('employee_name', 'none');

params - C'est la même chose que param sauf qu'il renvoie tous les paramètres sous forme de tableau.

$params = Request::active()->params();

Exemple

Créons un formulaire simple et traitons le formulaire en utilisant la classe de requête.

Step 1- Créez une nouvelle action, action_request dans le contrôleur des employés.

public function action_request() { 
}

Step 2 - Appelez les méthodes de requête pour obtenir tous les paramètres de la requête en cours.

public function action_request() { 
   $params = Request::active()->params(); 
}

Step 3 - Vider le tableau de paramètres récupéré.

public function action_request() { 
   $params = Request::active()->params(); echo dump($params); 
}

Step 4- Modifiez le routage pour inclure les paramètres dans le fichier de configuration de la route, fuel / app / config / routes.php

'employee/request(/:name)?' => array('employee/request', 'name' => 'name'),

Maintenant, en demandant la nouvelle action, http: // localhost: 8080 / employee / request / Jon, il affichera la réponse suivante.

Réponse

La classe Response fournit des options pour créer une réponse http. Par défaut, nous n'avons pas besoin d'utiliser une classe de réponse directement dans la plupart des situations. Au lieu de cela, nous utilisons View (que nous apprendrons dans le chapitre suivant) pour créer une réponse http. View masque la réponse http du développeur et envoie la réponse au client à l'aide de la classe Response sous-jacente . Dans une situation avancée, nous utilisons directement la classe Response et créons une réponse http complète.

Créer une réponse

La réponse se compose d'en-têtes et de corps. L'en-tête principal est le code d'état http. Les codes d'état HTTP sont des codes standard définis dans le protocole HTTP pour décrire la réponse. Par exemple, un code d'état 200 signifie que la demande est réussie.

La classe Response fournit trois arguments pour créer la réponse http,

$body - corps de la réponse http
$status_code - code d'état de la réponse http
$headers - en-têtes optionnels comme tableau

$body = "Hi, FuelPHP"; 
$headers = array ( 'Content-Type' => 'text/html', ); $response = new Response($body, 200, $headers);

Créons une nouvelle action, action_response dans le contrôleur d'employé comme suit.

public function action_response() { 
   $body = "Hi, FuelPHP"; $headers = array ('Content-Type' => 'text/html',); 
   $response = new Response($body, 200, $headers); return $response; 
}

Résultat

Méthodes

La classe Response fournit de nombreuses méthodes pour manipuler les réponses http. Ils sont comme suit,

forge - C'est la même chose que le constructeur de classe de réponse comme vu ci-dessus.

return Response::forge("Hi, FuelPHP", 404);

redirect- Il offre la possibilité de rediriger vers une URL au lieu d'envoyer une réponse. Il contient les arguments suivants,

a.url- URL de destination b. method - méthodes de redirection. emplacement (par défaut) et actualiser c . redirect_code - code d'état http. La valeur par défaut est 302.

// use a URL 
Response::redirect('http://some-domain/index', 'refresh');  

// or use a relative URI 
Response::redirect('employee/list');

redirect_back- Elle est similaire à la méthode de redirection, sauf qu'elle redirige vers la page précédente. Nous pouvons spécifier la page de redirection, si aucune page arrière n'est disponible.

// If there is no back page, go to the employee list page 
Response::redirect_back('/employee/list', 'refresh');

set_status - Il fournit une option pour définir le code d'état http.

$response = new Response(); $response->set_status(404);

set_header - Il fournit une option pour définir les en-têtes http.

$response = new Response(); $response->set_header('Content-Type', 'application/pdf');  

// replace previous value using third arguments 
$response->set_header('Content-Type', 'application/pdf', 'text/plain');

set_headers - C'est la même chose que set_header sauf qu'il fournit une option pour définir plusieurs en-têtes à l'aide de array.

$response = new Response(); 
$response->set_headers (array 
   'Content-Type' => 'application/pdf', 
   'Pragma' => 'no-cache', 
));

get_header - Il permet d'obtenir les détails d'en-tête de l'ensemble précédent.

$response = new Response(); 
$response->set_header('Pragma', 'no-cache'); // returns 'no-cache' $header = $response->get_header('Pragma'); // returns array('Pragma' => 'no-cache') $header = $response->get_header();

body - Il fournit une option pour définir le corps de la réponse http.

$response = new Response(); 
$response->body('Hi, FuelPHP'); // returns 'Hi, FuelPHP' $body = $response->body();

send_headers- Il envoie les en-têtes au client demandé. FuelPHP utilise cette méthode pour envoyer la réponse au client. Normalement, nous n'avons pas besoin d'utiliser cette méthode.

$response->send_headers();

send - Identique à send_headers sauf que les en-têtes peuvent être restreints dans la réponse http.

// send the headers as well 
$response->send(true); // only send the body $response->send(false); 
$response->send();

Viewest la couche de présentation de l'application MVC. Il sépare la logique d'application de la logique de présentation. Lorsqu'un contrôleur a besoin de générer du HTML, du CSS ou tout autre contenu, il transfère la tâche au moteur de visualisation.

FuelPHP fournit une classe simple et flexible, View avec toutes les fonctionnalités nécessaires d'un moteur de visualisation. La classe View prend en charge le rendu du fichier de vue. Afficher le fichier est une page HTML avec des instructions PHP intégrées. Les variables du fichier de vue peuvent être définies en utilisant la classe View comme tableau PHP et référencées dans le fichier de vue en utilisant la clé du tableau. Voyons quelques-unes des méthodes importantes de la classe View.

la forge

Purpose - Crée un nouvel objet View
Parameter - Voici les paramètres
- $file - Chemin du fichier de vue par rapport au dossier de vues, fuel / app / views
- $data - Tableau de valeurs
- $filter - Définit l'encodage automatique, par défaut les paramètres dans le fichier de configuration principal
Returns - Instance de la vue

Par exemple,

$view = View::forge ('path/to/view', array( 'title' => "Show employee, 'employees' => $employees, 
));

auto_filter

Purpose - Définissez s'il faut encoder les données ou non
Parameter - Voici le paramètre
- $filter - vrai / faux
Returns - Objet de la vue actuelle

Par exemple,

$view->auto_filter(); 
$view = $view->auto_filter(false);

set_filename

Purpose - Permet de définir ou de modifier le fichier de vue.
Parameter - Voici le paramètre -
- $file - Chemin pour afficher le fichier par rapport au dossier vues, carburant / application / vues
Returns - Objet Vue actuelle

Par exemple,

$view = new View();
$view>set_filename('path/to/view');

ensemble

Purpose - Définissez la valeur d'une ou plusieurs variables
Parameter - Voici les paramètres
- $key - Nom de variable ou tableau de valeurs
- $value - Valeur / null
- $filter - Paramètre d'encodage, vrai / faux
Returns - Objet de la vue actuelle

Par exemple,

$view = new View(); $view->set(array('name' => 'Jon'));

set_global

set_global est similaire à set, sauf qu'il s'applique à toutes les vues et les variables sont accessibles par toutes les vues. C'est une méthode statique.

View::set_global('name', 'Jon', false);

set_safe

Purpose - Réglez la valeur d'une ou plusieurs variables avec le codage sécurisé activé.
Parameter - Voici les paramètres -
- $key - Nom de variable ou tableau de valeurs
- $value - Valeur / null
Returns - Objet de la vue actuelle

Par exemple,

$view = new View(); $view->set_safe(array('name' => 'Jon'), null);

avoir

Purpose - Obtenez la valeur d'une ou plusieurs variables
Parameter - Voici les paramètres
- $key - Nom de variable
- $default - Valeur par défaut à renvoyer si la clé n'est pas trouvée
Returns - Valeur de la clé d'entrée

Par exemple,

$view = new View(); $name = $view>get('name');  // name = 'Jon'

rendre

Purpose - Rendre les fichiers de vue en chaîne en les fusionnant avec les variables locales et globales
Parameter - Voici les paramètres -
- $file - Le nom du fichier de vue
Returns - Le fichier de vue rendu sous forme de chaîne

Par exemple,

$html = View::forge()->render('/path/to/view');

Créer une vue

Pour comprendre les vues, modifions la méthode d'action, action_show du contrôleur, Controller_Employee .

employé.php

<?php  
   class Controller_Employee extends Controller { 
      public function action_show() {
         return View::forge('employee/show'); 
      } 
   }

Créez maintenant un dossier employé dans le répertoire des vues, situé dans fuel / app / views . Ensuite, créez un fichier show.php dans le dossier des employés et ajoutez le code suivant.

show.php

<h3> My first view </h3>

Maintenant, demandez l'url http: // localhost: 8080 / employee / show et cela produira le résultat suivant.

Passer des données à afficher

Nous pouvons transmettre des données aux vues à l'aide des méthodes View, comme indiqué précédemment. Voici un exemple simple.

employé.php

class Controller_Employee extends Controller { 
   public function action_show() { 
      $data = array(); //stores variables going to views 
      $data['name'] = ‘Jon’; $data[‘job’] = ‘Designer’;  
      
      //assign the view to browser output 
      return View::forge('employee/show', $data); 
   } 
}

Maintenant, ajoutez les modifications dans le view fichier.

show.php

<html> 
   <body> 
      Hello, <?php echo $name; ?>. 
      Your job is, <?php echo $job; ?>. 
   </body> 
</html>

Après avoir demandé l'URL, il affichera le nom et le travail comme suit -

Afficher le filtre

Les vues utilisent le codage de sortie pour transmettre tout ce que vous voulez. Si vous souhaitez transmettre des données non filtrées, nous pouvons utiliser la méthode set.

employé.php

class Controller_Employee extends Controller { 
   public function action_show() { 
      $view = \View::forge('employee/show'); 
      $view->set('name', 'Jon', true); $view->set('job', '<em>Designer</em>', false); 
      return $view; 
   } 
}

Après avoir demandé l'URL, il affichera les détails du travail dans le style d'accentuation, comme suit.

Vues imbriquées

FuelPHP prend en charge les vues imbriquées. Dans les vues imbriquées, une vue peut contenir une ou plusieurs vues. Pour définir les vues dans une autre vue, nous pouvons utiliser la méthode de rendu comme suit.

employé.php

class Controller_Employee extends Controller { 
   public function action_nestedview() { 
      
      //assign variables 
      $data = array(); 
      $data['title'] = 'Home'; $data['name'] = 'Jon'; 
      $data['job'] = 'Designer'; $views = array(); 
      $views['head'] = View::forge('head', $data)->render(); 
      $views['content'] = View::forge('employee/show', $data)->render();  
      return View::forge('layout', $views, false)->render(); 
   } 
}

fuel / app / views / layout.php

<html> 
   <head> 
      <?php echo $head; ?> 
   </head> 
   
   <body> 
      <?php echo $content; ?> 
   </body> 
</html>

carburant / app / vues / head.php

<title>
   <?php echo $title; ?>
</title>

carburant / app / vues / employé / show.php

Hello, <?php echo $name; ?>. Your job is, <?php echo $job; ?>.

Après avoir demandé l'URL, http: // localhost: 8080 / employee / nestedview et vérifié la vue source, il donne le code suivant.

<html> 
   <head> 
      <title>Home</title> 
   </head> 
   
   <body> 
      Hello, Jon. 
      Your job is, Designer. 
   </body> 
</html>

Contrôleur de modèle

FuelPHP fournit un contrôleur, Controller_Template avec un concept de disposition intégré. Le concept de mise en page est fait en utilisantbefore() et after()méthode du contrôleur. Pour utiliser le contrôleur de modèle, nous devons étendre le contrôleur en utilisant Controller_Template au lieu de Controller. Lors de l'utilisation de la méthode after () / before (), nous devons appeler parent :: before et parent :: after, sinon, le modèle se brise.

<?php 
   class Controller_Test extends Controller_Template { 
      public function before() { 
         parent::before(); 
         // do stuff 
      } 
        
      public function after($response) { $response = parent::after($response); // do stuff return $response; 
      } 
   }

template.php

Il s'agit d'un fichier modèle par défaut dans Fuel. Le fichier modèle est utilisé pour appeler des partiels JS, CSS, HTML et des vues partielles. Il est situé aufuel/app/views/. Les modèles sont utilisés pour envelopper votre vue dans une mise en page avec un en-tête, un pied de page, une barre latérale, etc. Nous pouvons changer le modèle par défaut en utilisant la variable $ template dans la méthode d'action comme suit.

carburant / application / classes / contrôleur / test.php

<?php  
   class Controller_Test extends Controller_Template { 
      public $template = 'template_test'; 
      public function action_index() { 
         $this->template->title = 'Example Page'; $this->template->content = View::forge('test/index'); 
      } 
   }

fuel / app / views / template_test.php

<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <title><?php echo $title; ?></title> <?php echo Asset::css('bootstrap.css'); ?> </head> <body> <div> <?php echo $content; ?>
      </div> 
   </body> 
</html>

carburant / app / vues / test / index.php

<h3>My Test page</h3>

Maintenant, demandez l'URL http: // localhost: 8080 / test et cela produira le résultat suivant.

Résultat

<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <title>Example Page</title> 
      <link type = "text/css" rel = "stylesheet" 
         href = "http://localhost:8080/assets/css/bootstrap.css?1464964766" />
   </head> 
   
   <body> 
      <div> 
         <h3>My Test page</h3> 
      </div> 
   </body> 
</html>

Générer une page de vue

Vous pouvez générer une page d'affichage à l'aide de la console Fuel's Oil. Voici la syntaxe de base.

oil g controller <controller-name> <page1> <page2> ..

Pour générer un contrôleur d'administration avec des pages d'accueil et de connexion, utilisez la commande suivante.

oil g controller admin home login

Résultat

Creating view: /path/to/app/fuel/app/views/admin/home.php 
Creating view: /path/to/app/fuel/app/views/admin/login.php 
Creating controller: /path/to/app/fuel/app/classes/controller/admin.php

FuelPHP fournit une couche supplémentaire après le contrôleur pour générer des vues. Une fois que le contrôleur traite l'entrée et en a terminé avec la logique métier, il envoie le contrôle auPresenter, qui prend en charge la logique supplémentaire telle que la récupération des données de la base de données, la définition des données de vue, etc., puis appelle l'objet View.

Nous pouvons rendre les vues en utilisant la classe Presenter comme suit -

carburant / application / classes / contrôleur / employé.php

public Controller_Employee extends Controller { 
   public function action_welcome() { 
      return Presenter::forge('employee/hello'); 
   } 
}

L'emplacement par défaut de la classe de présentateur est fuel / app / classes / presenter / . Voici un exemple simple.

carburant / application / classes / présentateur / employé / hello.php

<?php  
   class Presenter_Employee_Hello extends Presenter { 
      public function view() { 
         $this->name = Request::active()->param('name', 'World'); 
      } 
   }

Le fichier de vue de la classe de présentateur ci-dessus se résout en employee / hello.php par rapport au dossier de vues , qui est comme spécifié.

carburant / app / vues / employé / hello.php

<h3>Hi, <?php echo $name; ?></h3>

Enfin, modifiez l'itinéraire pour qu'il corresponde à l'action de bienvenue de l'employé, comme suit:

fuel / app / config / routes.php

'employee/hello(/:name)?' => array('employee/welcome', 'name' => 'hello'),

Maintenant, en demandant l'URL, http: // localhost: 8080 / employee / hello / Jon donne le résultat suivant.

Résultat

Le modèle joue un rôle important dans le cadre Web FuelPHP. Il représente les entités commerciales de l'application. Ils sont soit fournis par les clients, soit extraits de la base de données backend, manipulés selon les règles métier et réintégrés dans la base de données. Découvrons les modèles et comment ils interagissent avec le système back-end dans ce chapitre.

Créer un modèle

Dans FuelPHP, model est simplement une classe PHP simple étendant la classe Model intégrée. Par défaut, les modèles peuvent être préfixés avec Model_ similaire aux contrôleurs et doivent être placés dansfuel/app/classes/model/dossier. Créons un modèle d'employé de base et développons-le au fur et à mesure.

fuel / app / classes / model / employee.php

<?php 
   namespace Model; 

   class Model_Employee extends \Model { 
      public static function fetchAll() { 
         // Code to fetch employee from database 
      } 
   }

Accéder à un modèle

Une fois qu'un modèle est défini, il peut être librement utilisé dans n'importe quel contrôleur simplement en l'incluant dans le contrôleur comme suit.

use \Model\Employee; 

class Controller_Employee extends Controller { 
   public function action_index() { 
      $employees = Employee::fetchAll(); 
   } 
}

Aperçu de la base de données

FuelPHP fournit sa propre couche d'abstraction de base de données pour récupérer les données de la base de données. Il fournit à la fois un outil basé sur ORM de base et avancé. La boîte à outils de base se compose de classes basées sur DB, DBUtil et Query_Builer. La boîte à outils avancée est Orm. La boîte à outils Orm est dérivée de la boîte à outils de base et intégrée dans un package séparé.

Configuration de la base de données

FuelPHP sépare les paramètres de la base de données du fichier de configuration principal et le fichier est fuel/app/config/db.php. Il prend en charge un paramètre distinct pour chaque environnement. Actuellement, FuelPHP prend en charge les pilotes MySQL, MySQLi et PDO. Le réglage de l'échantillon est le suivant -

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'    => 'localhost', 
            'port'        => '3306', 
            'database'    => 'tutorialspoint_fueldb', 
            'username'    => 'root', 
            'password'    => 'password', 
            'persistent'  => false, 
            'compress'    => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   )

Boîte à outils basée sur la base de données

le DB classest l'option la plus simple pour accéder à la base de données depuis l'application. Il fournit des options pour créer la requête de base de données, l'exécuter sur la base de données cible et enfin récupérer le résultat. La classe DB interagit avec les classes suivantes et fournit une API de base de données complète.

Database_Connection - Singleton et classe principale pour interagir avec la base de données
Database_Query - Base, classe concrète pour exécuter la requête SQL et récupérer le résultat
Database_Query_Builder - Classe abstraite de base pour créer une requête SQL
Database_Query_Builder_Join - Classe pour créer des jointures SQL
Database_Query_Builder_Where - Classe abstraite pour créer des conditions de requête SQL
Database_Query_Builder_Select - Classe concrète pour construire une requête de sélection SQL
Database_Query_Builder_Insert - Classe abstraite pour créer une requête d'insertion SQL
Database_Query_Builder_Update - Classe abstraite pour créer une requête de mise à jour SQL
Database_Query_Builder_Delete - Classe abstraite pour créer une requête de suppression SQL

Le diagramme suivant illustre la relation entre les classes et les méthodes fournies par les classes.

API DB

Apprenons les méthodes les plus importantes disponibles dans la classe DB dans cette section.

exemple

Purpose- Crée et renvoie la nouvelle instance Database_Connection .
Parameter -
- $db - Nom de connexion à la base de données défini dans le fichier de configuration, facultatif.
Returns- Renvoie l' objet Database_Connection

Par exemple,

$db = DB::instance(); $db = DB::instance('test');

requete

Purpose - Préparez l'instruction SQL fournie et renvoie l'objet Database_Query, qui peut être utilisé pour insérer, mettre à jour, supprimer ou récupérer les données de la base de données.
Parameter -
- $query - Instruction SQL, peut contenir des espaces réservés;
- $type - Type SQL, facultatif (DB :: SELECT, DB :: INSERT, DB :: UPDATE et DB :: DELETE)
Returns- Renvoie l' objet Database_Query

Par exemple,

$query = DB::query('SELECT * FROM 'employees'');

last_query

Purpose - Pour obtenir la dernière requête exécutée
Parameter - Aucun
Returns - Renvoie la dernière requête exécutée

Par exemple,

$employees = DB::Select('Select * from 'employee''); 
$sql = DB::last_query();

sélectionner

Purpose - Générer la partie sélectionnée de la requête
Parameter -
- $columns - Liste des noms de colonnes de la base de données
Returns - Renvoie l'objet Database_Query_Builder_Select

Par exemple,

$query = DB::select(); // Select * $query = DB::select('id', 'name'); // Select id, name

select_array (DB)

C'est similaire à select sauf que nous pouvons envoyer des colonnes sous forme de tableau.

$query = DB::select_array(array('id', 'name')); // Select id, name

insérer

Purpose - Générer la partie insert de la requête
Parameter -
- $table_name - nom de la table de base de données;
- $columns - tableau de colonnes de table
Returns - Renvoie l'objet Database_Query_Builder_Insert

Par exemple,

$query = DB::insert('employee');  // Insert into employee 
$query = DB::insert('employee', array('id', 'name')); // Insert into employee (id, name)

mettre à jour

Purpose - Générer la partie mise à jour de la requête
Parameter -
- $table_name - nom de la table de base de données
Returns - Renvoie l'objet Database_Query_Builder_Update

Par exemple,

$query = DB::update('employee'); // update `employee`

effacer

Purpose - Générer la partie suppression de la requête
Parameter -
- $table_name - nom de la table de base de données
Returns - Renvoie l'objet Database_Query_Builder_Delete

Par exemple

$query = DB::delete('employee');  // delete from 'employee'

API de requête

Database_Queryfournit une option pour définir la connexion à la base de données, exécuter la requête et récupérer le résultat sous forme de tableau ou d'objet associatif. Voyons les méthodes fournies par la classe Database_Query.

set_connection

Purpose - Pour définir la base de données (détails de connexion à la base de données) sur laquelle exécuter la requête
Parameter - $ db - nom de connexion à la base de données
Returns- Renvoie l' objet Database_Query

Par exemple,

$query = DB::query('DELETE * FROM employee', DB::DELETE); $query->set_connection('2nd-db');

param

Purpose - Pour définir la valeur du paramètre défini dans l'objet Query
Parameter -
- $param - nom du paramètre;
- $value - valeur du paramètre
Returns- Renvoie l' objet Database_Query

Par exemple,

// set some variables
$table = 'employee'; $id = 1;
$name = 'Jon'; // don't use $query = DB::query('SELECT * FROM '.$table.'. WHERE id = '.$id.' AND name = "'.$name.'"'); // but use $query = DB::query('SELECT * FROM :tablename WHERE id = :id AND name = :name');
$query->param('tablename', 'employee'); $query->param('id', $id); $query->param('name', $name);

Méthodes similaires

parameters est un objet similaire sauf qu'il offre l'option de donner plusieurs valeurs à la fois.

$query->parameters (array( 
   'tablename' => $table, 'id' => $id, 
   'name' => $name 
});

lier

Purpose - Pour définir une variable sur le paramètre défini dans l'objet Query
Parameter -
- $param - nom du paramètre
- $var - la variable à laquelle lier le paramètre
Returns- Renvoie l' objet Database_Query

Par exemple,

// bind a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); $query->bind('tablename', $table); // update the variable $table = 'employee_salary'; 

// DELETE * FROM `employee_salary`; 
$sql = $query->compile();

compiler

Purpose - Pour compiler l'objet de requête défini en requête SQL
Parameter -
- $db - chaîne de connexion, en option
Returns -

Par exemple,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); $query->param('tablename', $table); // compile the query, returns: DELETE * FROM employee $sql = $query->compile();

exécuter

Purpose - Pour exécuter la requête définie dans l'objet Query et renvoyer le résultat
Parameter -
- $db - nom de connexion à la base de données
Returns - Renvoie le résultat

Par exemple,

// assign a value to a query parameter 
$table = 'employee'; $query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);  

// execute the query 
$query->execute();

as_assoc

Purpose - Pour définir le type de retour comme tableau associatif au lieu d'objets
Parameter - Aucun
Returns - Renvoie l'objet courant

Par exemple,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_assoc()->execute(); 
foreach ($result as $row) { 
   echo $row['id']; 
}

as_object

Purpose - Pour définir le type de retour comme objet au lieu d'un tableau associatif
Parameter - Aucun
Returns - Renvoie l'objet courant

Par exemple,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_object()->execute(); 
foreach ($result as $row) { 
   echo $row->id; } // have ORM model objects return instead $result = $query->as_object('Model_Employee')->execute();

API Query Builder

Les classes basées sur Query Builder (Query_Builder) fournissent des options pour créer des requêtes SQL de manière dynamique. Il comporte quatre classes, chacune permettant de sélectionner (Query_Builder_Select) , d'insérer (Query_Builder_Insert) , de mettre à jour (Query_Builder_Update) et de supprimer (Query_Builder_Delete) les requêtes. Ces classes sont dérivées de la classe Query_Builder_Where (option pour générer des conditions), elle-même dérivée de Query_Builder , base de toutes les classes.

Regardons les méthodes fournies par la classe Query_Builder.

sélectionner

Purpose - Pour générer les colonnes de requêtes de sélection.
Parameter -
- $columns - liste des colonnes, facultative
Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name') // select `name` $query = DB::select(array('first_name', 'name')) // select `first_name` as `name`

de

Purpose - Pour générer les détails du tableau des requêtes sélectionnées
Parameter -
- $tables - liste des tableaux
Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee') // select `name` from `employee`

où

Purpose - Pour générer les conditions de sélection, d'insertion et de mise à jour des requêtes
Parameters -
- $column - nom de colonne ou tableau ($ colonne, $ alias);
- $op - opérateurs logiques, =,! =, IN, BETWEEN et LIKE, facultatifs;
- $value - valeur de la colonne
Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee')  
$query = $query->where('name', '=', 'Jon'); 
// select `name` from `employee` where `name` = `Jon`;

Méthodes similaires

Les méthodes similaires sont where_open (), and_where_open (), or_where_open (), where_close (), and_where_close (), ou_where_close (). Elles sont similaires aux méthodes where () sauf qu'elles ajoutent des mots clés et des crochets supplémentaires autour des conditions. Voici un exemple de code.

$query = DB::select('*')->from('employee'); $query->where('email', 'like', '%@gmail.com'); 
$query->or_where_open(); $query->where('name', 'Jon'); 
$query->and_where('surname', 'Peter'); $query->or_where_close();  
// SELECT * FROM `employee` WHERE `email` LIKE "%gmail.com" OR 
   (`name` = "Jon" AND `surname` = "Peter")

joindre

Purpose - Pour générer les jointures de table des requêtes sélectionnées
Parameters -
- $table - nom de table ou tableau ($ table, $ alias);
- $type - type de jointure (GAUCHE, DROITE, INTÉRIEUR, etc.,)
Returns - Renvoie l'instance actuelle

Exemple

$query = DB::select('name')->from('employee')->join('employee_salary') 
// select `name` from `employee` JOIN `employee_salary`

sur

Purpose - Pour générer la condition des jointures dans les requêtes sélectionnées
Parameters -
- $c1 - nom de table ou nom de table avec alias dans le tableau;
- $op - opérateur logique;
- $c2 - nom de table ou nom de table avec alias dans le tableau
Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee')->join('employee_salary') $query = $query->on('employee.employee_id', '=', 'employee_salary.employee_id') 
// select `name` from `employee` JOIN `employee_salary` on 
// `employee.employee_id` = `employee_salary.employee_id`

Méthodes similaires

Les méthodes associées sont and_on () et or_on (). Ils sont similaires à on (), sauf qu'ils ajoutent des mots clés et des crochets supplémentaires autour des jointures.

par groupe

Purpose - Pour générer des requêtes group by
Parameter - $columns - Nom de la colonne par laquelle regrouper le résultat
Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee') $query = $query->group_by('name'); 
// select `name` from `employee` group by `name`

ayant

Purpose - Pour générer le groupe par conditions de requêtes SQL
Parameter - $column - nom de colonne ou tableau ( $column, $alias); $op - opérateurs logiques, =,! =, IN, BETWEEN et LIKE, facultatifs; $value - valeur de la colonne
Returns - Renvoie l'instance actuelle

Exemple

$query = DB::select('name')->from('employee') $query = $query->group_by('name'); $query = $query->having('name', '!=', 'Jon');
// select `name` from `employee` group by `name` having `name` != `Jon`

Méthodes similaires

Les méthodes similaires sont had_open (), and_having_open (), or_having_open (), having_close (), and_having_close () ou_having_close (). Elles sont similaires aux méthodes have (), sauf qu'elles ajoutent des mots-clés et des crochets supplémentaires autour des conditions.

réinitialiser

Purpose - Pour réinitialiser la requête
Parameter - Aucun
Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee')  
$query->reset() $query = DB::select('name')->from('employee_salary') 
// select `name` from `employee_salary`

Classe DBUtil

La classe DBUtil fournit une option pour gérer et exécuter des opérations de base de données de routine. Certaines des méthodes importantes sont les suivantes -

set_connection - Définit la connexion par défaut

DBUtil::set_connection('new_database');

create_database - Crée une base de données.

DBUtil::create_database('my_database');

drop_database - Supprime une base de données.

DBUtil::drop_database('my_database');

table_exists - Vérifie si une table donnée existe.

if(DBUtil::table_exists('my_table')) { 
   // Table exists 
} else { 
   // Table does NOT exist, create it! 
}

drop_table - Supprime une table.

DBUtil::drop_table('my_table');

create_table - Crée une table.

\DBUtil::create_table ( 
   'users', 
   array ( 
      'id' => array('type' => 'int', 'auto_increment' => true), 
      'name' => array('type' => 'text'), 
   ), 
);

Boîte à outils Orm

FuelPHP fournit une couche de base de données avancée utilisant le concept ORM basé sur le populaire Active record pattern. La boîte à outils est incluse dans l'application mais n'est pas configurée par défaut. Il est fourni sous forme de package et le nom du package est orm. Nous pouvons ajouter la configuration suivante dans le fichier de configuration principal,fuel/app/config/config.php pour charger la boîte à outils orm.

'always_load' => array ( 
   'packages' => array (
      'orm', 
   ), 
),

Créer des modèles

Orm fournit la classe de modèle de base Orm \ Model. Nous devons étendre nos modèles avec le modèle orm pour utiliser les fonctionnalités ORM. Voici un exemple de code.

class Model_Employee extends Orm\Model {}

Configuration

Orm fournit un ensemble de paramètres pour configurer le modèle pour utiliser les fonctionnalités ORM. Ils sont les suivants -

connection- Définissez une propriété _connection statique dans le modèle pour spécifier le nom de la connexion.

class Model_Employee extends Orm\Model { 
   protected static $_connection = "production"; 
}

table name- Définissez une propriété statique _table_name dans le modèle pour spécifier le nom de table de la table backend.

class Model_Employee extends Orm\Model { 
   protected static $_table_name = 'employee'; 
}

primary key- Définissez une propriété statique _primary_key dans le modèle pour spécifier la clé primaire de la table principale.

class Model_Employee extends Orm\Model { 
   protected static $_primary_key = array('id'); 
}

Columns- Définissez une propriété _properties statique dans le modèle pour spécifier les colonnes de la table backend. Il prend en charge data_type, label, validation, elememts de formulaire, etc.

class Model_Employee extends Orm\Model { 
   protected static $_properties = array ( 
      'id',  
      'name' => array ( 
         'data_type' => 'varchar', 
         'label' => 'Employee Name', 
         'validation' => array ( 
            'required',  
            'min_length' => array(3),  
            'max_length' > array(80) 
         ), 
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  

      'age' => array ( 
         'data_type' => 'int', 
         'label' => 'Employee Age', 
         'validation' => array ( 
            'required',  
         ),  
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  
   ); 
}

Conditions- Définissez une propriété _conditions statique pour définir les conditions et classer par options.

class Model_Employee extends Orm\Model { 
   protected static $_conditions = array ( 
      'order_by' => array('id' => 'desc'), 
      'where' => array ( 
         array('is_active', > true), 
      ), 
   ); 
}

Observers- Orm fournit un système d'événements basé sur l'observateur pour ajouter un comportement à des événements spécifiques. Pour ajouter un comportement, définissez d'abord une propriété _observers dans le modèle. Ensuite, définissez le comportement en tant que classe et définissez-le dans la propriété _observers avec les événements. Si aucun événement n'est spécifié, le comportement sera appelé pour tous les événements. Nous pouvons également spécifier plusieurs comportements.

class Model_Employee { 
   protected static $_observers = array ( 
      'example',  // will call Observer_Example class for all events 
      'Orm\\Observer_CreatedOn' => array ( 
         'events' => array('before_insert'),  
         // will only call Orm\Observer_CreatedOn at before_insert event 
      ) 
   ); 
}

Créer

Une fois que nous avons configuré le modèle, nous pouvons commencer à utiliser les méthodes immédiatement. ORM fournit une sauvegarde méthode pour enregistrer l'objet dans la base de données. Nous pouvons définir les données en utilisant les propriétés configurées comme suit -

// option 1 
$new = new Model_Employee(); $new->name = 'Jon'; 
$new->save(); // option 2, use forge instead of new $new = Model_Employee::forge();
$new->name = 'Jon'; $new->save();  

// option 3, use array for properties 
$props = array('name' => 'Jon'); $new = Model_Employee::forge($props); $new>save();

Lis

Orm fournit une méthode, find pour récupérer les données de la base de données et se lier à l'objet. La méthode find fonctionne en fonction du paramètre d'entrée. Regardons les différentes options -

by primary key - La spécification de la clé primaire renvoie l'enregistrement en faisant correspondre la clé primaire de la table configurée.

$employee = Model_Employee::find(1);

first / last record- Spécifier «premier» ou «dernier» récupérera respectivement le premier ou le dernier enregistrement. Nous pouvons également passer la commande par option.

$entry = Model_Employee::find('first'); 
$entry = Model_Article::find('last', array('order_by' => 'id'));

All- Spécifier «tous» récupérera tous les enregistrements de la table configurée. Nous pouvons spécifier une commande par option ainsi que des conditions.

$entry = Model_Employee::find('all');  
$entry = Model_Article::find ('all', array ( 
   'where' => array ( 
      array ('name', 'Jon'), 
   ), 
   'order_by' => array ('id' => 'desc'), 
));

Nous pouvons utiliser l'API de requête de la boîte à outils de base de données de base avec le modèle pour l'option de recherche avancée comme suit.

$query = Model_Employee::query()->where('category_id', 1)->order_by('date', 'desc');
$number_of_employees = $query->count(); 
$latest_employee = $query->max('id'); 
$young_employee = $query->min('age'); 
$newest_employee = $query->get_one(); 
$employees = $query->limit(15)->get();

Mettre à jour

La mise à jour du modèle est identique à la création, sauf qu'au lieu de créer un nouveau modèle, récupérez simplement le modèle à mettre à jour à l'aide de la méthode find, mettez à jour la propriété, puis appelez la méthode save comme suit.

$entry = Model_Employee:find(4); $entry->name = 'Peter'; 
$entry->save();

Effacer

Orm fournit une méthode de suppression pour supprimer le modèle. Récupérez simplement l'objet et appelez la méthode de suppression.

$entry = Model_Employee:find(4); 
$entry->delete();

Exemple de travail

Créons un exemple de travail dans ce chapitre pour comprendre le modèle et la base de données.

Créer une base de données

Créez une nouvelle base de données sur le serveur MySQL à l'aide de la commande suivante.

create database tutorialspoint_fueldb

Ensuite, créez une table dans la base de données à l'aide de la commande suivante.

create table employee(id int primary key, name varchar(20), age int not null);

Configurer la base de données

Configurons la base de données à l'aide du fichier de configuration de la base de données, * fuel / app / config / db.php. Ajoutez les modifications suivantes pour connecter le serveur MySQL.

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),  
      
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

Inclure le package ORM

Mettre à jour le fichier de configuration principal, fuel/app/config/config.php pour inclure le package ORM en ajoutant la configuration suivante.

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

Désormais, ORM est activé dans votre application

Créer un modèle d'employé

Créer un nouveau modèle, Employé sous le dossier modèle “fuel/app/classes/model”. Il est défini comme suit.

Employee.php

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; protected static $_primary_key = array('id'); 
      protected static $_properties = array ( 
         'id',  
         'name' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Employee Name', 
            'form' => array (
               'type' => 'text' 
            ), 
         ),  
         
         'age' => array ( 
            'data_type' => 'int', 
            'label' => 'Employee Age', 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      ); 
   }

Créer une action

Créer une nouvelle action, action_model dans le contrôleur des employés situé à fuel/app/classes/controller/employee.php comme suit.

class Controller_Employee extends Controller { 
   public function action_model() { 
      
      // db based sql command to delete all employees 
      $query = db::query('delete from `employee`'); 
      $query->execute('production'); // orm based query to add new employees $model = new model_employee(); 
      $model->name = "john"; $model->age = 25; 
      $model->save(); $model = new model_employee(); 
      $model->name = "peter"; $model->age = 20; 
      $model->save(); // orm based query to fetch all employee data $data = array(); 
      $data['emps'] = model_employee::find('all'); return response::forge(view::forge('employee/model', $data)); 
   } 
}

Créer une vue

Maintenant, créez un fichier de vue model.php situé à “fuel/app/views/employee”. Ajoutez les modifications suivantes dans le fichier.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   
   <?php 
   } 
   ?> 
</ul>

Maintenant, demandez l'URL, http://localhost:8080/employee/model et cela produira le résultat suivant.

Résultat

FuelPHP propose trois classes, Form Fieldset,, et Input,, pour effectuer la programmation de formulaire.

Form class fournit une option pour créer tous les éléments de formulaires HTML.
Fieldset classe fournit une option pour créer un élément html via des méthodes de niveau supérieur, intégrant les modèles et la validation.
Input class fournit une option pour analyser les données soumises via des formulaires html ainsi que des paramètres http, des variables de serveur et des agents utilisateurs.

Dans ce chapitre, apprenons Form programming dans FuelPHP.

Forme

Comme indiqué précédemment, la classe Form fournit des méthodes pour créer des éléments de formulaire html et les méthodes importantes sont les suivantes:

ouvert()

open()est utilisé pour créer un nouveau formulaire. Il fournit les deux paramètres suivants -

$attributes - les attributs de la balise de formulaire sous forme de tableau ou simplement l'URL d'action sous forme de chaîne.
$hidden - tableau de nom de champ masqué et leurs valeurs.

echo Form::open('/employee/add'); 
echo Form::open(array('action' => '/employee/add', 'method' => 'post'));

Fermer()

close() ferme simplement le formulaire.

echo Form::close();

contribution()

input()crée un élément d'entrée html. Il a les trois paramètres suivants,

$field - nom de l'élément d'entrée
$value - valeur de l'élément d'entrée
$attributes - attributs de l'élément d'entrée en tant que tableau

echo Form::input('name', 'jon', array('style' => 'border: 20px;'));

élément d'étiquette

labelcrée un élément d'étiquette html. Il a les trois paramètres suivants,

$label - étiquette à montrer
$id - identifiant d'élément de formulaire associé
$attributes - attributs de l'élément label en tant que tableau

echo Form::label('Employee Name', 'employee_name');

caché

hidden est similaire à la méthode d'entrée, sauf qu'elle définit le type de l'élément d'entrée sur masqué.

mot de passe

password est similaire à la méthode d'entrée, sauf qu'elle définit le type de l'élément d'entrée sur mot de passe.

radio

radioest similaire à la méthode d'entrée, sauf qu'elle définit le type de l'élément d'entrée sur radio. Il a les quatre paramètres suivants,

$field - nom de l'élément d'entrée
$value - valeur de l'élément d'entrée
$checked - si l'élément est coché ou non (vrai / faux)
$attributes - attributs de l'élément d'entrée en tant que tableau

echo Form::label('Male', 'gender'); 
echo Form::radio('gender', 'Male', true); 
echo Form::label('Female', 'gender'); 
echo Form::radio('gender', 'Female');

case à cocher

checkboxest similaire à la méthode d'entrée, sauf qu'elle définit le type de l'élément d'entrée sur la case à cocher. Il a les quatre paramètres suivants,

$field - nom de l'élément d'entrée
$value - valeur de l'élément d'entrée
$checked - si l'élément est coché ou non (vrai / faux)
$attributes - attributs de l'élément d'entrée en tant que tableau

echo Form::label('Male', 'gender'); 
echo Form::checkbox('gender', 'Male', true);
echo Form::label('Female', 'gender'); 
echo Form::checkbox('gender', 'Female');

fichier

file est similaire à la méthode d'entrée, sauf qu'elle définit le type de l'élément d'entrée sur fichier.

textarea

textareacrée un élément textarea html. Il a les trois paramètres suivants,

$field - nom de l'élément textarea
$value - valeur de l'élément textarea
$attributes - attributs de l'élément textarea en tant que tableau

echo Form::textarea ('description', 'original data (value)', array ('rows' => 6, 
      'cols' => 8));

sélectionner

selectcrée un élément de sélection HTML. Il a les quatre paramètres suivants -

$field - nom de l'élément sélectionné
$values - valeurs de sélection initiales
$options- options comme tableau. Les options peuvent être regroupées à l'aide d'un tableau imbriqué
$attributes - attributs de l'élément d'entrée en tant que tableau

echo Form::select ( 
   'country',  
   'none',  
   array ( 
      'none'  => 'None', 
      'asia'  => array ( 
         'in' > 'India', 
         'cn' => 'China' 
      ), 
      
      'us' => 'United States' 
   ) 
);

soumettre

submit est similaire à la méthode d'entrée, sauf qu'elle définit le type de l'élément d'entrée à soumettre.

bouton

buttoncrée un élément de bouton html. Il a les trois paramètres suivants,

$field - nom de l'élément bouton
$value - valeur de l'élément bouton
$attributes - attributs de l'élément bouton en tant que tableau

echo Form::button('emp_submit', 'Submit');

réinitialiser

reset est similaire à la méthode d'entrée, sauf qu'elle définit le type de l'élément d'entrée à réinitialiser.

fieldset_open

fieldset_open crée un ensemble de champs html et des éléments de légende. Il a les deux paramètres suivants -

attributes - attributs de l'élément fieldset en tant que tableau
legend - nom de la légende à créer

// returns <fieldset class = "example-class" id = "example-id">
<legend>
   Custom Legend
</legend> 

echo Form::fieldset_open (array (
   'class'  => 'example-class', 
   'id'     => 'exampleid', 
   'legend' => 'Custom Legend'
));

fieldset_close

fieldset_close crée la balise de fermeture du jeu de champs HTML.

// returns </fieldset> 
echo Form::fieldset_close();

Classe d'entrée

La classe Input fournit des méthodes pour lire toutes les données de demande ainsi que les détails du formulaire. Certaines des méthodes importantes sont les suivantes -

uri

uri renvoie l'URI actuel de la requête

// request: http://localhost:8080/employee/welcome  
echo Input::uri(); // return /employee/welcome

méthode

method renvoie la méthode HTTP utilisée dans la requête

echo Input::method() // "POST"

avoir

getpermet de lire les variables $ _GET. Il a les deux paramètres suivants,

$index - index du tableau $ _GET
$default - valeur par défaut, si l'index n'est pas trouvé.

echo Input::get('age', '20'); // returns $_GET['age']

Publier

postpermet de lire les variables $ _POST. Il a les deux paramètres suivants,

$index - index du tableau $ _POST
$default - valeur par défaut, si l'index n'est pas trouvé

echo Input::get('age', '20'); // returns $_POST['age']

param

param permet de récupérer l'élément de $ _GET, $_POST, $Variables _PUT ou $ _DELETE. Il a les deux paramètres suivants,

$index - index du tableau
$default - valeur par défaut, si l'index n'est pas trouvé

Si aucun paramètre n'est spécifié, tous les éléments seront renvoyés.

echo Input::param('age', '20'); // returns $_POST['age']

fichier

filepermet de lire les variables $ _FILE. Il a les deux paramètres suivants,

$index - index du tableau $ _POST
$default - valeur par défaut, si l'index n'est pas trouvé

echo Input::file();

is_ajax

is_ajax renvoie true, si la demande est effectuée via AJAX.

echo Input::is_ajax() // return false

protocole

protocol renvoie le protocole HTTP utilisé dans la requête.

echo Input::protocol() // returns "HTTP"

ip

ip renvoie l'adresse IP via laquelle la demande est effectuée.

echo Input::ip() // returns "84.45.34.24" (Public IP Address)

real_ip

real_ip essaie de renvoyer la véritable adresse IP (si le client est derrière le proxy) via laquelle la demande est effectuée.

echo Input::real_ip() // returns "10.76.12.1" (local private IP Address)

serveur

serverpermet de lire les variables $ _SERVER. Il a les deux paramètres suivants,

$index - index du tableau $ _POST
$default - valeur par défaut, si l'index n'est pas trouvé.

echo Input::server('HTTP_HOST'); // returns localhost:8080

référent

referrerrenvoie le référent de la variable $ _SERVER. C'est une méthode de raccourci pour obtenir le référent http de la requête en cours.

agent utilisateur

user_agentrenvoie l'agent utilisateur à partir de la variable $ _SERVER. Il s'agit d'une méthode de raccourci pour obtenir l'agent utilisateur http de la requête actuelle.

chaîne de requête

query_stringrenvoie la chaîne de requête de la variable $ _SERVER. Il s'agit d'une méthode de raccourci pour obtenir la chaîne de requête de la requête actuelle.

en-têtes

headersrenvoie les en-têtes spécifiques ou tous. Il a les deux paramètres suivants -

$index - nom des en-têtes HTTP
$default - valeur par défaut, si l'index n'est pas trouvé.

echo Input::headers('Content-Type'); // returns "text/html"

extension

extension renvoie l'extension URI de la requête actuelle.

// Example URL: http://localhost/test/ 
echo Input::extension();  // NULL  

// Example URL: http://localhost/test.html 
echo Input::extension();  // 'html'

Exemple de travail

Créons un formulaire simple pour ajouter un nouvel employé à l'aide de la classe Form et Input.

Créer un formulaire

Créer une nouvelle action, get_add dans le contrôleur des employés comme suit.

public function get_add() { 
   return Response::forge(View::forge('employee/add')); 
}

Maintenant, ajoutez une vue pour l'action, fuel / app / views / employee / add.php comme suit.

<!DOCTYPE html> 
<html lang = "en"> 
   <head> 
      <title>Employee :: add page</title> 
      <meta charset = "utf-8"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1"> 
      <?php echo Asset::css('bootstrap.css'); ?> 
   </head>
   
   <body> 
      <div class = "container"> 
         <?php 
            echo Form::open(array('action' => 'employee/add', 'method' => 'post')); 
         ?>  
         
         <div class = "form-group"> 
            <?php 
               echo Form::label('Employee name:', 'name'); 
               echo Form::input('name', '', array('class' => 'form-control')); 
            ?> 
         </div> 
         
         <div class = "form-group"> 
            <?php 
               echo Form::label('Employee age:', 'age'); 
               echo Form::input('age', '', array('class' => 'form-control')); 
            ?> 
         </div> 
         
         <?php echo Form::button('frmbutton', 'Submit', array(
            'class' => 'btn btn-default')); 
         ?> 
         
         <?php 
            echo Form::close(); 
         ?> 
      </div> 
   </body> 
   
</html>

Ici, nous avons utilisé bootstrappour concevoir le formulaire. FuelPHP fournit une prise en charge complète des composants bootstrap. Maintenant, en demandant la page, http: // localhost: 8080 / employee / add affichera le formulaire suivant.

Formulaire de processus

Créez une nouvelle action, post_add pour traiter le formulaire et ajoutez les données d'employé saisies par l'utilisateur dans la base de données du contrôleur d'employés comme suit.

public function post_add() { 
   $name = Input::post('name'); 
   $age = Input::post('age'); $model = new model_employee(); 
   $model->name = $name; 
   $model->age = $age; 
   $model->save();  
   Response::redirect('employee/list'); 
}

Ici, nous avons été redirigés vers la page de la liste des employés, une fois que les données saisies par l'utilisateur sont enregistrées dans la base de données. Ensuite, nous allons créer la page de la liste des employés.

Liste des employés

Créez une nouvelle action, action_list pour répertorier l'employé dans la base de données comme suit.

public function action_list() { 
   $data = array(); 
   $data['emps'] = model_employee::find('all'); return Response::forge(view::forge('employee/list', $data)); 
}

Créer une nouvelle vue, fuel/app/views/employee/list pour l'action ci-dessus comme suit.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   <?php 
   } 
   ?> 
</ul>

Vérifiez le formulaire

Maintenant, demandez l'URL, http://localhost:8080/employee/add, entrez certaines données d'employés comme indiqué dans la capture d'écran suivante et soumettez le formulaire.

Ensuite, il montre tous les employés (y compris un nouvellement ajouté) disponibles dans la base de données comme suit -

Validationest l'une des tâches les plus fréquentes et les plus répétées d'une application Web. L'utilisateur entre les données requises dans le formulaire et les soumet. Ensuite, l'application Web doit valider les données avant de traiter les données. Par exemple, l'utilisateur entre les données des employés et la post_action doit être validée avant de l'enregistrer dans la base de données. FuelPHP fournit une classe vraiment simple, Validation à cet effet.

Dans FuelPHP, le concept de validation est très simple et propose diverses méthodes via la classe Validation pour valider correctement le formulaire. Voici le flux de travail de la validation,

Step 1 - Créer un nouvel objet de validation en utilisant forge méthode.

$val = Validation::forge();

Step 2 - Ajoutez les champs à valider à l'aide de la méthode add.

$val->add('name', 'Employee name');

Step 3 - Définissez les règles de validation des champs ajoutés en utilisant add_rule méthode.

$val->add('name', 'Employee name')->add_rule('required'); 
$val->add('age', 'Employee age')->add_rule('required') 
   ->add_rule('numeric_min', 20) 
   ->add_rule('numeric_max', 30);

Step 4 - Appelez la méthode run pour valider les données.

// run validation on just post 
if ($val->run()) { 
   // success 
} else { 
   // falier 
}

Step 5 - Utilisez validé et erreur pour obtenir respectivement les champs valides et invalides.

$vars = $val->validated(); 
$vars = $val->error();

Règles

FuelPHP contient un grand nombre de règles à valider, et fournit également une option pour créer de nouvelles règles. Les règles prises en charge par la classe Validation sont les suivantes,

required - Valeur à saisir
required_with- Définissez un autre champ comme champ compagnon. Si le champ est défini, les champs compagnons doivent également être définis
match_value - Définissez la valeur à mettre en correspondance avec la valeur du champ
match_pattern - Définissez la valeur à faire correspondre comme une expression régulière avec la valeur du champ
match_field - Définissez la valeur d'un autre champ comme valeur à faire correspondre avec la valeur du champ
match_collection - Définissez la valeur à associer comme collection avec la valeur du champ
min_length - Définissez la longueur minimale de la valeur du champ
max_length - Définissez la longueur maximale de la valeur du champ
exact_length - Définissez la longueur exacte de la valeur du champ
valid_date - Définissez la valeur du champ sur une date valide
valid_email - Définissez la valeur du champ sur un e-mail valide
valid_emails - Définissez la valeur du champ sur les e-mails valides, séparés par une virgule
valid_url - Définissez la valeur du champ sur une URL valide
valid_ip - Définissez la valeur du champ sur une adresse IP valide
numeric_min - Définissez la valeur minimale de la valeur du champ
numeric_max - Définissez la valeur maximale de la valeur du champ
numeric_between - Définissez la valeur minimale et maximale de la valeur du champ
valid_string - Similaire à regex mais plus simple

$val->add('username', 'User name')->add_rule('valid_string', array('alpha, dots');

Ici, alpha fait référence aux caractères alphabétiques et les points font référence à (.). La chaîne valide est uniquement la chaîne qui contient le caractère alphabétique et (.). Les autres options sont majuscules, minuscules, spéciaux, numériques, espaces, etc.

Exemple de travail

Nous pouvons mettre à jour la fonctionnalité d'ajout d'employé pour inclure la validation. Mettez simplement à jour lepost_add méthode du contrôleur des employés comme suit.

public function post_add() { 
   $val = Validation::forge(); 
   $val->add('name', 'Employee name')->add_rule('required'); $val->add('age', 'Employee age')->add_rule('required')
      ->add_rule('numeric_min', 20) 
      ->add_rule('numeric_max', 30);  
   
   if ($val->run()) { $name = Input::post('name'); 
      $age = Input::post('age'); $model = new model_employee(); 
      $model->name = $name; 
      $model->age = $age; 
      $model->save();  
      Response::redirect('employee/list'); 
   } else { 
      Response::redirect('employee/add'); 
   } 
}

Ici, nous avons spécifié le nameet l'âge comme champs obligatoires. leagedoit être compris entre 20 et 30. Si les deux règles sont valides, les données de l'employé seront enregistrées et redirigées vers la page de la liste des employés. Sinon, les données des employés seront rejetées et redirigées vers la page d'ajout d'employés.

FuelPHP fournit une programmation de formulaire avancée via les classes Fieldset et Fieldset_Field. Fieldsetfournit une manière orientée objet de créer un formulaire. Il a un support complet pour les modèles. Il prend également en charge la validation côté client et côté serveur. Pour créer un formulaire à part entière, il suffit de créer un modèle avec un formulaire et un paramètre de validation appropriés. Découvrons la classe Fieldset et comment créer un formulaire en l'utilisant dans ce chapitre.

Fieldset

Fieldset est une collection de Fieldset_Fieldobjets. Fieldset_Field définit l'entrée individuelle d'un formulaire tel que prénom, nom, etc. avec les validations. La classe Fieldset a des méthodes pour ajouter / modifier / supprimer des champs. Il a des options pour identifier les champs définis dans un modèle et créer les champs à partir du modèle donné.Fieldsetutilise les classes Form et Validation en arrière-plan pour faire le vrai travail. Voyons quelques-unes des méthodes importantes de la classe Fieldset.

la forge

forgecrée une nouvelle instance Fieldset. Il a les deux paramètres suivants -

$name - identifiant du fieldset
$config- tableau de configuration. Les options possibles sont validation_instance et form_instance. validation_instance peut avoir un objet Validation et form_instance peut avoir un objet Form.

$employee_form = Fieldset::forge('employee');

exemple

instance renvoie l'instance Fieldset créée précédemment par identificateur.

$employee_form = Fieldset::instance('employee');

get_name

Obtient l'identifiant de l'instance de fieldset.

$employee_form = Fieldset::forge('employee'); 
$name = $employee_form->get_name();

ajouter

addcrée une nouvelle instance Fieldset_Field et l'ajoute à l'ensemble de champs actuel. Il contient les quatre paramètres suivants,

$name - nom du champ
$label - étiquette pour le terrain
$attributes - Attributs de balise HTML
$rules - règles de validation

$employee_field = $employee_form-> add (
   'employee_lastname', 
   'Lastname', 
   array ('class' => 'pretty_input')
);  

// with validation rules 
$employee_form->add ( 
   'email', 'E-mail', 
   array('type' => 'email', 'class' => 'pretty_input'), 
   array('required', 'valid_email') 
);

ajouter avant

add_before est similaire à add, sauf qu'il a un paramètre supplémentaire pour spécifier le champ avant lequel le champ nouvellement créé sera ajouté.

$employee_form->add_before (
   'employee_firstname', 
   'Firstname', 
   array ('class' => 'pretty_input'), 
   array(), 
   'employee_lastname'
);

effacer

delete supprime le champ spécifié de l'ensemble de champs.

$employee_form->delete('employee_firstname');

champ

field obtient soit tous les champs, soit celui spécifié à partir du jeu de champs.

$fields = $employee_form->field(); $lastname_field = $employee_form->field('employee_lastname');

construire

buildest un alias pour $ this-> form () -> build () . Génère le balisage HTML du formulaire.

$employee_form->build(Uri::create('employee/add'));

activer

enable réactive un champ précédemment désactivé.

$employee_form->enable('employee_firstname');

désactiver

disable permet de désactiver la construction d'un champ dans le fieldset.

$employee_form->disable('employee_firstname');

forme

form renvoie l'instance Form du jeu de champs actuel.

$form = employee_form->form();

add_model

add_model ajoute le champ du modèle dans l'ensemble de champs. Il a les trois paramètres suivants,

$class - nom de la classe
$instance - instance de la classe pour remplir les champs avec valeur
$method- nom de la méthode dans la classe. Cette méthode est utilisée pour ajouter des champs dans l'ensemble de champs. Orm \ Model a la méthode requise. Le nom de la méthode par défaut est set_form_fields.

$employee_form = Fieldset::forge('employee'); 
$employee_form->add_model('Model_Employee');

peupler

populate définit la valeur initiale des champs dans fieldset à l'aide d'une instance de modèle.

$emp = new Model_Employee(); 
$emp->name = "Jon"; $employee_form->populate($emp);

repeupler

repopulate est identique à populate, sauf qu'il remplit de nouveau les champs du fieldset.

validation

validation obtient l'instance de validation du jeu de champs actuel.

$validation = $employee_form->validation();

validé

Alias pour $ this-> validation () -> validated ().

input

Alias pour $ this-> validation () -> input ().

error

Alias pour $ this-> validation () -> error ().

show_errors

Alias pour $ this-> validation () -> show_errors ().

Exemple de travail

Créons un formulaire avancé pour ajouter un nouvel employé dans notre exemple d'application d'employé à l'aide de la classe Fieldset.

Mettre à jour le modèle

Mettez à jour le modèle d'employé avec les règles de validation nécessaires et ajoutez un observateur de validation comme suit.

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; protected static $_primary_key = array('id'); 
      
      protected static $_properties = array ( 'id', 'name' => array ( 'data_type' => 'varchar', 'label' => 'Employee Name', 'validation' => array ( 'required', 'min_length' => array(3), 'max_length' => array(80) ), 'form' => array ( 'type' => 'text' ), ), 'age' => array ( 'data_type' => 'int', 'label' => 'Employee Age', 'validation' => array ( 'required', ), 'form' => array ('type' => 'text' ), ), ); // Just add the Observer, and define the required event protected static $_observers = array('Orm\\Observer_Validation' => array ( 
         'events' => array('before_save'))); 
   }

Ici, nous avons défini les règles de validation pour les champs de nom et d'âge et ajouté un nouvel observateur pour effectuer la validation côté serveur avant d'enregistrer le modèle dans la base de données. La même règle de validation créera également les attributs de validation d'entrée nécessaires dans le formulaire.

Créer un formulaire

Créez une nouvelle action, action_advancedform dans le contrôleur d'employé comme suit.

public function action_advancedform() { 
   
   // create a new fieldset and add employee model
   $fieldset = Fieldset::forge('employee')->add_model('Model_Employee'); // get form from fieldset $form = $fieldset->form(); // add submit button to the form $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit'));  
   
   // build the form  and set the current page as action  
   $formHtml = $fieldset->build(Uri::create('employee/advancedform'));  
   
   // set form in data 
   $data = array(); $data['form'] = $formHtml; return Response::forge(View::forge('employee/advancedform', $data, false)); 
}

Ici, nous avons créé le formulaire en utilisant fieldset et l'envoyons à la vue. Ensuite, ajoutez une vue pour l'action,fuel/app/views/employee/advancedform.php comme suit.

<!DOCTYPE html> 
<html lang = "en"> 
   
   <head> 
      <title>Employee :: add page</title> 
      <meta charset = "utf-8"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1"> 
      <?php echo Asset::css('bootstrap.css'); ?> 
      
      <style>  
         table { 
            width: 90%; 
         }  
         table tr { 
            width: 90% 
         }
         table tr td { 
            width: 50% 
         }  
         input[type = text], select { 
            width: 100%; 
            padding: 12px 20px; 
            margin: 8px 0; 
            display: inline-block; 
            border: 1px solid #ccc; 
            border-radius: 4px; 
            box-sizing: border-box; 
         }  
         input[type = submit] { 
            width: 100%; 
            background-color: #3c3c3c; 
            color: white; 
            padding: 14px 20px; 
            margin: 8px 0; 
            border: none; 
            border-radius: 4px; 
            cursor: pointer; 
         }  
         div { 
            border-radius: 5px; 
            background-color: #f2f2f2; 
            padding: 20px; 
         } 
      </style> 
   </head> 
   
   <body> 
      <div class = "container"> 
         <?php
            if(isset($errors)) { echo $errors; 
            } 
            echo $form; 
         ?> 
      </div> 
   </body> 
   
</html>

Maintenant, en demandant la page http://localhost:8080/employee/add affichera le formulaire suivant.

Formulaire de processus

Mettez à jour la méthode d'action, action_advancedform pour traiter le formulaire et ajoutez les données d'employé saisies par l'utilisateur dans la base de données du contrôleur d'employés comme suit.

public function action_advancedform() { 
   
   // create a new fieldset and add employee model 
   $fieldset = Fieldset::forge('employee')->add_model('Model_Employee');  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form 
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit')); // build the form and set the current page as action $formHtml = $fieldset->build(Uri::create('employee/advancedform')); if (Input::param() != array()) { try { $article = Model_Employee::forge(); 
         $article->name = Input::param('name'); $article->url = Input::param('age'); 
         $article->save(); Response::redirect('employee/list'); } catch (Orm\ValidationFailed $e) { 
         $view = View::forge('employee/advancedform'); $view->set('form', $formHtml, false); $view->set('errors', $e->getMessage(), false); } } return Response::forge($view); 
}

Ici, nous avons été redirigés vers la page de la liste des employés, une fois que les données saisies par l'utilisateur sont validées et enregistrées dans la base de données. Sinon, on nous montrera à nouveau le formulaire.

Créer le formulaire

Maintenant, demandez l'URL, http://localhost:8080/employee/addet entrez quelques données d'employés et soumettez le formulaire. Si les données ne sont pas fournies, le formulaire demandera à l'utilisateur de saisir les données comme indiqué dans la capture d'écran suivante.

Si l'utilisateur contourne la validation côté client, le serveur validera le formulaire et affichera une erreur comme indiqué dans la capture d'écran suivante.

Si les données ont réussi la validation côté client et serveur, les données de l'employé seront enregistrées dans la base de données et la page sera redirigée vers la page de liste.

Le téléchargement de fichiers est l'une des fonctionnalités les plus couramment utilisées dans la programmation de formulaires. FuelPHP fournit une classe spéciale,Uploadpour gérer le téléchargement des fichiers. Apprenons à télécharger un fichier à l'aide de la classe Upload dans ce chapitre.

Configuration

La classe de téléchargement peut être configurée à l'aide d'un fichier de configuration séparé, fuel/app/config/upload.php. Les entrées de configuration importantes sont les suivantes -

max_size- Définissez la taille maximale du fichier à télécharger. "0" fait référence à une taille de téléchargement illimitée
ext_whitelist - Définir les extensions de fichier autorisées
ext_blacklist - Définir les extensions de fichier non autorisées
type_whitelist- Définissez les types de fichiers autorisés. Par exemple, "texte" pour le type mime "texte / brut"
type_blacklist - Définir les types de fichiers non autorisés
mime_whitelist- Définissez les types de fichiers mime autorisés. Par exemple, "text / plain"
mime_blacklist - Définir les types de fichiers mime non autorisés
prefix - Chaîne de préfixe dans le nom de fichier lors de l'enregistrement du fichier téléchargé sur le serveur
suffix - Chaîne de suffixe dans le nom de fichier lors de l'enregistrement du fichier téléchargé sur le serveur
extension - Extension du fichier téléchargé à définir
create_path - S'il faut créer le chemin du fichier, s'il n'est pas disponible
overwrite - S'il faut écraser le fichier existant lors de l'enregistrement du fichier téléchargé
auto_rename - S'il faut renommer le fichier en ajoutant un numéro de séquence lors de l'enregistrement du fichier téléchargé
randomize - S'il faut créer un nom aléatoire de 32 caractères pour enregistrer le fichier téléchargé

Méthodes de téléchargement

La classe de téléchargement fournit des options pour traiter et enregistrer le fichier téléchargé par les utilisateurs. Chaque fichier traité (avant l'enregistrement) aura les informations suivantes dans le tableau de résultats.

field - Nom du champ de formulaire
name - Nom du fichier téléchargé
type - Type de fichier tel que défini par le navigateur
mimetype - Type de fichier tel que défini par la classe Upload
file - Nom complet de l'emplacement temporaire du fichier téléchargé
filename - Nom de fichier du fichier téléchargé
extension - Extension du fichier téléchargé
size - Taille du fichier téléchargé en octets
errors - Tableau d'erreur avec code d'erreur et message
error - Définir les erreurs de tableau avec la raison pour laquelle le téléchargement échoue (en cas d'échec du téléchargement)

Une fois les fichiers enregistrés sur le serveur, le tableau de résultats contient également les informations suivantes.

saved_to - Chemin d'accès complet où le fichier téléchargé a été enregistré
saved_as - Nom du fichier qui a été enregistré
errors - Tableau d'erreur mis à jour

Voyons maintenant la méthode de la classe Upload.

est valable

is_valid renvoie true, si un fichier valide est téléchargé par l'utilisateur.

// do we have any uploaded files to save? 
if (Upload::is_valid()) { 
   // process  
}

get_files

get_files renvoie tous les fichiers téléchargés sous forme de tableau multidimensionnel. Si un index / nom de l'entrée de fichier du formulaire est spécifié, il renverra le fichier téléchargé lié à l'entrée de fichier spécifiée uniquement.

foreach(Upload::get_files() as $file) { 
   // do something with the file info 
}  
if ( Upload::get_files(0)) { 
   // do something 
}

get_errors

get_errors renvoie un tableau d'erreurs, en cas d'échec du téléchargement d'un ou plusieurs fichiers. Si un index / nom du nom d'entrée de fichier du formulaire est spécifié, il renverra l'erreur liée à l'entrée de fichier spécifiée uniquement.

foreach(Upload::get_errors() as $file) { 
   // do something with the file info 
}  
if (Upload::get_errors('myimage')) { 
   // do something 
}

Processus

processus fait référence au processus réel de collecte d'informations sur le fichier téléchargé. Nous pouvons fournir une nouvelle configuration personnalisée à l'aide de array. Si aucune configuration n'est spécifiée, il utilisera la configuration définie dans fuel / app / config / upload.php

Upload::process (array( 
   'auto_rename' => false, 
   'overwrite'   => true 
));

enregistrer

save fait référence au processus réel d'enregistrement de tous les fichiers validés dans un emplacement approprié. Nous pouvons spécifier l'index pour enregistrer uniquement cette entrée particulière.

Upload::save();
Upload::save(0);
Upload::save(0, 3);

Exemple de travail

Créons un nouveau contrôleur, Controller_Upload dans notre exemple d'employé pour tester la fonctionnalité de téléchargement.

Step 1 - Créer un fichier, fuel/app/classes/controller/upload.php. Créez un contrôleur de téléchargement.

<?php 
   class Controller_Upload extends Controller { 
   }

Step 2 - Créez une nouvelle action get_upload.

<?php  
   class Controller_Upload extends Controller { 
      public function get_index() { 
         return \View::forge("upload/index"); 
      } 
   }

Step 3 - Créez une nouvelle vue pour l'action créée.

<!DOCTYPE html> 
<html> 
   <body> 
   
      <form action = "/upload/index" method = "post" enctype = "multipart/form-data"> 
         Select image to upload: 
         <input type = "file" name = "fileToUpload" id = "fileToUpload"> 
         <input type = "submit" value = "Upload Image" name = "submit"> 
      </form>  
      
   </body> 
</html>

Step 4 - Créez une nouvelle action post_action pour traiter le fichier téléchargé.

<?php  
   class Controller_Upload extends Controller { 
      public function get_index() { 
         return \View::forge("upload/index"); 
      }  
      public function post_index(){ 
         $config = array( 'path' => DOCROOT.'files', 'randomize' => true, 'ext_whitelist' => array('img', 'jpg', 'jpeg', 'gif', 'png'), ); Upload::process($config);  
         // if there are any valid files 
         
         if (Upload::is_valid()) { 
            Upload::save(); 
            echo "success"; 
         } else { 
            // and process any errors 
            foreach (Upload::get_errors() as $file) { echo var_dump($file); 
            } 
         } 
      } 
   }

Enfin, lancez l'application en demandant l'url, http://localhost:8080/upload/index et essayez de télécharger le fichier.

Résultat

AJAX est une technologie moderne de programmation Web. Il fournit des options pour envoyer et recevoir des données dans une page Web de manière asynchrone, sans actualiser la page. Découvrons la programmation de FuelPHP AJAX dans ce chapitre.

Le framework FuelPHP fournit des options pour identifier si le type de demande est AJAX ou non. La classe d'entrée a une méthode,is_ajax()dans ce but. Si une demande AJAX est faite,Input::is_ajax retour de la méthode true, autrement false.

Cette méthode est utilisée pour gérer correctement une requête AJAX côté serveur.

if (Input::is_ajax()) {  
   // Ajax request  
} else {  
   // Normal request  
}

On peut utiliser json_encodepour renvoyer la réponse JSON. Nous pouvons combiner ces deux méthodes pour créer une application Web basée sur AJAX simple et propre.

Exemple de travail

Ajoutons une nouvelle page, ajax/index dans l'application des employés et essayez de récupérer les informations de l'employé de manière asynchrone.

Step 1 - Créez un nouveau contrôleur, Controller_Ajax dans fuel / app / classes / controller / ajax.php.

<?php  
   class Controller_Ajax extends Controller { 
   }

Step 2- Créez une nouvelle action, action_index comme suit.

<?php  
   class Controller_Ajax extends Controller { 
      public function action_index() { 
         $emps = model_employee::find('all'); $data = array(); 
         $i = 0; foreach($emps as $emp) { $data[$i] = array(); $data[$i]['name'] = $emp['name']; 
            $data[$i]['age'] = $emp['age']; $i = $i + 1; } if(\Input::is_ajax()) { echo json_encode($data); 
         } else { 
            return \View::forge("ajax/index"); 
         } 
      } 
   }

Ici, si la demande est AJAX, nous récupérons les informations de l'étudiant, les encodons en JSON et les renvoyons. Sinon, nous rendons simplement la vue correspondante.

Step 3 - Créer le fichier de vue correspondant, fuel/app/views/ajax/index.php comme suit.

<html>
   <head>
      <script language = "javascript" src = "/assets/js/jquery-3.2.1.min.js"></script>
      
      <style>
         .table { border-collapse: collapse; }
         .table th, td {
            border-bottom: 1px solid #ddd;
            width: 250px;
            text-align: left;
            align: left;
         }
      </style>
   </head>
   
   <body>
      <a id = "loademployee" href = "#">Load employee information</a>
      </br> 
      </br>

      <table class = "table">
         <tbody id = "employee">
         </tbody>
      </table>
      
      <script language = "javascript">
         $(document).ready(function() { $("#loademployee").on("click", function(event) {
               $.ajax ({ url: '/ajax/index', type: 'POST', dataType: 'json', async: true, success: function(data, status) { var e = $('<tr><th>Name</th><th>Age</th></tr>');
                     $('#employee').html(''); $('#employee').append(e);
                     
                     for(i = 0; i < data.length; i++) {
                        employee = data[i];
                        var e = $('<tr><td id = "name"></td><td id = "age"></td></tr>'); $('#name', e).html(employee['name']);
                        $('#age', e).html(employee['age']); $('#employee').append(e);
                     }
                  },
                  
                  error : function(xhr, textStatus, errorThrown) {
                     alert('Ajax request failed.');
                  }
               });
            });  
         });
      </script>
   </body>
   
</html>

Ici, nous avons créé une balise d'ancrage (id: loademployee) pour charger les informations de l'employé à l'aide de l'appel AJAX. L'appel AJAX est effectué à l'aide de JQuery. L'événement associé à la balise loademployee s'active lorsqu'un utilisateur clique dessus. Ensuite, il récupérera les informations de l'employé à l'aide de l'appel AJAX et générera le code HTML requis de manière dynamique.

Step 4 - Lancez l'application.

Enfin, lancez l'application, http://localhost:8000/ajax/index et cliquez sur l'onglet d'ancrage Charger les informations sur les employés.

Résultat

FuelPHP fournit une excellente fonctionnalité pour demander une action dans la même application en utilisant Requestclasse. C'est ce qu'on appelle la demande HMVC. Il permet de réutiliser la logique du contrôleur.

Création d'une requête HMVC

La création d'une requête HMVC est aussi simple que de créer un objet de requête avec l'URL requise et d'appeler la méthode d'exécution comme suit.

$list = Request::forge('employee/list/')->execute(); echo $list;  

$employee = Request::forge('employee/show/1')->execute(array('id' => '1')); echo $employee;

Exemple de travail

Créons un nouveau contrôleur, Controller_HMVC pour tester la fonctionnalité HMVC. Créez un fichier,fuel/app/classes/controller/hmvc.php et placez le code suivant.

<?php 
   class Controller_HMVC extends Controller { 
      public function action_index() { 
         echo Request::forge('employee/list')->execute(); 
      } 
   }

Ici, nous venons d'appeler la page employé / liste via une requête HMVC et avons montré le résultat.

Résultat

Les thèmes sont utilisés pour activer plusieurs aspects et convivialité de l'application. Il offre à l'utilisateur / développeur la possibilité de modifier l'aspect et la convivialité de l'application sans perturber la fonctionnalité de l'application. Une application peut avoir un ou plusieurs thèmes. Chaque thème vit dans son propre dossier. Apprenons à créer des thèmes dans ce chapitre.

Configuration du thème

FuelPHP fournit un fichier de configuration séparé pour les thèmes, fuel/app/config/themes.php. Tous les paramètres liés au thème sont configurés dans ce fichier. Certains des principaux paramètres du thème sont les suivants:

active - Nom du thème actif
fallback - Nom du thème de secours, si le thème actif n'est pas trouvé
paths - Tableau du chemin pour rechercher et trouver des thèmes
assets_folder- Normalement, les ressources doivent être à l'intérieur de DOCPATH pour être accessibles via le Web. Il fait référence au dossier de ressources pour les thèmes à l'intérieur du DOCPATH
view_ext - Extension du fichier de vue du thème
info_file_name - Fichier contenant des informations étendues sur les thèmes
require_info_file - S'il faut exiger le fichier d'informations sur le thème, info_file_name
use_modules - Utiliser ou non le module actuel

La configuration simple du fichier de thème est la suivante.

<?php  
   return array ( 
      'active' => 'tpthemes', 
      'fallback' => 'tpthemes', 
      'paths' => array ( 
         APPPATH.'themes', 
      ), 
      'assets_folder' => 'assets', 
      'view_ext' => '.html', 
      'require_info_file' => false, 
      'info_file_name' => 'themeinfo.php', 
      'use_modules' => false, 
   );

Ici nous avons mis,

Le nom du thème actif et de secours en tant que thèmes
Le chemin du dossier de thème comme fuel / app / themes /
Le chemin du dossier d'actifs sous la forme / public / assets / tpthemes /

Cours à thème

Une fois la configuration terminée, nous pouvons utiliser la classe Thème fournie par FuelPHP pour faire les fonctionnalités du thème. Faites-nous part des méthodes disponibles dans la classe Theme de ce chapitre.

exemple

La méthode instance permet de créer un nouveau thème. Il a les deux paramètres suivants,

$name - Nom du thème (facultatif)
$config - Tableau de configuration de thème (identique à celui vu dans la section de configuration)

Les deux paramètres sont facultatifs. Si aucun paramètre n'est spécifié, il essaie d'obtenir le thème par défaut à partir du fichier de configuration. Si le nom du thème est spécifié, il essaie d'obtenir les autres paramètres du fichier de configuration. Si la configuration est également spécifiée, elle utilisera le paramètre spécifié par l'utilisateur au lieu du paramètre du fichier de configuration.

$theme = \Theme::instance(); $theme = \Theme::instance('tpthemes'); 
$theme = \Theme::instance ('mytheme', array ( 
   'active' => 'mytheme', 'view_ext' => '.php'));

la forge

forge est similaire à instance, sauf qu'il n'a qu'un tableau de configuration.

$theme = \Theme::forge (array( 
   'active'   => 'tpthemes', 
   'fallback' => 'tpthemes', 
   'view_ext' => '.php', 
));

vue

La méthode view utilise la View::forge()en arrière-plan. Les deux API sont similaires, sauf que la méthode de visualisation recherche le fichier de vue dans le dossier des thèmes, fuel / app / themes / tpthemes / au lieu de fuel / app / views / folder.

$theme = \Theme::instance(); $view = $theme->view('template/index'); 
// *fuel/app/themes/tpthemes/template/index.php

présentateur

La méthode du présentateur utilise le Presenter::forge()en arrière-plan. Les deux API sont similaires, sauf que la méthode du présentateur recherche le fichier de vue dans le dossier des thèmes, fuel / app / themes / tpthemes / au lieu de fuel / app / views / folder.

$theme = \Theme::instance(); 
$presenter = $theme->presenter('template/index');

asset_path

La méthode asset_path renvoie le chemin d'accès à l'actif demandé par rapport au thème actuellement sélectionné.

$theme = \Theme::instance(); // public/assets/tpthemes/css/style.css $style = \Html::css($theme->asset_path('css/style.css'));

add_path

La méthode add_path permet d'ajouter un chemin de thème à l'exécution.

$theme = \Theme::instance(); 
$theme->add_path(DOCROOT.'newthemes');

add_paths

La méthode add_paths permet d'ajouter plusieurs chemins de thème au moment de l'exécution.

$theme = \Theme::instance();   
$theme->add_path(DOCROOT.'newthemes');

actif

La méthode active permet de définir le thème actif.

$theme = \Theme::instance(); 
$active = $theme->active('newtheme');

se retirer

La méthode de secours permet de définir le thème de secours.

$theme = \Theme::instance(); $fallback = $theme->fallback('custom');

get_template

La méthode get_template retournera l'instance View du modèle de thème actuellement chargé.

$theme = \Theme::instance(); 
$theme->get_template()->set('body', 'Theme can change the look and feel of your app');

set_template

La méthode set_template permet de définir le modèle de thème de la page.

$theme = \Theme::instance(); 
$theme->set_template('layouts/index')->set('body', 'set theme template');

trouver

find renvoie true, si le chemin d'accès au thème est trouvé, sinon il retourne false.

$theme = \Theme::instance(); 
$path = $theme->find('newtheme')

tout

La méthode all renvoie un tableau de tous les thèmes dans tous les chemins de thème.

$theme = \Theme::instance(); $themes = $theme->all();

get_info

La méthode get_info renvoie une variable spécifique du tableau d'informations du thème. Si aucun thème n'est spécifié, le tableau d'informations du thème actif est utilisé.

$theme = \Theme::instance(); 
$var = $theme->get_info('color', 'green', 'newtheme');

Ici, la méthode get the color est définie dans 'newtheme'. S'il n'est pas défini, il utilisera «vert» comme couleur par défaut.

set_info

La méthode set_info définit une variable dans le thème actif ou de secours.

$theme->set_info('color', 'green', 'fallback');

set_partial

La méthode set_partial permet de définir une vue partielle pour une section nommée de votre modèle de page. Habituellement, cela se fait via un appel HMVC.

$theme = \Theme::instance(); 
$theme->set_template('layouts/homepage'); $theme->set_partial('navbar', 'homepage/navbar');

get_partial

La méthode get_partial permet d'obtenir l'instance de vue d'un partiel précédemment défini dans une section nommée de votre modèle de page.

$theme = \Theme::instance(); $theme->set_partial('sidebar', 'partials/menu'); 
$theme->get_partial('sidebar', 'partials/menu')->set('class', 'menu green');

Exemple de travail

Ajoutons le support de thème dans notre application employé.

Step 1 - Ajoutez un nouveau fichier de configuration de thème, fuel / app / config / theme.php avec le contenu suivant.

<?php  
   return array ( 
      'active' => 'tpthemes',
      'fallback' => 'tpthemes', 
      'paths' => array (APPPATH.'themes', ), 
      'assets_folder' => 'assets', 
      'view_ext' => '.html', 
      'require_info_file' => false, 
      'info_file_name' => 'themeinfo.php', 
      'use_modules' => false, 
   );

Step 2 - Ajouter un nouveau dossier d'actifs, public / assets / tpthemes / css pour le thème, tpthemes.

cd /go/to/app/root/path 
mkdir -p public/assets/tpthemes/css

Step 3 - Téléchargez le dernier bootstrap et placez le bootstrap.min.css sous public / assets / tpthemes / css

Step 4 - Ajouter un nouveau dossier, tpthemes sous le dossier fuel / app / themes.

cd /go/to/app/root/path   
mkdir -p fuel/app/themes/tpthemes

Step 5 - Ajoutez un nouveau modèle de mise en page, bootstrap.html sous fuel / app / themes / tpthemes / layout / et ajoutez le code suivant.

<!DOCTYPE html> 
<html lang = "en"> 
   <head> 
      <title>Theme example</title> 
      <meta charset = "utf-8"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1"> 
      <!-- Bootstrap core CSS --> 
      <?php echo \Theme::instance()->asset->css('bootstrap.min.css'); ?> 
   </head> 
   
   <body> 
      <?php echo $header; ?> 
      <div class = "container"> 
         <div class = "row">
            <div class = "col-sm-12"> 
               <?php echo $content; ?> 
            </div> 
         </div> 
      </div> 
   </body>
   
</html>

Ici, nous avons utilisé l'instance de thème et la méthode d'actif pour obtenir le chemin du fichier d'amorçage. Nous avons défini deux variables, l'en-tête et le contenu.header est défini pour définir dynamiquement les détails de l'en-tête. content est défini pour définir le contenu réel de la page de manière dynamique.

Step 6 - Ajoutez un nouveau modèle d'en-tête, header.php à fuel / app / themes / tpthemes / partials comme suit.

<div class = "jumbotron text-center">
   <h1>Theme support in fuelphp</h1> 
   <p>bootstrap based template</p>  
</div>

Step 7 - Créer un nouveau contrôleur, ThemeSample à fuel / app / classes / controller / themesample.php et action à action_index comme suit.

<?php  
   class Controller_ThemeSample extends \Controller { 
      public function before() { 
         $this->theme = \Theme::instance(); 
         $this->theme->set_template('layouts/bootstrap'); $header = $this->theme->view('partials/header'); $this->theme->get_template()->set('header', $header); } public function action_index() { $content = $this->theme ->view('themesample/index') ->set('message', 'This data comes from action page'); $this->theme 
         ->get_template() 
         ->set('content', $content); } public function after($response) { 
         if (empty($response) or ! $response instanceof Response) { 
            $response = \Response::forge(\Theme::instance()->render()); } return parent::after($response); 
      } 
   }

Ici, nous avons utilisé before et after méthode pour faire l'initialisation du thème à l'aide des méthodes de Themeclasse. Certaines des méthodes utilisées sont instance, get_template, set_template et view.

Step 8 - Enfin, ajoutez une vue pour l'action d'index, index.php dans fuel / app / themes / tpthemes / themesample comme suit.

<p>The data comes from *fuel/app/themes/tpthemes/themesample/index.html* file.</p> 
<p> 
   <?php echo $message; ?> 
</p>

Ici, nous avons défini une variable, message, qui doit être définie dynamiquement dans le contrôleur.

Nous avons créé un nouveau thème, tpthemes et l'a utilisé dans ThemeSamplemanette. Vérifions maintenant le résultat en demandant l'URL, http: // localhost: 8080 / themesample / index. Le résultat est le suivant.

Le module est un excellent moyen d'écrire des fonctionnalités Web réutilisables telles que blog, album, chat, etc. Le module ne perturbe pas l'autre code de l'application Web. Il vit dans son propre dossier et fournit silencieusement ses fonctionnalités. Les modules sont simplement les mêmes contrôleurs, modèles et vues, sauf qu'ils sont regroupés, configurés et placés dans un dossier spécial. Habituellement, un module réside généralement dans le sous-répertoire de l'application nommé modules situé dans fuel / app / modules.

Configuration du module

Nous pouvons définir le chemin des modules dans le fichier de configuration de l'application principale, fuel / app / config / config.php comme suit.

'module_paths' => array ( 
   path/to.’modules'.DS,              // path to application modules 
   path/to.’..’.DS.'globalmods'.DS    // path to our global modules 
),

Espace de nom du module

Dans FuelPHP, chaque module a son propre espace de noms PHP. La définition d'un espace de noms séparé résout les conflits de noms. Par exemple, un module d'employé peut être défini sous l'espace de noms, EmployeeModule comme suit.

<?php  
   namespace Employeemodule;  

   class Controller_Employee { 
      //code here 
   }

Le nom du module doit être identique au nom de dossier du module.

Structure du module

Nous pouvons créer un module en créant un nom de dossier défini dans la configuration. Le nom du dossier détermine le nom du module et le nom de l'espace de noms pour les classes du module.

La structure du module est la suivante -

classes
- controller
- model
- view
config
lang
tasks
views

Le module peut avoir ses propres fichiers de configuration. Il est très utile dans la configuration du routage et ne perturbe pas la configuration d'origine de l'application. Un autre concept important est que la classe de module peut être réutilisée en chargeant le module dans la section de configuration always_load comme suit.

'always_load => array ( 
   'modules' => array('employeemodule'), 
),

De plus, les modules peuvent être chargés et utilisés instantanément sans être configurés comme suit.

Module::load('employeemodule');  
\Employeemodule\Myclass::mymethod('params');

Les packages sont similaires aux modules dans la réutilisation du code mais diffèrent des manières suivantes,

Il ne correspond pas aux URL Web
Il n'est pas accessible via les demandes HMVC

En bref, les packages ne sont pas des fonctionnalités Web directes telles que blog, album, etc. Il s'agit plutôt d'une bibliothèque de fonctions regroupées telles que le traitement des e-mails, la création de documents, la création de graphiques, l'authentification, etc. application.

Créer des packages

Pour créer un package, nous devons d'abord organiser notre code source spécifié comme suit.

/fuel 
   /packages 
      /package (root directory of package) 
         /bootstrap.php 
      /classes 
         /our.php 
      /classes.php 
         /here.php 
      /config 
         /config.php 
         /and_so_on

La structure du package a deux fichiers spécifiques au package, les fichiers config.php et bootstrap.php. Le but du fichier de configuration est de regrouper la configuration du package sous le dossier du package lui-même sans perturber l'application principale. Le but du fichier d'amorçage est de définir l'espace de noms afin que l'autoloader le charge correctement.

Voici quelques façons de définir l'espace de noms:

Autoloader::add_namespace('Mypackage', __DIR__.'/classes/'); 
Autoloader::add_core_namespace('Mypackage'); 
Autoloader::add_core_namespace('Mypackage', true); 
Autoloader::add_classes (array( 
   'Mypackage\\Classname' => __DIR__.'/classes/classname.php', 
   'Mypackage\\Anotherclass' => __DIR__.'/classes/anotherclass.php', 
));

Une fois que le fichier bootstrap est correctement configuré et que les packages sont chargés dans l'application, nous pouvons l'utiliser comme suit.

$instance = new Myclass; 
$instance = new Mynamespace\Myclass;

Installer des packages

Les packages sont généralement placés dans le répertoire fuel / packages. Par défaut, les packages suivants sont installés,

auth - Package d'authentification
email - Forfait e-mail
oil - Commande de carburant, paquet d'huile
orm - Forfait ORM
parser - Package d'analyse syntaxique Markdown

Pour installer un nouveau package, voici les deux options,

Option 1 - Installation manuelle - télécharger et installer

Pour installer manuellement le package, téléchargez d'abord le package à partir du site Web de l'auteur. Déballez-le et placez-le sousfuel/packages/ dossier.

Option 2 - Méthode automatique utilisant la commande d'huile

FuelPHP fournit un moyen automatisé d'installer les paquets hébergés dans github. Utilisez la commande suivante pour installer le package, mytestpackage.

php oil package install mytestpackage

Il clone le code source du package à l'aide du client git et le déplace dans le dossier fuel / packages. Si le client git n'est pas disponible, nous pouvons utiliser l'argument de commande –direct pour demander à la commande de télécharger et d'installer les packages comme suit.

php oil package install mytestpackage --direct

Utilisation des packages

Les packages peuvent être utilisés dans l'application une fois qu'il est chargé dans l'application. Il existe deux façons de charger les packages dans l'application.

Option 1 - Grâce à la classe Package

FuelPHP fournit une classe, Package pour charger, décharger et vérifier la disponibilité des packages via respectivement les méthodes de chargement, de déchargement et de chargement. loadLa méthode a deux paramètres. Le premier paramètre,$package est le nom du package et le deuxième paramètre, pathest le chemin du package. Le deuxième paramètre est facultatif, si le package est installé dansfuel/packages dossier.

// load the orm package 
Package::load('orm');  

// load the parser package from a specific directory 
Package::load('parser', '/path/to/packages/dir/');  

// load the non-existent package 
Package::load('awesome'); // Throws a PackageNotFoundException

Option 2 - Via le fichier de configuration

Pour charger un package de manière permanente, ajoutez simplement le package sous always_load entrée de configuration dans le fichier de configuration principal, fuel/app/config/config.php. Pour charger le package de courrier électronique, utilisez la syntaxe suivante.

'always_load' => array ( 
   'packages' => array ( 
      'email', 
   ), 
),

Une fois les packages chargés dans l'application, nous pouvons l'utiliser comme suit.

$instance = new Myclass; $instance = new Mynamespace\Myclass;

Cookiefournit un stockage de données côté client et ne prend en charge qu'une petite quantité de données. Habituellement, c'est 2 Ko par domaine et cela dépend du navigateur.Sessionfournit un stockage de données côté serveur et prend en charge une grande quantité de données. Voyons comment créer un cookie et une session dans l'application Web FuelPHP.

Biscuits

FuelPHP fournit un Cookieclasse pour créer un élément de cookie. La classe de cookie est utilisée pour créer, attribuer et supprimer des cookies.

Configurer le cookie

La classe Cookie peut être configurée globalement via le fichier de configuration de l'application principale, situé dans fuel / app / config / config.php. Il est défini comme suit.

'cookie' => array (  
   
   //Number of seconds before the cookie expires 
   'expiration'  => 0,  
   
   //Restrict the path that the cookie is available to 
   'path'        => '/',  
   
   //Restrict the domain that the cookie is available to 
   'domain'      => null,  
   
   // Only transmit cookies over secure connections 
   'secure'      => false,  
   
   // Only transmit cookies over HTTP, disabling Javascript access 
   'http_only'   => false, 
),

Méthodes

La classe Cookie fournit des méthodes pour créer, accéder et supprimer un élément de cookie. Ils sont les suivants -

ensemble()

La méthode set est utilisée pour créer une variable Cookie. Il contient les arguments suivants,

$name - La clé dans le tableau $ _COOKIE.
$value - La valeur du cookie.
$expiration - Nombre de secondes pendant lesquelles le cookie doit durer.
$path - Le chemin sur le serveur sur lequel le cookie sera disponible.
$domain - Le domaine sur lequel le cookie est disponible.
$secure - Définissez sur true si vous souhaitez uniquement transmettre des cookies via des connexions sécurisées.
$httponly - Autoriser uniquement la transmission de cookies via HTTP, désactivant l'accès JavaScript.

Cookie::set('theme', 'green');

avoir()

La méthode get est utilisée pour lire une variable Cookie. Il contient les arguments suivants,

$name - La clé dans le tableau $ _COOKIE.
$value - La valeur à renvoyer si la clé n'est pas disponible dans le tableau $ _COOKIE.

Cookie::get('theme');

effacer()

La méthode de suppression est utilisée pour supprimer une variable de cookie. Il contient les arguments suivants,

$name - La clé dans le tableau $ _COOKIE.
$value - La valeur du cookie.
$domain - Le domaine sur lequel le cookie est disponible.
$secure - Définissez sur true si vous souhaitez uniquement transmettre des cookies via des connexions sécurisées.
$httponly - Autoriser uniquement la transmission de cookies via HTTP, désactivant l'accès JavaScript.

Cookie::delete('theme');

Session

FuelPHP fournit la classe, Session pour maintenir l'état de l'application.

Configurer la session

La classe de session peut être configurée via le fichier de configuration spécial, fuel/core/config/session.php. Certaines des entrées de configuration importantes sont les suivantes -

auto_initialize - Initialisez la session automatiquement.
driver- Nom du pilote de session. La session est implémentée à l'aide du pilote et les options possibles sont cookie, db, memcached, redis et file. Le pilote par défaut est cookie.
match_ip - Vérifiez l'adresse IP du client.
match_ua - Vérifiez l'agent utilisateur client.
expiration_time - Valeur du délai d'expiration de la session en secondes.
rotation_time - Il est temps de renouveler la session.

Méthodes de session

La classe Session fournit des méthodes pour manipuler les données de session. Ils sont comme suit,

exemple()

le instance La méthode renvoie une instance par défaut ou une instance spécifique, identifiée par son nom.

$session = Session::instance(); // default instance $session = Session::instance('myseesion'); // specific instance

ensemble()

le set est utilisée pour affecter une variable de session.

Session::set('userid', $userid);

avoir()

le get La méthode vous permet de récupérer les variables stockées de la session.

$userid = Session::get('userid');

effacer()

le delete La méthode vous permet de supprimer une variable de session stockée.

Session::delete('userid');

créer()

le createLa méthode vous permet de créer une nouvelle session. Si une session est déjà présente, elle sera détruite et une nouvelle session sera créée.

Session::create();

détruire()

le destroy est utilisée pour détruire une session existante.

Session::destroy();

lis()

le read La méthode vous permet de lire une session.

Session::read();

écrire()

le write La méthode vous permet d'écrire la session.

Session::write();

clé()

le keyLa méthode vous permet de récupérer des éléments de la clé de session. La valeur de la clé est unique.

$session_id = Session::key('session_id');

Un eventest une action ou une occurrence reconnue par le programme qui peut être gérée par le programme lui-même. Par exemple, nous pouvons définir une action ou un événement nommé my_fuel_event, puis faire un peu de travail chaque fois que l'événement, my_fuel_event est appelé. FuelPHP fournit la classe,Event pour travailler avec les événements de l'application.

Événements système

FuelPHP a défini certains des événements à travers lesquels nous pouvons effectuer un travail chaque fois que les événements définis sont appelés ou déclenchés par l'application. Cette aide modifie le comportement du FuelPHP sans modifier les fichiers de code de base du FuelPHP. Les événements prédéfinis sont les suivants -

app_created - Cet événement sera déclenché après l'initialisation du framework FuelPHP.
request_created - Cet événement sera déclenché après la création d'un nouvel objet Request.
request_started - Cet événement sera déclenché lorsque l'exécution d'une requête est demandée.
controller_started - Cet événement sera déclenché avant l'appel de la méthode des contrôleurs avant ().
controller_finished - Cet événement sera déclenché après l'appel des contrôleurs après l'appel de la méthode () et la réception de la réponse.
response_created - Cet événement sera déclenché après la création d'un nouvel objet Réponse.
request_finished - Cet événement sera déclenché lorsque l'exécution d'une demande est terminée et qu'une réponse est reçue.
shutdown - Cet événement sera déclenché après que la requête principale a été traitée et que la sortie a été envoyée.

Nous pouvons gérer les événements dans le fichier de configuration spécial, fuel/app/config/events.php comme suit -

<?php  
   return array ( 
      'fuelphp' => array ( 
         'app_created' => function() { 
            // After FuelPHP initialised
         }, 
         'request_created' => function() { 
            // After Request forged 
         }, 
         'request_started' => function() { 
            // Request is requested 
         }, 
         'controller_started' => function() { 
            // Before controllers before() method called 
         }, 
         'controller_finished' => function() { 
            // After controllers after() method called 
         }, 
         'response_created' => function() { 
            // After Response forged 
         }, 
         'request_finished' => function() { 
            // Request is complete and Response received 
         }, 
         'shutdown' => function() { 
            // Output has been send out 
         }, 
      ), 
   );

Méthodes d'événement

La classe Event fournit des méthodes pour enregistrer, désenregistrer et déclencher des événements. Ils sont comme suit,

S'inscrire()

La méthode register permet aux fichiers d'enregistrer un objet qui sera exécuté lorsque la méthode de déclenchement est appelée.

$my_event_code = function() { 
   echo 'my event'; 
} 
Event::register('my_event', $my_event_code);

désinscrire ()

La méthode unregister permet aux fichiers de désinscrire un objet qui serait exécuté lorsque la méthode de déclenchement est appelée.

Event::unregister('my_event', $my_event_code);

déclencheur()

La méthode de déclenchement est utilisée pour déclencher ou activer les rappels associés via la méthode register.

Event::trigger('my_event');

has_events ()

La méthode has_events est disponible afin que vous puissiez vérifier si un événement enregistré particulier a des déclencheurs.

Event::has_events('my_event');

la forge()

La forge renvoie un nouvel objet événement.

$event = Event::forge();

exemple()

L'instance renvoie un nouveau singleton d'objet événement.

$event = Event::instance('event_instance');

La fonctionnalité de messagerie électronique est la fonctionnalité la plus demandée dans un cadre Web. FuelPHP fournit une classe de courrier électronique élégante regroupée sous forme de package. Il est utilisé pour envoyer des e-mails simples en texte brut ainsi que des e-mails avancés en texte enrichi avec plusieurs pièces jointes. Il prend en charge les fonctionnalités suivantes: e-mails en texte brut, e-mails HTML, pièces jointes et pièces jointes en ligne.

Configuration

Pour activer la fonctionnalité de messagerie dans l'application, nous devons simplement charger le package de messagerie comme spécifié ci-dessous dans le fichier de configuration principal, fuel / app / config / config.php.

'always_load' => array ( 
   'packages' => array ( 
      'email', 
   ), 
),

Une autre option consiste à charger le package de courrier électronique, le contrôleur lui-même comme suit.

\Package::load('email');

Le paramétrage de l'e-mail peut être effectué dans le fichier de configuration principal et certaines des options importantes sont les suivantes,

driver - Pilote de messagerie tel que smtp
is_html - Envoyer ou non des e-mails sous forme de contenu HTML
priority - Priorité de l'email
smtp.host - Hôte du serveur SMTP
smtp.port - Port du serveur SMTP
smtp.username - Nom d'utilisateur du serveur SMTP
smtp.password - Mot de passe du serveur SMTP
smtp.timeout - Délai d'expiration SMTP
smtp.starttls - Si le serveur SMTP a besoin de la commande STARTTLS

API de messagerie

Voici l'API fournie par la classe de pilote de courrier électronique et de courrier électronique.

la forge

Objectif: créer une instance de pilote de messagerie. Il crée le pilote en fonction de la configuration ou de l'entrée qu'il reçoit. Le pilote de messagerie fournit des fonctionnalités pour créer et envoyer des e-mails. Certains des pilotes de messagerie possibles sontsmtp, sendmail, mailgun, et mandrill.

Parameter - Aucun ou tableau de détails de configuration
Returns - Renvoie l'objet Email_Driver

Par exemple,

$email = \Email::forge(); $email = \Email::forge (array( 
   'driver' => 'smtp', 
));

corps

Purpose - Pour définir le corps du message
Parameter - $ body - corps du message
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); 
$email->body('Body message'); //or pass it a View $email->body(\View::forge('my/view', $data);

alt_body

Purpose - Pour définir le corps du message alternatif
Parameter - $ alt_body - corps de message alternatif
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); $email->alt_body('Body message');  

//or pass it a View 
$email->alt_body(\View::forge('my/view', $data);

priorité

Purpose - Pour définir la priorité du courrier
Parameter -
- $priority- valeur de la priorité. Les options sont -

a. \Email::P_LOWEST 
* \Email::P_LOW 
* \Email::P_NORMAL 
* \Email::P_HIGH 
* \Email::P_HIGHEST

Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); 
$email->priority(\Email::P_HIGHEST);

html_body

Purpose - Pour définir le corps du message au format HTML
Parameter -
- $html - corps du message en HTML;
- generate_alt - s'il faut générer un message alternatif;
- auto_attach - s'il faut incorporer l'image ou non
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); // Do generate the alt body, but don't auto attach images. $email->html_body(\View::forge('welcome/email', $data), true, false);

de

Purpose - Pour définir l'adresse de départ
Parameters -
- $from - depuis l'adresse e-mail;
- $name - Nom de l'expéditeur
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); 
$email->from('[email protected]', 'My Name');

matière

Purpose - Pour définir l'objet du message
Parameter - $ subject - objet du message électronique
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); $email->subject('Suject of the mail message');

à

Purpose - Pour définir l'adresse e-mail du destinataire
Parameters -
- $email - adresse e-mail ou tableau d'adresses e-mail;
- $name - nom du destinataire
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); $email->to('[email protected]', 'My Dear Name'); 
$email->to (array( 
   '[email protected]', 
   '[email protected]' => 'My Dear friend', 
));

entête

Purpose - Pour définir un en-tête personnalisé pour le message électronique
Parameters -
- $header - type d'en-tête ou tableau d'en-tête;
- $value - valeur de l'en-tête
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge(); 
$email->header('X-SMTPAP', 'XXXXXXXX'); $email>reply_to (array( 
   'X-SMTPAP'  => 'XXXXXX', 
   'X-SMTPAP2' > 'XXXXXA',
));

attacher

Purpose - Pour joindre un fichier au message électronique
Parameters-
- $file - chemin du fichier;
- $inline - s'il faut joindre le fichier en ligne ou non;
- $cid - identifiant de contenu;
- $mime - Type MIME du fichier joint;
- $name - remplacement du nom du fichier de pièce jointe
Returns - Renvoie l'instance actuelle

Par exemple,

$email = \Email::forge();
$email>attach(DOCROOT.'attachments/sample_attachment.pdf');

envoyer

Purpose - Pour envoyer le mail.
Parameter -
- $validate - s'il faut valider les adresses e-mail
Returns - vrai ou faux

Par exemple,

$email = \Email::forge(); try{ $email->send(); 

} catch(\EmailSendingFailedException $e) { // The driver could not send the mail. } catch(\EmailValidationFailedException $e) { 
   // One or more email addresses failed validation. 
}

Exemple d'e-mail de travail

Utilisons l'API apprise dans le chapitre précédent et créons un code simple pour envoyer un message. Voici le code le plus simple pour envoyer un message.

$email = Email::forge(); $email->from('[email protected]', 'person1'); 
$email->to('[email protected]', 'person2'); $email->subject('Add something'); 
$email->body('contents of mail'); $email->send();

Profilerest l'un des outils importants pour analyser et améliorer les performances de l'application. FuelPHP fournit un excellent profileur pour profiler l'application. Apprenons-en plus sur le profil de FuelPHP dans ce chapitre.

Activer le profilage

Le profilage est désactivé par défaut. Pour activer le profilage, définissez le profilage d'attribut sur true dans le fichier de configuration principal, fuel / app / config / config.php comme suit.

'profiling'  => true,

Désormais, le profilage est activé dans l'application. Une fois le profilage activé, toutes les pages demandées afficheront un onglet supplémentaire en bas de la page avec les informations de profilage, comme indiqué dans la capture d'écran suivante.

Informations sur le profileur

Le Profiler a une interface à onglets et se compose des données suivantes,

Console - Fournit des informations sur les erreurs, les entrées de journal, l'utilisation de la mémoire ou les délais d'exécution.
Load time - Affiche le temps de chargement de la demande.
Database - Le nombre de requêtes exécutées et le temps d'exécution.
Memory - Mémoire totale utilisée pour la requête.
Files - Affiche tous les fichiers PHP.
Config - Contenu de la configuration à la fin de la requête.
Session - Contenu de la session à la fin de la demande.
GET - Le contenu du tableau $ _GET.
POST - Le contenu du tableau $ _POST.

Classe de profileur

La classe profiler est utilisée pour ajouter vos informations de profilage. Il implémente une version personnalisée de PHPQuickProfiler (PQP). Profiler contient une collection de variables javaScript pour contrôler l'état initial du Profiler.

Profiler la classe prend en charge les éléments suivants methods -

marque()

mark ajoutera un marqueur de vitesse au profileur. Il montre le temps de chargement.

Profiler::mark('my custom code');

mark_memory ()

La méthode * mark_memory * ajoute un marqueur de mémoire au profileur. Si aucune entrée n'est spécifiée, l'utilisation de la mémoire à ce moment-là est enregistrée. Si nous spécifions la variable et une étiquette pour la variable comme indiqué ci-dessous, cela montrera l'utilisation de la mémoire de la variable et l'étiquera en utilisant l'étiquette spécifiée.

mark_memory($this, 'My Employee Controller memory usage');

console()

La méthode de console ajoutera simplement une entrée de journal au profileur.

Profiler::console('log entry');

FuelPHP fournit un excellent support pour gérer les erreurs et déboguer l'application. Expliquons la gestion des erreurs et le débogage dans ce chapitre.

La gestion des erreurs

La gestion des erreurs FuelPHP est basée sur des exceptions. FuelPHP fournit une exception PhpErrorException pour toutes les anciennes erreurs php. FuelPHP lève PhpErrorException chaque fois qu'une erreur dans le code PHP est rencontrée. FuelPHP facilite également l'affichage de pages d'erreur personnalisées pour divers codes d'état HTTP.

Erreur de fichier introuvable

FuelPHP fournit une nouvelle classe d'exception, HttpNotFoundException pour gérer les demandes inconnues. Parfois, nous pouvons rencontrer la demande qui peut ne pas être traitée. À ce moment-là, nous pouvons simplement lancer l'exception HttpNotFoundException.

Par défaut, une page par défaut est configurée pour HttpNotFoundException dans le fichier de configuration des routes, fuel / app / config / routes.php en utilisant l'entrée 400. Chaque fois que HttpNotFoundException est déclenché, la demande sera redirigée vers 400 pages.

'_404_'   => 'welcome/404',    // The main 404 route

Erreurs internes

FuelPHP fournit une nouvelle classe d'exception, HttpServerErrorException pour gérer toutes les erreurs de serveur. Parfois, il se peut que nous ne puissions pas traiter la demande donnée en raison d'erreurs internes. À ce moment-là, nous pouvons simplement lancer l'exception HttpServerErrorException.

Par défaut, une page par défaut est configurée pour HttpServerErrorException dans le fichier de configuration des routes, fuel / app / config / routes.php en utilisant l'entrée 500. Chaque fois que HttpServerErrorException est déclenché, la demande sera redirigée vers 500 pages.

'_500_'   => 'welcome/500',    // The main 500 route

Cette page enregistrera l'erreur, affichera l'erreur formatée dans la page et enverra occasionnellement une notification à l'administrateur système.

Erreurs de violation d'accès

FuelPHP fournit une nouvelle classe d'exception, HttpNoAccessException pour gérer les violations d'accès. Parfois, il se peut que nous ne puissions pas traiter la demande en raison d'une restriction d'accès. À ce moment-là, nous pouvons simplement lancer l'exception HttpNoAccessException.

Par défaut, une page par défaut est configurée pour HttpNoAccessException dans le fichier de configuration des routes, fuel / app / config / routes.php à l'aide de l'entrée 403. Chaque fois que HttpNoAccessException est déclenchée, la demande sera redirigée vers la page 403.

'_403_'   => 'welcome/403',     // The main 403 route

Cette page affichera les informations de violation d'accès.

Débogage

Le débogage est l'une des activités les plus fréquentes du développement d'une application. FuelPHP fournit une classe simple,Debugpour gérer l'activité de débogage de l'application. Apprenons la classe Debug et ses méthodes dans ce chapitre.

Classe de débogage

La classe de débogage fournit des méthodes utilitaires pour afficher les informations détaillées des variables, objets, tableau, etc. La classe de débogage fournit les méthodes suivantes,

déverser

La méthode de vidage renvoie plusieurs valeurs mixtes au navigateur de manière structurée et formatée.

Debug::dump($var1, $var2);

trace arrière ()

backtrace affiche les informations détaillées sur l'exécution actuelle du code. Il affiche les informations du fichier PHP, la ligne actuelle et toutes ses actions précédentes.

Debug::backtrace();

Des classes()

Renvoie une liste de toutes les classes.

Debug::classes();

interfaces ()

Renvoie une liste de toutes les classes d'interface.

Debug::interfaces();

comprend ()

Renvoie une liste de tous les fichiers inclus actuellement chargés au moment de l'exécution.

Debug::includes();

les fonctions()

Renvoie une liste de toutes les fonctions.

Debug::functions();

constantes ()

Renvoie une liste de toutes les constantes.

Debug::constants();

extensions ()

Renvoie une liste de toutes les extensions.

Debug::extensions();

en-têtes ()

Renvoie une liste de tous les en-têtes HTTP.

Debug::headers();

phpini ()

Imprime une liste des paramètres de configuration lus à partir du fichier php.ini.

Debug::phpini();

Les tests unitaires sont un processus essentiel dans le développement de grands projets. Unit testsaider à automatiser les tests des composants de l'application à chaque étape du développement. Il alerte lorsque le composant de l'application ne fonctionne pas selon la spécification métier du projet. Les tests unitaires peuvent être effectués manuellement mais sont souvent automatisés.

PHPUnit

Le framework FuelPHP s'intègre au framework de test PHPUnit. Pour écrire un test unitaire pour le framework FuelPHP, nous devons configurer PHPUnit. Si PHPUnit n'est pas installé, téléchargez-le et installez-le. Nous pouvons confirmer la disponibilité de PHPUnit dans notre système à l'aide de la commande suivante.

phpunit --version

Si PHPUnit est disponible, vous verrez le résultat similaire au suivant.

PHPUnit 5.1.3 by Sebastian Bergmann and contributors.

Création de tests unitaires

L'emplacement standard fourni par FuelPHP pour écrire un test unitaire est fuel / app / tests. Nous pouvons écrire le test unitaire pour le contrôleur, le modèle, la vue et les présentateurs dans des dossiers séparés. Écrivons un test unitaire pour valider l'objet Model_Employee.

Step 1 - Créez un dossier, modèle sous le dossier fuel / app / tests.
Step 2 - Créez un fichier, employee.php sous fuel / app / tests / model / folder.
Step 3 - Créez une nouvelle classe de test, Test_Model_Employee en étendant la classe TestCase fournie par PHPUnit.
Step 4 - Ecrire une méthode, testInstanceOfEmployee () pour associer la création d'objet employé à l'aide de la méthode assertInstanceOf () fournie par la classe TestCase de PHPUnit.

Voici le code complet -

<?php  
   class Test_Model_Employee extends TestCase { 
      public function testInstanceOfEmployee() { 
         $this->assertInstanceOf(Model_Employee::class, new Model_Employee()); 
      } 
   }

Créer un groupe de test

FuelPHP fournit une option pour créer un groupe de cas de test. Créer un groupe est aussi simple que d'ajouter l'attribut docblock, @group. Incluons notre cas de test dans le groupe MyTest.

<?php   
   /** 
      * @group MyTest 
   */ 
   class Test_Model_Employee extends TestCase { 
      public function testInstanceOfEmployee() { 
         $this->assertInstanceOf(Model_Employee::class, new Model_Employee()); 
      } 
   }

Exécuter le test

Pour exécuter tous les tests du répertoire, utilisez la commande suivante.

$ php oil test

Pour exécuter un groupe spécifique de tests, utilisez la commande suivante.

$ php oil test --group = MyTest

Après avoir exécuté la commande, vous recevrez la réponse suivante.

Tests Running...This may take a few moments.
PHPUnit 5.1.3 by Sebastian Bergmann and contributors.
                                        1 / 1 (100%).
Time: 123 ms, Memory: 8.00Mb
OK (1 test, 1 assertion)

Dans ce chapitre, nous allons apprendre à créer une application BookStore complète basée sur MVC dans FuelPHP.

étape 1: créer un projet

Créez un nouveau projet nommé «BookStore» dans FuelPHP à l'aide de la commande suivante.

oil create bookstore

étape 2: créer une mise en page

Créez une nouvelle mise en page pour notre application. Créez un fichier, layout.php à l'emplacement fuel / app / views / layout.php. Le code est comme suit,

fuel / app / views / layout.php

<!DOCTYPE html> 
<html lang = "en"> 
   <head> 
      <meta charset = "utf-8"> 
      <meta http-equiv = "X-UA-Compatible" content = "IE = edge"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1">  
      <title><?php echo $title; ?></title>  
      
      <!-- Bootstrap core CSS --> 
      <link href = "/assets/css/bootstrap.min.css" rel = "stylesheet">  
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
      </script> 
      <script src = "/assets/js/bootstrap.min.js"></script> 
   </head>  
   
   <body> 
      <nav class = "navbar navbar-inverse navbar-fixed-top"> 
         <div class = "container"> 
            <div class = "navbar-header">
               
               <button type = "button" class = "navbar-toggle collapsed" 
                  datatoggle = "collapse" data-target = "#navbar" 
                  aria-expanded = "false" ariacontrols = "navbar"> 
                  <span class=  "sr-only">Toggle navigation</span> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
               </button> 
               <a class = "navbar-brand" href = "#">FuelPHP Sample</a> 
            </div> 
            
            <div id = "navbar" class = "collapse navbar-collapse"> 
               <ul class = "nav navbar-nav"> 
                  <li class = "active"><a href = "/book/index">Home</a></li> 
                  <li><a href = "/book/add">Add book</a></li> 
               </ul> 
            </div><!--/.nav-collapse --> 
         </div> 
      </nav>  
      
      <div class = "container"> 
         <div class = "starter-template" style = "padding: 50px 0 0 0;"> 
            <?php echo $content; ?> 
         </div> 
      
      </div><!-- /.container --> 
   </body>
   
</html>

Ici, nous utilisons un modèle bootstrap. FuelPHP a un support de première classe pour les modèles de bootstrap. Nous avons créé deux variables, le titre et le contenu. title est utilisé pour spécifier le titre de la page actuelle et le contenu est utilisé pour spécifier les détails de la page actuelle.

étape 3: créer un contrôleur

Créez un nouveau contrôleur, Controller_Book pour afficher, ajouter, modifier et supprimer le livre. Créez un nouveau fichier, fuel / app / classes / controller / book.php et placez le code suivant.

fuel / app / classes / controller / book.php

<?php  
   class Controller_Book extends Controller_Template {
      public $template = 'layout'; 
      public function action_index() { 
         
         // Create the view object 
         $view = View::forge('book/index'); // set the template variables $this->template->title = "Book index page"; 
         $this->template->content = $view; 
      } 
   }

Ici, nous avons créé le contrôleur de livre en héritant du contrôleur de modèle et en définissant le modèle par défaut sur fuel / app / views / layout.php.

étape 4: créer la vue d'index

Créez un dossier, réservez dans le répertoire views sous le dossier fuel / app / views. Ensuite, créez un fichier index.php dans le dossier du livre et ajoutez le code suivant,

fuel / app / views / index.php

<h3>index page</h3>

À partir de maintenant, nous avons créé un contrôleur de livre de base.

étape 5: modifier l'itinéraire par défaut

Mettez à jour l'itinéraire par défaut pour définir la page d'accueil de l'application pour réserver le contrôleur. Ouvrez le fichier de configuration de routage par défaut, fuel / app / config / routes.php et modifiez-le comme suit.

fuel / app / config / routes.php

<?php 
   return array ( 
      '_root_'  => 'book/index',  // The default route 
      '_404_'   => 'welcome/404', // The main 404 route 

      'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'), 
   );

Maintenant, en demandant l'URL, http: // localhost: 8080 / retournera la page d'index du contrôleur de livre comme suit,

étape 6: créer une base de données

Créez une nouvelle base de données sur le serveur MySQL, en utilisant la commande suivante,

create database tutorialspoint_bookdb

Ensuite, créez une table dans la base de données à l'aide de la commande suivante,

CREATE TABLE book ( 
   id INT PRIMARY KEY AUTO_INCREMENT, 
   title VARCHAR(80) NOT NULL, 
   author VARCHAR(80) NOT NULL, 
   price DECIMAL(10, 2) NOT NULL 
);

Insérez un exemple d'enregistrement dans la table à l'aide de l'instruction SQL suivante.

INSERT 
INTO 
   book(title, 
   author, 
   price) 
VALUES( 
   'The C Programming Language', 
   'Dennie Ritchie', 
   25.00 
),( 
   'The C++ Programming Language', 
   'Bjarne Stroustrup', 
   80.00
),( 
   'C Primer Plus (5th Edition)', 
   'Stephen Prata', 
   45.00 
),('Modern PHP', 'Josh Lockhart', 10.00),( 
   'Learning PHP, MySQL & JavaScript, 4th Edition', 
   'Robin Nixon', 
   30.00 
)

étape 7: configurer la base de données

Configurez la base de données à l'aide du fichier de configuration de base de données, db.php situé dans fuel / app / config.

fuel / app / config / db.php

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_bookdb', 
            'username'       => 'root', 
            'password'       => 'password', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_bookdb', 
            'username'       => 'root', 
            'password'       => 'password', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

étape 8: inclure le package Orm

Mettez à jour le fichier de configuration principal pour inclure le package ORM. Il se trouve dans «fuel / app / config /».

fuel / app / config / config.php

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

étape 9: créer un modèle

Créez un modèle de livre dans book.php situé dans «fuel / app / classes / model». Il est défini comme suit -

fuel / app / classes / model / book.php

<?php  
   class Model_Book extends Orm\Model { 
      protected static $_connection = 'production'; protected static $_table_name = 'book'; 
      protected static $_primary_key = array('id'); protected static $_properties = array ( 
         'id',  
         'title' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Book title', 
            'validation' => array ( 
               'required',  
               'min_length' => array(3),  
               'max_length' => array(80) 
            ), 
            
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
         'author' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Book author', 
            'validation' => array ( 
               'required', 
            ), 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
         'price' => array ( 
            'data_type' => 'decimal', 
            'label' => 'Book price', 
            'validation' => array ( 
               'required', 
            ), 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      );  
      protected static $_observers = array('Orm\\Observer_Validation' => array ( 
         'events' => array('before_save') 
      )); 
   }

Ici, nous avons spécifié les détails de la base de données comme propriétés du modèle. Il a également des détails de validation.

étape 10: afficher des livres

Mettez à jour l'action d'index dans le contrôleur de livre pour répertorier les livres disponibles dans la base de données.

fuel / app / classes / controller / book.php

<?php  
   class Controller_Book extends Controller_Template { 
      public $template = 'layout'; 
      public function action_index() { 
         
         // Create the view object 
         $view = View::forge('book/index'); // fetch the book from database and set it to the view $books = Model_Book::find('all'); 
         $view->set('books', $books);  
         
         // set the template variables
         $this->template->title = "Book index page"; $this->template->content = $view; 
      } 
   }

Ici, nous avons utilisé le orm pour récupérer les détails du livre dans la base de données, puis les transmettre aux vues.

étape 11: mettre à jour la vue d'index

Mettez à jour le fichier de vue index.php situé dans «fuel / app / views / book». Le code complet mis à jour est le suivant,

carburant / app / vues / livre / index.php

<table class = "table"> 
   <thead> 
      <tr> 
         <th>#</th> 
         <th>Title</th> 
         <th>Author</th> 
         <th>Price</th> 
         <th></th> 
      </tr> 
   </thead> 
   
   <tbody> 
      <?php 
         foreach($books as $book) { ?> <tr> <td><?php echo $book['id']; ?></td> 
         <td><?php echo $book['title']; ?></td> <td><?php echo $book['author']; ?></td> 
         <td><?php echo $book['price']; ?></td> <td> <a href = "/book/edit/<?php echo $book['id']; ?>">Edit</a> 
            <a href = "/book/delete/<?php echo $book['id']; ?>">Delete</a> 
         </td>
      </tr> 
      
      <?php 
      } 
      ?> 
   </tbody> 
</table> 
<ul>
</ul>

Maintenant, en demandant l'URL, http: // localhost: 8080 / affichera la page comme suit -

étape 12: Créer une action pour ajouter un livre

Créez la fonctionnalité pour ajouter un nouveau livre dans la librairie. Créez une nouvelle action, action_add dans le contrôleur de livre comme suit,

public function action_add() { 
   
   // create a new fieldset and add book model 
   $fieldset = Fieldset::forge('book')->add_model('Model_Book');  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form 
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit')); // build the form and set the current page as action $formHtml = $fieldset->build(Uri::create('book/add')); $view = View::forge('book/add'); 
   $view->set('form', $formHtml, false);  
   
   if (Input::param() != array()) { 
      try { 
         $book = Model_Book::forge(); $book->title = Input::param('title'); 
         $book->author = Input::param('author'); $book->price = Input::param('price'); 
         $book->save(); Response::redirect('book'); } catch (Orm\ValidationFailed $e) { 
         $view->set('errors', $e->getMessage(), false); 
      } 
   }  
   $this->template->title = "Book add page"; $this->template->content = $view; }

Ici, les deux processus suivants sont en cours d'exécution,

Création du formulaire de livre pour ajouter un livre à l'aide des méthodes Fieldset et du modèle de livre.
Traitement du formulaire du livre, lorsque l'utilisateur entre les informations du livre et renvoie le formulaire. Il peut être trouvé en vérifiant la méthode Input :: param () pour toutes les données soumises. Le traitement du formulaire implique les étapes suivantes -
- Rassemblez les informations du livre.
- Validez les informations du livre. Nous avons déjà défini la validation à appeler avant la méthode de sauvegarde. Si la validation échoue, elle lèvera l' exception Orm \ ValidationFailed.
- Stockez les informations du livre dans la base de données.
- Redirigez l'utilisateur vers la page d'index en cas de succès. Sinon, affichez à nouveau le formulaire.

Nous faisons les deux, montrant le formulaire ainsi que le traitement du formulaire dans la même action. Lorsque l'utilisateur appelle l'action pour la première fois, il affiche le formulaire. Lorsque l'utilisateur entre les informations du livre et soumet les données, il traite le formulaire.

étape 13: créer la vue pour l'action d'ajout de livre

Créez la vue pour l'action d'ajout de livre. Créez un nouveau fichier, fuel / app / views / book / add.php et entrez le code suivant,

<style>  
   #form table { 
      width: 90%; 
   }  
   #form table tr { 
      width: 90% 
   }  
   #form table tr td { 
      width: 50% 
   }  
   #form input[type = text], select { 
      width: 100%; 
      padding: 12px 20px; 
      margin: 8px 0; 
      display: inline-block; 
      border: 1px solid #ccc; 
      border-radius: 4px; 
      box-sizing: border-box; 
   }  
   #form input[type = submit] { 
      width: 100%;
      background-color: #3c3c3c; 
      color: white; 
      padding: 14px 20px; 
      margin: 8px 0; 
      border: none; 
      border-radius: 4px; 
      cursor: pointer; 
   }  
   #form div { 
      border-radius: 5px; 
      background-color: #f2f2f2; 
      padding: 20px; 
   }  
</style>  

<div id = "form">  
   <h2>Book form</h2> 
   
   <?php   
      if(isset($errors)) { 
         echo $errors; } echo $form;  
   ?> 
</div>

Ici, nous montrons simplement le formulaire créé dans la méthode d'action. De plus, nous montrons les erreurs, le cas échéant.

étape 14: vérification de l'action d'ajout de livre

Demander l'url, http: // localhost: 8080 / book / add ou cliquer sur le lien de navigation Ajouter un livre, affichera le formulaire comme suit,

Forme

Formulaire avec données

Après avoir saisi les informations du livre et soumis la page, les informations du livre seront stockées dans la base de données et la page sera redirigée vers la page d'index comme suit.

Liste de livres avec livre nouvellement ajouté

étape 15: Création d'une action pour modifier le livre

Créez la fonctionnalité pour modifier et mettre à jour les informations du livre existant. Créez une nouvelle action, action_edit dans le contrôleur de livre comme suit.

public function action_edit($id = false) { if(!($book = Model_Book::find($id))) { throw new HttpNotFoundException(); } // create a new fieldset and add book model $fieldset = Fieldset::forge('book')->add_model('Model_Book'); 
   $fieldset->populate($book);  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit')); // build the form and set the current page as action $formHtml = $fieldset->build(Uri::create('book/edit/' . $id));  
   $view = View::forge('book/add'); $view->set('form', $formHtml, false); if (Input::param() != array()) { try { $book->title = Input::param('title'); 
         $book->author = Input::param('author'); $book->price = Input::param('price'); 
         $book->save(); Response::redirect('book'); } catch (Orm\ValidationFailed $e) { 
         $view->set('errors', $e->getMessage(), false); 
      } 
   }  
   $this->template->title = "Book edit page"; $this->template->content = $view; 
}

Il est similaire à ajouter une action, sauf qu'il recherche le livre demandé par identifiant avant de traiter la page. Si des informations sur le livre sont trouvées dans la base de données, elle continuera et affichera les informations du livre dans le formulaire. Sinon, il lancera une exception de fichier introuvable et quittera.

étape 16: créer la vue pour l'action d'édition

Créez la vue pour l'action de modification du livre. Ici, nous utilisons la même vue que celle utilisée pour l'action d'ajout.

Étape 17: vérification de l'action d'édition du livre.

Cliquez sur le lien d'édition de n'importe quel livre dans la page de liste des livres, il affichera le formulaire de livre correspondant comme suit -

Formulaire avec détails du livre

étape 18: Créer une action pour supprimer le livre

Créez la fonctionnalité pour supprimer le livre de la librairie. Créez une nouvelle action, action_delete dans le contrôleur de livre comme suit,

public function action_delete($id = null) { 
   if ( ! ($book = Model_Book::find($id))) { 
      throw new HttpNotFoundException(); 

   } else { 
      $book->delete(); 
   } 
   Response::redirect('book'); 
}

Ici, nous vérifions l'existence du livre dans la base de données en utilisant l'ID de livre fourni. Si le livre est trouvé, il est supprimé et redirigé vers la page d'index. Sinon, une page non trouvée d'informations sera affichée.

étape 19: vérification de l'action de suppression

Vérifiez l'action de suppression en cliquant sur le lien de suppression dans la page de liste des livres. Il supprimera le livre demandé et sera à nouveau redirigé vers la page d'index.

Enfin, toutes les fonctionnalités pour ajouter, modifier, supprimer et répertorier les informations du livre sont créées.

FuelPHP est simple, flexible, évolutif et facilement configurable par rapport aux autres frameworks PHP basés sur MVC. Il fournit toutes les fonctionnalités du framework MVC moderne. Il peut être utilisé tel quel ou peut être complètement modifié pour répondre à nos besoins. Surtout, c'est un excellent choix pour le développement Web.