Tutoriel de présentation du framework CodeIgniter

Le but du tutoriel est de vous présenter CodeIgniter, un framework simple et léger capable de vous permettre de réaliser un minisite tel qu'un site e-commerce rapidement, en vous fournissant le cadre de développement favorable à une progression rapide alliée à une structuration idéale de votre projet.

Commentez Donner une note à l'article (5)

Article lu   fois.

L'auteur

Site personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

CodeIgniter est un environnement-cadre de développement d'application, un ensemble d'outils permettant de structurer et de construire des sites Web en utilisant PHP.
Son objectif est de vous permettre de développer des projets beaucoup plus rapidement que si vous partiez de zéro, en fournissant un ensemble fourni de bibliothèques pour les tâches habituellement nécessaires, ainsi qu'une interface simple et une structuration logique d'accès à ces bibliothèques. CodeIgniter vous permet de vous concentrer sur votre créativité en minimisant la quantité de code nécessaire pour réaliser une tâche donnée.

I-A. Architecture logicielle MVC

L'architecture de CodeIgniter est basée sur le patron de conception MVC.
Il s'agit d'un patron de conception permettant de séparer le code d'accès aux données, la présentation et le contrôle de l'ensemble des actions.
L'article suivant est une très bonne introduction à ce patron de conception.
http://julien-pauli.developpez.com/tutoriels/php/mvc-controleur/

I-B. Utilisation de CodeIgniter

L'utilisation principale reste la mise en place d'un environnement structurant et simplifiant pour vos réalisations techniques.
D'après la documentation officielle, CodeIgniter est fait pour vous si :

  • vous voulez un cadre de développement avec un faible impact de performance ;
  • vous avez besoin de performances élevées ;
  • vous avez besoin d'une large compatibilité de versions de PHP et de configurations ;
  • vous voulez un cadre qui ne nécessite quasiment aucune configuration pour démarrer ;
  • vous voulez un cadre qui ne vous oblige pas à utiliser la ligne de commande ;
  • vous voulez un cadre qui ne vous oblige pas à adhérer à des règles restrictives de codage ;
  • vous ne voulez pas être obligé d'apprendre un langage de templates supplémentaires ;
  • vous voulez éviter la complexité, en favorisant des solutions simples ;
  • vous avez besoin d'une documentation claire et complète.

I-C. Prérequis techniques

Il faut aussi un serveur Apache Http 2.0 ou supérieure afin de pouvoir utiliser PHP en mode Web.
Le framework CodeIgniter est prévu pour fonctionner sur une large variété de versions de PHP. Le minimum syndical ici est le PHP 5.1. L'ensemble des versions supérieures étant bien sûr supportées. Les versions précédentes ne sont plus supportées depuis la version 2.0 de CodeIgniter.
Bien que ce ne soit pas nécessaire, il est préférable d'appuyer son application sur une base de données permettant de garantir la pérennité des données. Le langage PHP supporte les bases de données suivantes : MySQL (4.1+), MySQL, MS SQL, PostgreSQL, Oracle, SQLite et ODBC. Le framework CodeIgniter offre ainsi, par défaut, le support d'accès à ces serveurs de base de données.

I-D. Récupération de la dernière version

Pour ce tutoriel de présentation de CodeIgniter 2.0.2, nous avons utilisé la dernière version de CodeIgniter.
http://codeigniter.com/download.php
Il est possible de récupérer EasyPHP pour réaliser la mise en place des exemples.
EasyPHP5.3.3 est disponible à l'adresse suivante :
https://sourceforge.net/projects/quickeasyphp/files/EasyPHP/5.3.3/EasyPHP-5.3.3-setup.exe/download
Pour les environnements Linux, les utilitaires Yum, Apt-get et autres utilitaires d'installation sont disponibles afin de vous mettre à disposition l'ensemble des applications nécessaires.

II. Démarrer d'un projet CodeIgniter

II-A. Organisation générale de CodeIgniter

L'archive du projet est organisée en quatre parties distinctes :

  • le script principal : index.php ;
  • le fichier de licence de CodeIgniter ;
  • le répertoire contenant le manuel d'utilisateur ;
  • le répertoire du moteur et de votre application.

II-B. Point d'entrée : index.php

Ce script est le point d'entrée de votre application et tous les appels passent systématiquement par ce script.
Il a pour rôle de coordonner les actions spécifiques de votre projet en les associant au moteur MVC décrit plus loin dans ce tutoriel.
Il faut noter trois points importants dans votre script :

  • le niveau des affichages d'erreurs :
 
Sélectionnez
error_reporting(E_ALL);
  • le répertoire du moteur CodeIgniter :
 
Sélectionnez
$system_folder = "system";
  • le répertoire de votre application :
 
Sélectionnez
$application_folder = "application";

Cela signifie que par défaut, il est possible avec CodeIgniter de séparer le répertoire d'installation du moteur ($system_folder) du répertoire de votre application ($application_folder).

II-C. Structure des répertoires de votre application

II-C-1. Index.html : le fichier de sécurité

Pour commencer, chaque répertoire de votre application contient un fichier index.html afin d'éviter que l'on puisse lister le contenu de vos répertoires et en déduire la technologie utilisée.

II-C-2. Structuration en répertoires

Le répertoire contient neuf sous-répertoires permettant d'organiser chaque partie de votre application :

  • Config : le répertoire contenant les fichiers de paramétrage ;
  • Controllers : le répertoire contenant le code de l'ensemble des contrôleurs ;
  • Error : le répertoire des pages d'erreurs par défaut ;
  • Helpers : le répertoire contenant vos classes utilitaires ;
  • Hooks : le répertoire contenant vos propres extensions noyau ;
  • Language : le répertoire contenant les fichiers de langage ;
  • Libraries : le répertoire contenant vos propres bibliothèques ;
  • Models : le répertoire contenant vos classes d'utilisation de vos modèles de données ;
  • Views : le répertoire contenant vos classes d'affichage.

II-D. Sécurisation de l'installation de CodeIgniter

II-D-1. Paramétrage Apache pour interdire de listage des répertoires

Il est possible par exemple de paramétrer le serveur Apache afin de lui interdire explicitement de lister le répertoire.
Ajouter un .htaccess à la racine de votre répertoire d'application avec la directive suivante à la base de votre projet :

 
Sélectionnez
Options -indexes

II-D-2. Retrait des informations inutiles

Afin de sécuriser votre installation, il est impératif de retirer l'inutile de votre serveur de production.
Dans le cadre d'un projet tel que CodeIgniter, il est préférable de retirer les répertoires et fichiers suivants :

  • Licence.txt : fichier de licence du produit capable de trahir votre framework en un clic ;
  • User_guide : il est inutile de laisser le manuel permettant à une personne mal intentionnée de disposer de la documentation directement sur le serveur.

II-E. Paramétrage des URL

II-E-1. Format des URL par défaut

Le format des URL CodeIgniter par défaut est le suivant :
http://www.monsite.com/index.com/site/consultation
Le principal défaut est qu'il ne cache pas bien la technologie utilisée, et il est aussi impératif actuellement d'avoir des sites avec des URL génériques permettant d'évoluer ou de changer simplement de technologie sans casser la structure hiérarchique du site.
Cette structuration est importante dans le cadre du référencement de site Web, car les moteurs de recherche n'apprécient pas vraiment le changement d'URL d'un contenu quelconque et freinent la progression du référencement de celui-ci.

