Tutoriel de présentation du framework CodeIgniter

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.

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.

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 :

Options -indexes

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.

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.

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

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.

Options -indexes
RewriteEngine on
RewriteCond $1 !^(index\.php|css|js|images|robots\.txt|favicon\.ico|$)
RewriteRule ^(.*)$ index.php/$1 [L]

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

• http://www.monsite.com/ ;
• http://www.monsite.com/index.php ;
• http://www.monsite.com/index.

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

<?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 :

$this->load->view('hello_message');

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

<html>
    <head>
        <title>HELLO World</title>
    </head>
    <body>
        <h1>Hello World</h1>
    </body>
</html>

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

• http://www.monsite.com/hello ;
• http://www.monsite.com/hello/ ;
• http://www.monsite.com/hello/hello ;
• http://www.monsite.com/hello/index.

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

Une classe utilitaire est une classe contenant des fonctions utilitaires pour un domaine particulier de la programmation en PHP et avec 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.

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 :

$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 :

$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.

$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.

$this->load->database('autreconfig');

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

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 :

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

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.

$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.

$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();

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.

$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.

$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();

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

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()

• récupération de tous les articles :

$query=$this->db->get('ARTICLE');

• récupération du premier article de la base :

$this->db->select('LABEL')->from('ARTICLE')->limit(1);

$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 :

$this->db->select('LABEL')->from('ARTICLE')->where('PRIXHT <', 100)->order_by('PRIXHT', 'ASC')->limit(10);
$query = $this->db->get();

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

• $this->db->insert()
• $this->db->set()

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()

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

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()

• $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()

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 :

<?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>';
        }
    } 
} 
?>

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.

<?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);
    } 
} 
?>

• $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()

Uploader un fichier :

$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 :

$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 :

$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();

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

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

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.

<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>

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é.

<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>

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().

<?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'); }
    } 
} 
?>

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.

$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);

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

$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.

• http://www.monsite.com/journals
• http://www.monsite.com/journals/
• http://www.monsite.com/journals/index
• http://www.monsite.com/journals/toto
• http://www.monsite.com/products/34
• http://www.monsite.com/products/5

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

function _remap($method) {
    if ($method == 'methode_inconnue') {
        $this->$index();
    } else {
        $this->default_method();
    }
}

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.

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

                    $ php ci_call.php ecommerce index

…

                    $ php ci_call.php xmlrpc_client ping

…

$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.

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

<?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 :

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

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 :

$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 :

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.

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

• $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.

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.

Application/language/french/message_lang.php :

<?php
    $lang['title']='Titre pour l\'internationnalisation de CodeIgniter';
    $lang['application_name']='Le produit CodeIgniter'; 
?>

Application/language/english/message_lang.php :

<?php
    $lang['title']='Title for CodeIgniter internationalisation';
    $lang['application_name']='the Framework CodeIgniter'; 
?>

• 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 à :

$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 :

$this->load->helper('language')

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

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