II-E-2. Format d'URL plus génériques

L'idée est de mettre en place le mécanisme de réécriture d'URL d'Apache permettant de faire disparaître le nom du script index.php, et de rendre le site portable à souhait vers d'autres technologies si le besoin apparaît.
L'URL précédente doit devenir : http://www.monsite.com/site/consultation

II-E-3. Paramétrage Apache pour la réécriture

Le fichier .htaccess suivant reprend la préconisation interdisant le listage des répertoires, et y ajoute la règle de réécriture simple permettant le joli formatage des URL de votre site en excluant la réécriture pour les fichiers suivants :

  • fichier index.php en lui-même ;
  • les fichiers du répertoire images ;
  • les fichiers du répertoire CSS ;
  • les fichiers du répertoire JS ;
  • le fichier robots.txt ;
  • la racine du site.
 
Sélectionnez
1.
2.
3.
4.
Options -indexes
RewriteEngine on
RewriteCond $1 !^(index\.php|css|js|images|robots\.txt|favicon\.ico|$)
RewriteRule ^(.*)$ index.php/$1 [L]

II-E-4. Accès à l'installation initiale

La racine du site est accessible depuis les trois URL suivantes :

II-E-5. Résultat de la page principale

Image non disponible

III. Concepts fondamentaux de CodeIgniter

III-A. Architecture globale d'une application MVC

Image non disponible

III-B. Présentation d'un contrôleur

Le contrôleur est l'organe de contrôle du système. Il a en charge l'analyse des demandes clientes et l'orchestration des appels aux modèles et aux vues nécessaires à la fourniture de la réponse attendue. Il doit aussi effectuer le choix des appels et l'ordre de ceux-ci. Dans CodeIgniter, un contrôleur est une classe PHP héritant des propriétés de la classe Controler.

III-C. Présentation d'un modèle

Le Modèle est l'organe de récupération et de sélection des données pertinentes pour répondre à la demande. Son rôle consiste à récupérer, filtrer, modifier les données, afin de fournir un sous-ensemble de données pertinent pour la réponse.
Dans CodeIgniter, un contrôleur est une classe PHP héritant des propriétés de la classe Model.

III-D. Présentation d'une vue

La vue est l'organe chargé de produire la présentation des résultats en fonction de données qui lui sont fournies. Pour cela la vue s'appuie généralement sur des « templates » ou modèles de réponse auxquels elle intègre les données afin de composer le résultat final.
Dans le cas de CodeIgniter, les templates sont des fichiers PHP contenant du code de génération d'affichage uniquement.

III-E. Premier cas pratique : Bonjour le Monde !

III-E-1. Écrire son premier contrôleur

Le premier contrôleur peut être déposé dans le répertoire system/application/controllers/ et être nommé : Hello.php

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
<?php 
class Hello extends Controller {
    function Hello()
    {
        parent::Controller();
    }
    function index()
    {
        $this->load->view('hello_message');
    } 
} 
/* End of file hello.php */ 
/* Location: ./system/application/controllers/hello.php */ 
?>

Il est conseillé fortement de respecter le formalisme du contrôleur et des commentaires de pied de page afin de garder votre code homogène et lisible.
Le moyen utilisé par le contrôleur pour associer une vue de votre traitement est réalisé par l'appel suivant :

 
Sélectionnez
$this->load->view('hello_message');

III-E-2. Écrire sa première vue

Le premier contrôleur peut être déposé dans le répertoire system/application/views/ et être nommé : hello_message.php

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
<html>
    <head>
        <title>HELLO World</title>
    </head>
    <body>
        <h1>Hello World</h1>
    </body>
</html>

III-E-3. Appel au nouveau contrôleur

L'appel peut-être effectué par deux URL distinctes :

Le résultat est assez simple et va nous permettre de construire rapidement de nouvelles pages par simple ajout de contrôleurs et de vues.

Hello World

IV. Concepts fondamentaux - suite

IV-A. Présentation de l'utilisation des modèles

Un modèle est un organe permettant de récupérer, filtrer et organiser des données au sein d'une source de données persistantes.
Dans le cas de votre application, il s'agit d'une classe PHP héritant de la classe Model. Il s'agit d'une classe contenant des méthodes facilitant la manipulation des données applicatives en général, et offrant un pont idéal entre les données et vos objets métier. Votre contrôleur se servira de votre modèle afin de récupérer les objets utiles et réalisera un appel à votre vue afin de produire le rendu final associé à vos données.

IV-B. Présentation des classes utilitaires

IV-B-1. Présentation des classes utilitaires

Une classe utilitaire est une classe contenant des fonctions utilitaires pour un domaine particulier de la programmation en PHP et avec CodeIgniter.

IV-B-2. Tableau de synthèse des classes utilitaires de CodeIgniter

Nom de la classe utilitaire

Description

Array Helper

Cette classe utilitaire permet de manipuler des tableaux PHP.
Fonctions : element() et ramdom_element()
Chargement : $this->load->helper('array') ;

Compatibility Helper

Cette classe utilitaire permet de fournir des méthodes de compatibilité entre PHP 4 et PHP5.
Fonctions : file_put_contents(), fputcsv(), http_build_query(), str_ireplace() et stripos()
Chargement : $this->load->helper('compatibility') ;

Cookie Helper

Cette classe utilitaire permet de manipuler des cookies HTTP.
Fonctions : set_cookie(), get_cookie() et delete_cookie ()
Chargement : $this->load->helper('cookie') ;

Date Helper

Cette classe utilitaire permet de manipuler des dates en PHP.
Fonctions : now(), mdate(), standard_date(), local_to_gmt(),mysql_to_unix(), unix_to_human(),
human_to_unix(), timespan(), days_in_month(),
timezones() et timezone_menu()
Chargement : $this->load->helper('date') ;

Directory Helper

Cette classe utilitaire permet de manipuler des répertoires.
Fonction : directory_map ()
Chargement : $this->load->helper('directory') ;

Download Helper

Cette classe utilitaire permet de manipuler les en-têtes HTTP pour forcer le téléchargement plutôt que l'affichage de données.
Fonction : force_download ()
Chargement : $this->load->helper('download') ;

Email Helper

Cette classe utilitaire permet de gérer la validité et l'envoi d'emails.
Fonction : email ()
Chargement : $this->load->helper('email') ;

File Helper

Cette classe utilitaire permet de manipuler des fichiers.
Fonctions : read_file(), write_file(), delete_files(), get_filenames(), get_dir_file_info(), get_file_info(), get_mime_by_extension(), symbolic_permissions() et octal_permissions()
Chargement : $this->load->helper('file') ;

Form Helper

Cette classe utilitaire permet de générer par programmation des formulaires HTML.
Fonctions :form_open(), form_open_multipart(), form_hidden(), form_input(), form_password(), form_upload(), form_textarea(), form_dropdown(), form_multiselect(),form_fieldset(), form_fieldset_close(), form_checkbox(), form_radio(), form_submit(), form_label(), form_reset(), form_button(), form_close(), form_prep(), set_value(), set_select() et set_radio() Fonctions :
Chargement : $this->load->helper('form') ;

HTML Helper

Cette classe utilitaire permet de gérer des éléments HTML.
Fonctions : br(), heading(), img(), link_tag(), nbs(), ol(), ul(), meta() et doctype()
Chargement : $this->load->helper('html') ;

Inflector Helper

Cette classe utilitaire permet de modifier des chaînes de caractères.
Fonctions : singular(), plural(), camelize(), underscore() et humanize()
Chargement : $this->load->helper('inflector') ;

Language Helper

Cette classe utilitaire permet de gérer les traductions.
Fonction : lang()
Chargement : $this->load->helper('language') ;

Number Helper

Cette classe utilitaire permet de traduire des valeurs en octets dans un format lisible avec Unité.
Fonction : byte_format()
Chargement : $this->load->helper('number') ;

Path Helper

Cette classe utilitaire permet de récupérer le chemin absolu d'une ressource.
Fonctions : set_realpath()
Chargement : $this->load->helper('path') ;

Security Helper

Cette classe utilitaire permet de faciliter la gestion de la sécurité au sein de votre application.
Fonctions : xss_clean(), dohash(), strip_image_tags() et encode_php_tags()
Chargement : $this->load->helper('security') ;

Smiley Helper

Cette classe utilitaire permet de traduire des smileys en images à partir de ressources fournies par le projet CodeIgniter
http://codeigniter.com/download_files/smileys.zip
Fonctions : get_clickable_smileys, smiley_js() et parse_smileys()
Chargement : $this->load->helper('smiley') ;

String Helper

Cette classe utilitaire permet de manipuler et générer des chaînes de caractères.
Fonctions : random_string(), alternator(), repeater(), reduce_double_slashes(), trim_slashes(), reduce_multiples() et quotes_to_entities()
Chargement : $this->load->helper('string') ;

Text Helper

Cette classe utilitaire permet de manipuler du texte.
Fonctions : word_limiter(), character_limiter(), ascii_to_entities(), entities_to_ascii(), word_censor(), highlight_code(), highlight_phrase() et word_wrap()
Chargement : $this->load->helper('text') ;

Typography Helper

Cette classe utilitaire permet de gérer la typographie d'un texte dans la page Web.
Fonctions : auto_typography () et nl2br_except_pre ()
Chargement : $this->load->helper('typography') ;

URL Helper

Cette classe utilitaire permet de manipuler et gérer des URL.
Fonctions : site_url(), base_url(), current_url(), uri_string(), index_page(), anchor(), anchor_popup(), mailto(), safe_mailto(), auto_link(), url_title(), prep_url() et redirect()
Chargement : $this->load->helper('url') ;

XML Helper

Cette classe utilitaire permet de gérer les caractères réservés en XML en les convertissant.
Fonction : xml_convert ()
Chargement : $this->load->helper('xml') ;

IV-C. Présentation des classes librarie de CodeIgniter

IV-C-1. Présentation des bibliothèques CodeIgniter

Une bibliothèque (library) est une classe spécifique de CodeIgniter permettant de réaliser des tâches complexes dans un domaine particulier de la programmation en PHP et avec CodeIgniter. Une bibliothèque est un organe plus complexe qu'une simple classe utilitaire nécessitant une gestion plus avancée des états.

IV-C-2. Tableau de synthèse des bibliothèques de CodeIgniter

Nom de la classe utilitaire

Description

Benchmarking Class

Cette bibliothèque permet de réaliser des mesures de temps de traitements de votre application.
Chargement : $this->output->enable_profiler(TRUE) ;

Calendar Class

Cette bibliothèque permet de fournir des méthodes de gestion de calendrier.
Chargement : $this->load->library('calendar') ;

Cart Class

Cette bibliothèque permet de gérer un caddy pour site de e-commerce.
Chargement : $this->load->library('cart') ;

Config Class

Cette bibliothèque permet de gérer des fichiers de configuration.
Chargement : Automatique

Database Class

Cette bibliothèque permet de manipuler des données dans une base de données.
Chargement : $this->load->library('database') ;

Email Class

Cette bibliothèque permet de manipuler et envoyer des emails avec des fonctionnalités avancées telles que les pièces jointes.
Chargement : $this->load->library('email') ;

Encryption Class

Cette bibliothèque permet de manipuler le chiffrement et de déchiffrement de données.
Chargement : $this->load->library('encrypt') ;

File Uploading Class

Cette bibliothèque permet de gérer l'upload de fichiers depuis le navigateur-client.
Chargement : $this->load->library('upload') ;

Form Validation Class

Cette bibliothèque permet de gérer la validation des formulaires HTML.
Chargement : $this->load->library('form_validation') ;

FTP Class

Cette bibliothèque permet de gérer des transferts de fichiers via FTP.
Chargement : $this->load->library('ftp') ;

HTML Table Class

Cette bibliothèque permet de générer des tableaux HTML.
Chargement : $this->load->library('table') ;

Image Manipulation Class

Cette bibliothèque permet de manipuler des images, créer des vignettes, retailler, effectuer des rotations et des fusions.
Chargement : $this->load->library('image_lib') ;

Input and Security Class

Cette bibliothèque permet de gérer le filtrage et la manipulation sécurisée des données.
Chargement : Automatique

Loader Class

Cette bibliothèque permet de gérer le chargement des différents éléments dans CodeIgniter.
Chargement : Automatique

Language Class

Obsolète et remplacé par la classe utilitaire Language.

Output Class

Cette bibliothèque permet de gérer le résultat final envoyé au client.
Chargement : Automatique

Pagination Class

Cette bibliothèque permet de gérer la pagination et la navigation dans vos pages.
Chargement : $this->load->library('pagination') ;

Session Class

Cette bibliothèque permet de manipuler et de gérer les sessions.
Chargement : $this->load->library('session') ;

Trackback Class

Cette bibliothèque permet de gérer et manipuler des rétroliens ou trackbacks.
Chargement : $this->load->library('trackback') ;

Template Parser Class

Cette bibliothèque permet de supporter un langage simple de templates pour vos pages Web.
Chargement : $this->load->library('parser') ;

Typography Class

Cette bibliothèque permet de gérer la typographie de vos textes.
Chargement : $this->load->library('typography') ;

Unit Testing Class

Cette bibliothèque permet de réaliser et exécuter des tests unitaires.
Chargement : $this->load->library('unit_test') ;

URI Class

Cette bibliothèque permet de manipuler des URI.
Chargement : Automatique

User Agent Class

Cette bibliothèque permet de manipuler l'en-tête User-Agent.
Chargement : $this->load->library('user_agent') ;

XML-RPC Class

Cette bibliothèque permet de fournir un service XML au format XML-RPC.
Chargement : $this->load->library('xmlrpc') ;

Zip Encoding Class

Cette bibliothèque permet de manipuler des données au format ZIP.
Chargement : $this->load->library('zip') ;

IV-D. Chargement automatique de composants

Il se peut que vous ayez sans arrêt les mêmes éléments à charger dans votre contrôleur.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
$this->load->model('...'); 
$this->load->librairie('...'); 
$this->load->helper('...'); 
$this->load->plugin('...'); 
$this->load->config('...'); 
$this->load->lang ('...');

Et afin de ne pas surcharger votre contrôleur de ces lignes de code, il est possible de procéder à leur chargement automatique à chaque appel.
Pour cela il faut modifier le fichier application/config/autoload.php contenant l'ensemble des éléments à précharger automatiquement.
Attention car à chaque appel, l'ensemble du code des éléments à précharger sera lu, interprété et exécuté avant de passer à votre application.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
$autoload['libraries'] = array(); 
$autoload['helper'] = array(); 
$autoload['plugin'] = array(); 
$autoload['config'] = array(); 
$autoload['language'] = array(); 
$autoload['model'] = array();

Il suffit d'ajouter le nom des éléments à charger afin de les voir pris en compte automatiquement dans votre application.
Par exemple, si votre application utilise massivement des bases de données et la validation de formulaires ainsi que l'envoi d'emails, il est probable que la ligne suivante puisse correspondre à votre besoin.

 
Sélectionnez
$autoload['libraries'] = array('database', 'email', 'form_validation');

De même, si votre application nécessite un fichier de configuration supplémentaire, il suffit d'ajouter un fichier de configuration dans le répertoire application/config/mesconfigs.hp et de le charger automatiquement avec :

 
Sélectionnez
$autoload['config'] = array('mesconfigs');

V. Présentation de quelques bibliothèques utiles

V-A. bibliothèque de gestion des bases de données

V-A-1. Paramétrage de l'accès à la base de données

La configuration de l'accès à la base de données est réalisée dans le fichier de configuration application/configuration/database.php.
Il existe une configuration par défaut :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
$db['default']['hostname'] = "localhost";
$db['default']['username'] = "admin";
$db['default']['password'] = "";
$db['default']['database'] = "basededonnees";
$db['default']['dbdriver'] = "mysql";
$db['default']['dbprefix'] = "";
$db['default']['pconnect'] = TRUE;
$db['default']['db_debug'] = FALSE;
$db['default']['cache_on'] = FALSE;
$db['default']['cachedir'] = "";
$db['default']['char_set'] = "utf8";
$db['default']['dbcollat'] = "utf8_general_ci";

Afin de charger la configuration par défaut, il suffit d'ajouter l'appel suivant dans votre code :

 
Sélectionnez
$this->load->database();

Le chargement sera effectif et vous pourrez immédiatement utiliser le composant d'accès aux bases de données.
Il est cependant possible de créer de multiples configurations en ajoutant un nouveau sous-ensemble.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
$db['autreconfig']['hostname'] = "localhost";
$db['autreconfig']['username'] = "admin";
$db['autreconfig']['password'] = "";
$db['autreconfig']['database'] = "autrebasededonnees";
$db['autreconfig']['dbdriver'] = "mysql";
$db['autreconfig']['dbprefix'] = "";
$db['autreconfig']['pconnect'] = TRUE; 
$db['autreconfig']['db_debug'] = FALSE;
$db['autreconfig']['cache_on'] = FALSE;
$db['autreconfig']['cachedir'] = "";
$db['autreconfig']['char_set'] = "utf8";
$db['autreconfig']['dbcollat'] = "utf8_general_ci";

Afin de charger la nouvelle configuration, il suffit d'ajouter l'appel suivant dans votre code en y précisant le nom de la configuration à charger.

 
Sélectionnez
$this->load->database('autreconfig');

Le chargement sera effectif et vous pourrez immédiatement utiliser le composant d'accès aux bases de données.

V-A-2. Exécution et validation d'une requête SQL

La solution pour exécuter une requête SQL sans récupération de données, en dehors de la vérification du bon fonctionnement de la requête SQL, est d'utiliser la méthode $this->db->simple_query().

Exemple :

 
Sélectionnez
1.
2.
3.
4.
$this->load->database('autreconfig'); 
$res=$this->db->simple_query("INSERT INTO ARTICLE VALUES ( ... )"); 
if ( $res== TRUE ) echo "Requete [OK]"; 
else echo " Requete [ECHEC]";

V-A-3. Exécution et récupération des résultats au format objet

L'utilisation la plus courante de votre base de données est la consultation et l'affichage ; pour cela il est possible d'utiliser les méthodes $this->db->query() et $query->result(). Les résultats sont retournés sous forme d'objet.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
$query = $this->db->query("SELECT * FROM ARTICLE");
if ($query->num_rows() > 0) {
    foreach ($query->result() as $row) {
        echo $row->ID;
        echo $row->LABEL;
        echo $row->PRIXHT;
     } 
} else { echo "Pas d'article."; }
    
$query->free_result();

Il est possible de récupérer élément par élément, plutôt qu'en masse, les données résultat.
Voici donc une version permettant de ne pas allouer massivement de la mémoire au début de la boucle for.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
$query = $this->db->query("SELECT * FROM ARTICLE");
if ($query->num_rows() > 0) {
    for ($i=0; $i<$query->num_rows(); $i++) {
        $row= $query->row($i);
        echo $row->ID;
        echo $row->LABEL;
        echo $row->PRIXHT;
    } 
} else { echo "Pas d'article."; } 

$query->free_result();

V-A-4. Exécution et récupération des résultats au format tableau

Parfois, il est plus pratique, pour des raisons de compatibilité, de manipuler des tableaux PHP que des objets PHP. CodeIgniter fournit l'ensemble des outils pour manipuler des tableaux au lieu des objets.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
$query = $this->db->query("SELECT * FROM ARTICLE");

if ($query->num_rows() > 0) {
        foreach ($query->result_array() as $row) {
            echo $row['ID'];
            echo $row['LABEL'];
            echo $row['PRIXHT'];
        } 
} else { echo "Pas d'article."; } 
$query->free_result();

Il est possible de récupérer élément par élément, plutôt qu'en masse, les données résultat.
Voici donc une version permettant de ne pas allouer massivement de la mémoire au début de la boucle for.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
$query = $this->db->query("SELECT * FROM ARTICLE");
if ($query->num_rows() > 0) {
    for ($i=0; $i< $query->num_rows(); $i++)> {
        $row= $query->row_array($i);
        echo $row['ID'];
        echo $row['LABEL'];
        echo $row['PRIXHT'];
    } 
} else { echo "Pas d'article."; } 
$query->free_result();

V-A-5. Utilisation d'Active Record pour générer les échanges

Active Record est un patron de conception permettant de faciliter l'écriture de requêtes SQL par programmation.

V-A-6. Méthodes disponibles pour la lecture

L'implémentation d'Active Record dans CodeIgniter est riche et permet en plus de chaîner les appels de méthodes.
Voici la liste des méthodes permettant par programmation de générer une requête SQL équivalente :

  • $this->db->get()
  • $this->db->get_where()
  • $this->db->select()
  • $this->db->select_max()
  • $this->db->select_min()
  • $this->db->select_avg()
  • $this->db->select_sum()
  • $this->db->from()
  • $this->db->join()
  • $this->db->where()
  • $this->db->or_where()
  • $this->db->where_in()
  • $this->db->or_where_in()
  • $this->db->where_not_in()
  • $this->db->or_where_not_in()
  • $this->db->like()
  • $this->db->or_like()
  • $this->db->not_like()
  • $this->db->or_not_like()
  • $this->db->group_by()
  • $this->db->distinct()
  • $this->db->having()
  • $this->db->or_having()
  • $this->db->order_by()
  • $this->db->limit()
  • $this->db->count_all_results()
  • $this->db->count_all()

V-A-7. Exemples de lectures avec Active Record

  • récupération de tous les articles :
 
Sélectionnez
$query=$this->db->get('ARTICLE');
  • récupération du premier article de la base :
 
Sélectionnez
$this->db->select('LABEL')->from('ARTICLE')->limit(1);
 
Sélectionnez
$query = $this->db->get();
  • récupération des dix premiers labels des articles de moins de 100 euros hors taxes en donnant les moins chers :
 
Sélectionnez
1.
2.
$this->db->select('LABEL')->from('ARTICLE')->where('PRIXHT <', 100)->order_by('PRIXHT', 'ASC')->limit(10);
$query = $this->db->get();

V-A-8. Méthodes disponibles pour l'insertion

Les méthodes suivantes permettent d'insérer des données dans vos bases de données :

V-A-9. Méthodes disponibles pour la mise à jour

La méthode suivante permet de mettre à jour simplement vos données :

  • $this->db->update()
  • $this->db->delete()
  • $this->db->empty_table()
  • $this->db->truncate()

V-A-10. Méthodes de mise en cache avec Active Record

  • $this->db->start_cache()
  • $this->db->stop_cache()
  • $this->db->flush_cache()

V-B. La bibliothèque de gestion des emails

La bibliothèque de gestion des emails permet à votre application de gérer l'envoi d'emails.
Le chargement de la bibliothèque est simple.

 
Sélectionnez
$this->load->library('email');

Cette bibliothèque offre le support de plusieurs protocoles Mail (Mail, Sendmail, et SMTP) afin de mieux s'adapter à votre environnement.
La bibliothèque offre l'ensemble des fonctionnalités tel que le support des destinataires en copie (CC) et en copie cachée (BCC).
Elle permet le découpage des textes et l'envoi au format texte ou HTML.
Les pièces jointes peuvent être ajoutées dans vos messages.

V-B-1. Méthodes disponibles pour l'envoi d'emails

Les méthodes suivantes permettent de gérer la création, l'envoi et l'analyse de vos emails dans votre application.

  • $this->email->from()
  • $this->email->reply_to()
  • $this->email->to()
  • $this->email->cc()
  • $this->email->bcc()
  • $this->email->subject()
  • $this->email->message()
  • $this->email->set_alt_message()
  • $this->email->clear()
  • $this->email->send()
  • $this->email->attach()
  • $this->email->print_debugger()

V-B-2. Exemple simple d'envoi d'emails

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
$list = array( 
    "Jean-Marie" => "jmrenouard@gmail.com", 
    "Sophie" => "sophie@gmail.com", 
    "Clement" => '<link href="mailto:clement@gmail.com">clement@gmail.com</link>', 
); 

foreach ($list as $prenom => $email) {
    $this->email->clear();
    $this->email->to($email);
    $this->email->from('codeigniter@gmail.com');
    $this->email->subject('Message à l\'attention de '.$prenom);
    $this->email->message("Bonjour $prenom,\nVous avez gagnez une voiture\n après avoir répondu à nos 100 questions...");
    $this->email->send(); 
}

V-B-3. Exemple d'envoi d'emails avec pièces jointes

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
$list= array( 
"Jean-Marie" => "jmrenouard@gmail.com", 
"Sophie" => "sophie@gmail.com", 
"Clement" => '<link href="mailto:clement@gmail.com">clement@gmail.com</link>', 
); 
 
foreach ($list as $prenom => $email) {
    $this->email->clear();
    $this->email->to($email);
    $this->email->from('codeigniter@gmail.com');
    $this->email->subject('Message à l\'attention de '.$prenom);
    $this->email->message("Bonjour $prenom,\nVous avez gagnez une voiture\n après avoir répondu à nos 100 questions...");
    $this->email->attach('/doc/logo.jpg');
    $this->email->attach('/doc/questionnaire.doc');
    $this->email->attach('/doc/image_billets.jpg');
    $this->email->send();> 
}

V-C. La bibliothèque de création de Web Services

Le framework CodeIgniter permet de gérer vos propres Web Services via le support du protocole XML-RPC. Il s'agit d'un protocole simple donc la spécification se trouve ici http://www.xmlrpc.com/.
XML-RPC est un protocole léger de Web Services basé sur XML.
Il offre l'avantage de s'abstraire des environnements techniques spécifiques ( Windows/Linux) et des problématiques de transcodage de résultats et des demandes.
Il s'agit donc d'un protocole idéal pour lier plusieurs technologies hétérogènes au sein d'un système d'information sans provoquer un risque d'incompatibilité entre applications.

V-C-1. Méthodes disponibles pour gérer vos échanges XML-RPC

  • $this->xmlrpc->server()
  • $this->xmlrpc->timeout()
  • $this->xmlrpc->method()
  • $this->xmlrpc->request()
  • $this->xmlrpc->send_request()
  • $this->xmlrpc->set_debug(TRUE)
  • $this->xmlrpc->display_error()
  • $this->xmlrpc->display_response()
  • $this->xmlrpc->send_error_message()
  • $this->xmlrpc->send_response()

V-C-2. Gestion des appels à un service XML-RPC

Il est possible de gérer des appels à des services distants par XML-RPC.
C'est idéal pour structurer des services au sein d'une entreprise, et permettre la mise à disponibilité des informations et des outils de traitement de l'information.
Voici donc un exemple de contrôleur permettant d'interroger un serveur XML-RPC :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
<?php 
class Xmlrpc_client extends Controller {
    function index()
    {
        $this->load->helper('url');
        $server_url = site_url('xmlrpc_server');
        $this->load->library('xmlrpc');
        $this->xmlrpc->server(http://www.monsitecom/xml_server, 80);
        $this->xmlrpc->method('ping');
        $request = array('Comment vas-u ?');
        $this->xmlrpc->request($request);
        if ( ! $this->xmlrpc->send_request()) {
            echo $this->xmlrpc->display_error();
        } else {
            echo '<pre>';
            print_r($this->xmlrpc->display_response());
            echo '</pre>';
        }
    } 
} 
?>

V-C-3. Gestion des appels entrants au format XML-RPC

La bibliothèque CodeIgniter permet de créer un Web Service rapidement en complément de votre site Web.
Il permet de lier vos partenaires à votre site et d'automatiser certains échanges.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
<?php 
class Xmlrpc_server extends Controller {
    function index()
    {
        $this->load->library('xmlrpc');
        $this->load->library('xmlrpcs');
        $config['functions']['Ping'] = array('function' => 'Xmlrpc_server.process');
        $this->xmlrpcs->initialize($config);
        $this->xmlrpcs->serve();
    }
    function process($request)
    {
        $parameters = $request->output_parameters();
        $response = array(
                array(
                    'Tu dis : ' => $parameters['0'],
                    'Je reponds' => 'Cc est plutôt bon signe :).'),
                'struct');
        return $this->xmlrpc->send_response($response);
    } 
} 
?>

V-D. Bibliothèque de gestion d'accès FTP

Le protocole FTP est idéal pour gérer les transferts de fichiers.
Ce protocole est largement utilisé pour les transferts de site. Il est donc possible d'imaginer un site qui vous permet de déployer vos configurations et applications chez un hébergeur directement depuis un site d'administration.

V-D-1. Méthodes disponibles pour gérer vos échanges FTP

  • $this->ftp->connect()
  • $this->ftp->upload()
  • $this->ftp->rename()
  • $this->ftp->move()
  • $this->ftp->delete_file()
  • $this->ftp->delete_dir()
  • $this->ftp->list_files()
  • $this->ftp->mirror()
  • $this->ftp->mkdir()
  • $this->ftp->chmod()
  • $this->ftp->close()

V-D-2. Exemples d'utilisation de FTP

Uploader un fichier :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
$this->load->library('ftp');

$config['hostname'] = 'ftp.free.fr';
$config['username']= 'jmrenouard';
$config['password'] = 'XXXXXX';
$this->ftp->connect($config); 
$this->ftp->upload('/site/monfichier.html', '/public_html/monfichier.html'); 
$this->ftp->close();

Effectuer une copie intégrale de répertoire par FTP :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
$this->load->library('ftp');
$config['hostname'] = 'ftp.free.fr';
$config['username'] = 'jmrenouard';
$config['password'] = 'XXXXXX';
$this->ftp->connect($config); 
$this->ftp->mirror(('/site/','/public_html'); 
$this->ftp->close();

Lister un répertoire par FTP :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
$this->load->library('ftp');
$config['hostname'] = 'ftp.free.fr';
$config['username'] = 'jmrenouard';
$config['password'] = 'XXXXXX';

$this->ftp->connect($config); 
$list=$this->ftp->list('/public_html'); 
print_r($list); 
$this->ftp->close();

V-E. Les bibliothèques de gestion de formulaires

La bibliothèque de validation de formulaires est un outil idéal pour vous garantir une gestion simple des formulaires HTML, en garantissant la sécurité et la validation des paramètres passés dans le formulaire.

V-E-1. Méthodes disponibles pour gérer vos formulaires

  • $this->form_validation->set_rules()
  • $this->form_validation->run()
  • $this->form_validation->set_message()

V-E-2. Fonctions de la classe utilitaire

  • form_error() ;
  • validation_errors() ;
  • set_value() ;
  • set_select() ;
  • set_checkbox() ;
  • set_radio().

V-F. Exemple simple de gestion de la validation de formulaire

Voici un exemple simple de formulaire de création de comptes.

V-F-1. La vue du formulaire : view/formulaire.php

La vue formulaire permet de fabriquer une vue prenant en compte l'affichage du formulaire et des erreurs éventuelles. Ces erreurs seront affichées en haut du formulaire et devant le champ ne respectant pas les règles de validation.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
<html>
    <head>
    <title>MON FORMULAIRE</title>
    </head>
    <body>
        <?php echo validation_errors(); ?>
        <?php echo form_open('form'); ?>
        <h5>Login</h5>
        <?php echo form_error('login'); ?>
        <input type="text" name="login" value="<?php echo set_value('login'); ?>" size="50" />
        <h5>Password</h5>
        <?php echo form_error('password'); ?>
        <input type="text" name="password" value="<?php echo set_value('password'); ?>" size="50" />
        <h5>Validation du Password </h5>
        <?php echo form_error('passconf'); ?>
        <input type="text" name="passconf" value="<?php echo set_value('passconf'); ?>" size="50" />
        <h5>Adresse Email</h5>
        <?php echo form_error('email'); ?>
        <input type="text" name="email" value="<?php echo set_value('email'); ?>" size="50" />
        <div><input type="submit" value="Submit" /></div>
        </form>
    </body> 
</html>

V-F-2. La vue de confirmation de création de comptes : view/succes.php

Il s'agit d'une vue simple permettant de construire une page de résultats indiquant que les règles ont été respectées et le traitement du formulaire effectué.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
<html>
    <head>
    <title>Mon formulaire</title>
    </head>
    <body>
        <h3>Le formulaire de création de compte a bien été transmis !</h3>
        <p><?php echo anchor('formulaire', 'Essayez à nouveau'); ?></p>
    </body> 
</html>

V-F-3. Le contrôleur permettant de gérer la validation du formulaire : controllers/form.php

Le contrôleur est l'élément central de la procédure de validation.
Les règles de validation sont positionnées par la méthode : $this->form_validation->set_rules() et la validation est effectuée par la méthode $this->form_validation->run().

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
<?php 
class Form extends Controller {
    function index()
    {
        $this->load->helper(array('form', 'url'));
        $this->load->library('form_validation');
        $this->form_validation->set_rules('login', 'Username', 'required');
        $this->form_validation->set_rules('password', 'Password', 'required');
        $this->form_validation->set_rules('passconf', 'Password Confirmation', 'required');
        $this->form_validation->set_rules('email', 'Email', 'required');
        if ($this->form_validation->run() == FALSE) {
            $this->load->view('formulaire');
        } else { $this->load->view('succes'); }
    } 
} 
?>

V-F-4. Modification avancée des paramètres de filtrage

Il est possible de définir les règles de paramétrage de la validation dans un tableau PHP. Cette version utilise ce modèle. De même, les règles de validation sont enrichies en utilisant la cascade de règles.
La règle suivante :

  • trim|required|min_length[5]|max_length[12]|xss_clean'

indique que :

  • trim : la chaîne va être réduite des espaces au début et à la fin ;
  • required : indique que la chaîne ne peut être vide après réduction ;
  • min_length[5] : indique que la chaîne doit faire au moins 5 caractères ;
  • max_length[12] : indique que la chaîne doit faire au plus 121 caractères ;
  • xss_clean : indique que la chaîne doit être sécurisée contre une attaque type XSS.
 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
$config = array(
    array('field'=> 'login','label'=> 'Login','rules'=> 'trim|required|min_length[5]|max_length[12]|xss_clean'),
    array('field'=> 'password','label'=>'Password', 'rules'=> 'trim|required|matches[passconf]|md5'),
    array('field'=> 'passconf', 'label'=> 'Validation du Password','rules'=> 'trim|required|matches[passconf]|md5'),
    array('field'=> 'email', 'label'=> 'Email', 'rules'=> 'trim|required|valid_email')
);
$this->form_validation->set_rules($config);

VI. Concepts avancés des URL

VI-A. Gestion avancée des URL

VI-A-1. Redéfinition d'URL par configuration

Le fichier de configuration application/config/routes.php permet de définir les contrôleurs associés à une URI.

 
Sélectionnez
1.
2.
$route['journals'] = "blogs"; 
$route['product/(:num)'] = "catalog/product_lookup_by_id/$1";

Tous les appels à une URI commençant par /journals seront dirigés vers le contrôleur blogs.
Dans le second cas, tous les appels à une URI commençant par /products/{un nombre quelconque} seront dirigés vers le contrôleur catalog et la méthode product_lookup_by_id avec comme paramètre le nombre.

VI-A-2. Redéfinition d'URL par programmation

Dans chaque contrôleur, il est possible de définir la distribution dans les méthodes par la méthode _remap

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
function _remap($method) {
    if ($method == 'methode_inconnue') {
        $this->$index();
    } else {
        $this->default_method();
    }
}

VI-B. Gestion des erreurs

La gestion des erreurs peut être réalisée par programmation et elle est en général gérée par le framework.

VI-B-1. Les vues associées aux pages d'erreur

Il est possible de spécifier quatre pages spécifiques d'erreur:

  • error_404.php : pour les pages non trouvées ;
  • error_db.php : pour les pages d'erreur associées aux bases de données ;
  • error_php.php : pour les pages d'erreur associées aux problèmes de code PHP ;
  • error_general.php : pour les pages d'erreur associées aux problèmes généraux.

VI-B-2. Méthodes de gestion des erreurs

  • show_error('message' [, int $status_code= 500 ] )
  • show_404('page')
  • log_message('level', 'message')

VI-C. Appel en ligne de commande

Il est possible d'écrire un client pour vos applications CodeIgniter afin d'appeler vos méthodes directement sans passer par un navigateur ou un client HTTP.

VI-C-1. Code du client CodeIgniter

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
#!/usr/bin/php 
<?php 
/* Eviter les coupures de timeout */ 
set_time_limit(0); 

/* Definir une limite de buffer mémoire suffissante */ 
ini_set('memory_limit', '256M'); 

/* Eviter d'utiliser le script depuis un navigateur */ 
if (isset($_SERVER['REMOTE_ADDR'])) die('Permission denied.'); 

/* Possitionnement de quelques variables */ 
define('CMD', 1); 
$ROOT_DIR="/var/www/html/site/"; 

/* retrait du premier paramétre : le nom du script */ 
unset($argv[0]); 

/* Positionnement des parameters pour retrouver le bon controlleur et la benne méthde */ 
$_SERVER['REQUEST_URI'] = '/' . implode('/', $argv) . '/'; 
$_SERVER['QUERY_STRING'] = $_SERVER['PATH_INFO'] = $_SERVER['REQUEST_URI'] ;
/* Appel au framework */ 
include("$ROOT_DIR/index.php"); 
?>

VI-C-2. Exemple d'utilisation

 
Sélectionnez
                    $ php ci_call.php ecommerce index

 
Sélectionnez
                    $ php ci_call.php xmlrpc_client ping

VI-D. Paramétrage pour la production

Il est important de paramétrer votre php.ini en production afin qu'il garantisse un minimum de protection.
Il est conseillé de désactiver l'envoi de l'en-tête HTTP avec le numéro de version PHP et de désactiver l'affichage des erreurs PHP dans la fenêtre de résultat même si les pages peuvent être modifiées pour l'affichage.

VI-D-1. Paramètres à valider en production

 
Sélectionnez
Expose_php =Off 
Display_errors=Off

VII. Amélioration des performances

VII-A. Mesure des performances

Mesurer les performances grâce à CodeIgniter est très simple.
Il suffit d'ajouter cette ligne dans votre contrôleur pour l'activer, et de la retirer pour la désactiver.

 
Sélectionnez
$this->output->enable_profiler(TRUE);

Dès que la ligne est ajoutée, des informations supplémentaires apparaissent en bas de page :

Image non disponible

Les informations suivantes sont affichées afin de déboguer facilement et trouver les sources de contention de votre application.

  • URL appelée ;
  • Méthode et classe PHP du contrôleur ;
  • Utilisation mémoire totale ;
  • Durée respective de chacune des étapes triées par ordre de parution dans le code ;
  • Les données GET passées en paramètre ;
  • Les données POST passées en paramètre ;
  • Les requêtes SQL envoyées vers les bases de données.

VII-B. Présentation de la bibliothèque Benchmarking

La bibliothèque Benchmark est chargée automatiquement par CodeIgniter, et il est donc inutile d'invoquer $this->load->library pour charger la bibliothèque.
Pour ajouter une ligne de mesure spécifique pour un bloc de code donné, il faut :
placé au début du bloc, $this->benchmark->mark('xxx_start') et $this->benchmark->mark('xxx_stop') placé à la fin du bloc.
Cela permettra d'ajouter une mesure de performance labellisée 'xxx'.

VII-B-1. Exemple de code

 
Sélectionnez
1.
2.
$this->benchmark->mark('tag_start');> sleep(2);> $this->benchmark->mark('tag_end');> 
$this->benchmark->mark('tag2_start');> sleep(1);> $this->benchmark->mark('tag2_end');

Grâce à ces ajouts de code, deux nouvelles lignes apparaissent au niveau du tableau benchmarks indiquant les temps exécution pour le tag et tag2.

VII-C. Mise en place de cache

Afin d'améliorer les performances, il est possible pour certaines pages de mettre le résultat dans un cache. Dans ce cas, le résultat ne sera pas recalculé, mais directement pris depuis un fichier dans le cache contenant le résultat de la page.
La bibliothèque output nécessaire est chargée par défaut.
Pour activer cette fonctionnalité par page ou par méthode de contrôleur, il faut trois choses :

  • le nombre de minutes de persistance du cache ;
  • les droits d'écriture sur le répertoire system/cache ;
  • l'appel explicite dans le contrôleur de la demande de mise en cache.

Si vous souhaitez mettre en place le cache de page pour une durée de $n secondes, voici la ligne à ajouter  :

 
Sélectionnez
$this->output->cache($n);

VII-D. Réalisation de ses propres bibliothèques

Il est possible d'écrire vos propres bibliothèques.
Le framework CodeIgniter vous permet trois choses :

  • créer vos propres bibliothèques ;
  • étendre des bibliothèques existantes ;
  • remplacer des bibliothèques existantes.

Vos bibliothèques doivent être stockées dans le répertoire application/libraries.

VII-D-1. Création d'une bibliothèque

Le fichier de la bibliothèque doit commencer par une majuscule : Soap.php

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
<?php 
if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class Soap {
    function recevoir_une_requete_soap() {...}
    function envoyer_une_requete_soap () {...} 
}

?>

Il n'y a rien de complexe, et afin d'utiliser votre nouvelle bibliothèque, le chargement s'effectue par programmation :

 
Sélectionnez
$this->load->library('soap'); 
$this->soap->envoyer_une_requete_soap();

VII-D-2. Extension d'une bibliothèque existante

Pour ceci, il suffit de trouver la thématique générale de votre bibliothèque et de surcharger la classe.
Pour connaître le préfixe de surcharge des bibliothèques fondamentales, il faut consulter le paramètre suivant dans le fichier de configuration application/config/config.php :

 
Sélectionnez
$config['subclass_prefix'] = 'MY_';

toutes les classes avec un préfixe en MY_ seront considérées comme une extension des bibliothèques fondamentales portant le même nom.
Ci-dessous, il s'agit d'une extension de la classe CI_Mail de CodeIgniter avec l'ajout d'une fonction annuler_dernier_email :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
class MY_Email extends CI_Email {
    function My_Email() {
        parent::CI_Email();
    }
    function annuler_dernier_email(){
    } 
}

Le chargement de la nouvelle bibliothèque surchargée se fait de ma même manière sans supplément.

 
Sélectionnez
$this->load->library('email'); 
$this->email->annuler_dernier_email();

VIII. La sécurité

VIII-A. Fonctionnalités de sécurité de CodeIgniter

La fonction de filtrage de sécurité de CodeIgniter est invoquée automatiquement à l'appel d'un contrôleur.
Cette fonction permet :

  • la suppression du tableau global $_GET car les données sont disponibles sous d'autres formes dans le contrôleur ;
  • la suppression de toutes les variables globales, même avec le paramètre php.ini register_globals à ON ;
  • le filtrage des données des tableaux $_POST et $_COOKIE en ne permettant que les caractères alphanumériques ;
  • la fourniture d'une solution de protection XSS activable ;
  • la normalisation des retours à la ligne en \n.

VIII-B. Activation du filtrage de sécurité

Il existe deux moyens d'activer la validation et la protection XSS des données passées au framework :

 
Sélectionnez
$data = $this->input->xss_clean($data);

La seconde technique consiste à ajouter le filtrage automatique dans le fichier de configuration principale application/config/config.php :

 
Sélectionnez
$config['global_xss_filtering'] = TRUE;

IX. Qualité du code

La qualité du code peut être attribuée à de nombreux facteurs tels que :

  • architecture du code ;
  • règle de nommage et codage ;
  • extensibilité des fonctionnalités ;
  • capacité de tester unitairement chaque partie du code ;
  • capacité à internationaliser l'application rapidement.

IX-A. Mise en place de tests unitaires pour votre site

Il est possible de mettre en place des tests unitaires et ainsi de garantir une qualité de code mesurable.
Afin de charger la bibliothèque des tests unitaires, il vous faut ajouter la ligne suivante dans votre contrôleur.

 
Sélectionnez
$this->load->library('unit_test');

IX-A-1. Méthode de production de tests unitaires

  • $this->unit->run("élément testé", "résultat attendue", "nom du test");

La partie résultat attendu peut être remplacée par des chaînes réservées à certains tests ;.

  • is_string : l'élément testé est une chaîne de caractères ;
  • is_bool : l'élément testé est un booléen ;
  • is_true : l'élément testé est VRAI ;
  • is_false : l'élément testé est FAUX ;
  • is_int : l'élément testé est un entier ;
  • is_numeric : l'élément testé est une valeur numérique ;
  • is_float : l'élément testé est une valeur flottante ;
  • is_double : l'élément testé est une valeur double ;
  • is_array : l'élément testé est un tableau PHP ;
  • is_null : l'élément testé est NULL.

IX-A-2. Exemples de tests unitaires avec rapport formaté

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
function testTU() {
    $this->load->library('unit_test');
    $this->unit->run("ceci est une chaine", 'is_string', 'Test de chaine');
    $this->unit->run("ceci est une chaine", 'is_null', 'Test de nullite');
    $this->unit->run(5, 'is_int', 'Test de nombre entier');
    echo "<H1>Tests unitaires</H1>";
    echo $this->unit->report(); 
}

IX-A-3. Rapport résultat

Image non disponible

IX-A-4. Exemple de tests unitaires avec rapport brut

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
function testTU() {
    $this->load->library('unit_test');
    $this->unit->run("ceci est une chaine", 'is_string', 'Test de chaine');
    $this->unit->run("ceci est une chaine", 'is_null', 'Test de nullite');
    $this->unit->run(5, 'is_int', 'Test de nombre entier');
    echo "<H1>Tests unitaires</H1>";
    echo "<pre>";
    print_r ($this->unit->result());
    echo "</pre>"; 
}

IX-A-5. Résultat brut

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
Tests unitaires 
Array 
(
    [0] => Array
    (
        [Test Name] => Test de chaine 
        [Test Datatype] => String 
        [Expected Datatype] => String 
        [Result] => Passed 
        [File Name] => C:\wamp\www\ci_ecommerce\system\application\controllers\ecommerce.php 
        [Line Number] => 36 
    ) 
    [1] => Array 
    ( 
        [Test Name] => Test de nullite 
        [Test Datatype] => String 
        [Expected Datatype] => Null 
        [Result] => Failed 
        [File Name] => C:\wamp\www\ci_ecommerce\system\application\controllers\ecommerce.php 
        [Line Number] => 37 
    ) 
    [2] => Array 
    ( 
        [Test Name] => Test de nombre entier 
        [Test Datatype] => Integer 
        [Expected Datatype] => int 
        [Result] => Passed 
        [File Name] => C:\wamp\www\ci_ecommerce\system\application\controllers\ecommerce.php 
        [Line Number] => 38 
    ) 
)

IX-B. Internationalisation de votre site

L'une des fonctionnalités la plus difficile et fastidieuse à rattraper dans une application est la mise en place de l'internationalisation de votre application.
L'internationalisation permet de définir une langue pour l'ensemble des messages de votre application aussi bien pour vos erreurs que pour vos titres et labels.
CodeIgniter offre une classe utilitaire et une bibliothèque permettant de réaliser rapidement cette tâche.
Initialisées dès le commencement d'un projet, elles facilitent la maintenance en évitant une passe ou deux complètes sur votre code afin de modifier les vues pour coller au principe de l'internationalisation de CodeIgniter.

IX-B-1. Fichier de traduction

Un fichier de traduction doit être placé dans le répertoire application/language/french/message_lang.php.
Dans le sous-répertoire application/language, il doit y avoir un répertoire par langue traduite.
Chaque fichier de traduction doit être nommé par xxxx_lang.php pour être pris en compte par le framework CodeIgniter.

IX-B-2. Exemple de fichier de traduction

Application/language/french/message_lang.php :

 
Sélectionnez
1.
2.
3.
4.
<?php
    $lang['title']='Titre pour l\'internationnalisation de CodeIgniter';
    $lang['application_name']='Le produit CodeIgniter'; 
?>

Application/language/english/message_lang.php :

 
Sélectionnez
1.
2.
3.
4.
<?php
    $lang['title']='Title for CodeIgniter internationalisation';
    $lang['application_name']='the Framework CodeIgniter'; 
?>

IX-B-3. Méthode d'utilisation de la classe utilitaire Language

  • lang('nom de l élément', 'identifiant du formulaire')
  • lang('nom de l élément')

Cette méthode permet de raccourcir la syntaxe qui ressemble plus à :

 
Sélectionnez
$this->lang->line('page_title')

Pour utiliser ce raccourci de syntaxe, il faut le charger soit dans application/config/autoload.php language dans la partie helper, ou ajouter la ligne suivante au début du contrôleur :

 
Sélectionnez
$this->load->helper('language')

Le choix du langage se fait par appel à la méthode de chargement du bon fichier de traduction :

 
Sélectionnez
$this->lang->load('message', 'french')

IX-B-4. Utilisation de l'internationalisation en français

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
function testInt() {
    $this->load->helper('language');
    $this->lang->load('message', 'english');
    $this->load->view('entete', array('titre'=> lang('title') ) );
    $this->load->view('affichage_brut', array( 'titre' => lang('title'), 'contenu'=> lang('application_name') ) );
    $this->load->view('pied'); 
}

X. Aide et support

Vous trouverez de nombreuses informations en français sur les sites :

Vous pouvez trouver de l'aide sur le forum anglophone de CodeIgniter à l'adresse suivante :

Le forum francophone se trouve à l'adresse suivante :

La documentation de référence http://codeigniter.com/user_guide est entièrement traduite à l'adresse suivante :

L'une des sources la plus complète est le wiki : http://codeigniter.com/wiki et notamment le répertoire CodeIgniter où vous trouverez de nombreuses références vers des sites relatifs à CodeIgniter.

XI. Liens du tutoriel

XII. Remerciements

Nous remercions Winjerome pour la mise au gabarit etMaxy35 pour la correction orthographique.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

Copyright ©. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.