Installation

Nous allons télécharger WampServeur, CodeIgniter et Smarty.

Pour WampServeur, suivez les instructions d’installation.
Pour CodeIgniter et Smarty il suffit de dezipper les fichiers.

Dans WampServeur nous allons créer notre dossier de base de notre site
C:/wamp/www/tutorielwaanser

Intégration de Smarty

Dans le fichier index.php ajouter la constante : WEBSITE_PATH

if (strpos($system_folder, '/') === FALSE) {

if (function_exists('realpath') AND @realpath(dirname(__FILE__)) !== FALSE)
{
$system_folder = realpath(dirname(__FILE__)).'/'.$system_folder;
}
} else {
// Swap directory separators to Unix style for consistency
$system_folder = str_replace("\\", "/", $system_folder);
}

define('WEBSITE_PATH', realpath(dirname(__FILE__)).'/'.$application_folder );

Dans le fichier system/application/config/config.php modifier la variable :

$config['subclass_prefix'] = 'WAANSER_';

Créer les arborescences suivantes :
- system/smarty/libs et copier  les dossiers Internals et plugins de Smarty

system/application/smarty/plugins
system/application/smarty/tpl

system/application/tmp/smarty/cache
system/application/tmp/smarty/templates_c

Renommer le fichier Smarty.class.php en Smarty.php
Copier les fichier Smarty.php, Smarty_Compiler.class.php et Config_File.class.php dans le dossier system/libraries

//  ******* Smarty ********
define('DIR_SEP', DIRECTORY_SEPARATOR);
define('SMARTY_DIR', BASEPATH.'smarty'.DIRECTORY_SEPARATOR);
define('SMARTY_CORE_DIR', BASEPATH.'smarty/libs/internals' . DIRECTORY_SEPARATOR);

define('SMARTY_PHP_PASSTHRU',   0);
define('SMARTY_PHP_QUOTE',      1);
define('SMARTY_PHP_REMOVE',     2);
define('SMARTY_PHP_ALLOW',      3);

Ensuite nous devons créer les libraries WAANSER_controller et WAANSER_smarty dans le dossier system\application\libraries

class WAANSER_Controller extends Controller {

/**
* @desc	for template
* @var 	obj smarty
*/
public $oMySmarty = null;

public function Controller() {

parent::Controller();

$this->loadSmarty();
}

public function loadSmarty() {

$this->oMySmarty = &load_class('Smarty');
}

}

Ce fichier va nous permettre d’étendre le contrôleur d’origine, pour récupérer tous le processus de chargement des classes, et nous ajoutons un attribut $oMySmarty qui sera un objet de la classe Smarty.

Avec cet objet on pourra changer de générateur de template.
On peut, même si c’est moche   utiliser le générateur de templates par défaut en même temps que le générateur Smarty.

class WAANSER_Smarty extends Smarty {

/**
* @desc	class constructor
* @version	1.0.0
* @date	20090307
*/
public function __construct() {

parent::Smarty();
$this->setParams();
}

/**
* @desc 	initialise les variables pour smarty
* @version 1.0.0
* @date	20090307
*/

public function setParams() {
$this->template_dir = APPPATH.'smarty/tpl';
$this->compile_dir = APPPATH.'tmp/smarty/templates_c';
$this->plugins_dir = array(APPPATH.'smarty/libs/plugins', APPPATH.'smarty/plugins');
}

}

?>

Il nous reste a changer le fichier welcome dans le dossier system\application\controllers, il suffit juste de changer l’appel au fichier parent.

class Welcome extends WAANSER_Controller {

function Welcome()
{
parent::Controller();
}

function index()
{
$this->oMySmarty->assign('TEST_WAANSER', 'Smarty est OK');
$this->oMySmarty->display('welcome.tpl');
//$this->load->view('welcome_message');
}
}

Et de lui ajouter une variable avec la methode assign et de lui indiquer le template a afficher avec la methode display.

Ensuite ajouter le fichier welcome.tpl dans le dossier system\application\smarty\tpl

<p>{$TEST_WAANSER}</p>

Au prochain Tuto

Création du formulaire

Pour créer notre formulaire, nous allons faire appel au helper (form).

Un helper est une librairie de code igniter.

Dans le controleur ecoleCtr, nous allons charger la vue ajoutEleve.

    public function __construct()
    {
        parent::__construct();
        $this->load->helper('form');
    }
    public function ajoutEleve()
    {
		$this->load->view('ajoutEleve');
    }

Maintenant dans la vue ajoutEleve nous allons utiliser la commande form_open pour construire le formulaire.

la synthaxe : form_open(méthode du contrôleur où seront envoyées les données du formulaire);

Pour nous ça va être :

<?=form_open('ecoleCtr/insertEleve');?>

<p>nom : <input type="text" name="nom"/></p>
<p>prenom : <input type="text" name="prenom"/></p>
<p><input type="submit" value="envoyer"/></p>

Attention les noms de champs doivent être les même que ceux de la base.
Cela va permettre d’insérer les données dans la base plus facilement.

Envoi et traitement des données

Stocker les données avec Code Ingiter se fait très rapidement

On va utiliser la méthode insert de la librairie db.

    public function insertEleve()
    {
		$this->db->insert('user',$_POST);
    }

Un fois que vous validez votre formulaire si vous tombez sur cette adresse :

http://example.com/index.php/eleveCtr/eleve_insert

C’est que vous avez oublier comme moi de remplir :

$config['base_url']	= "http://localhost/ecole";

dans system-> application -> config -> config.php

Redirection

On va rediriger notre utilisateur à la page où il y a la liste d’élève.

Avec Code Igniter pour faire des redirections on a besoin du helper url

       $this->load->helper('url');

La méthode redirect(chemin,type); s’occupe de la redirection.

Pour nous ça sera :

redirect('/ecoleCtr/listeEleve', 'refresh');

Modification Update avec CI

Maintenant que nous savons insérer des données nous allons apprendre à les modifier

Retournons dans notre vue listeEleve.php

ecole -> system -> application -> views-> listeEleve.php

Pour chaque élève, on va ajouter un lien vers un formulaire pour modifier les informations de cet élève.

Les liens avec anchor

La syntaxe n’est pas compliqué anchor(url,texte)

Donc dans notre exemple nous allons rediriger vers la méthode modifEleve de ecoleCtr;

<td><?=anchor('ecoleCtr/modifEleve/'.$oEleve->id, 'Modifier');?></td>

Rendez vous dans le modèle

ecole -> system -> application -> models -> ecoleMod.php

On va modifier notre fonction :

    public function getEnfant($aRestriction = null)
    {
    	if (is_array($aRestriction))
    	{
	    	foreach ($aRestriction as $sKey => $sValue)
	    	{
	    		$this->db->where($sKey, $sValue);
	    	}
    	}
    	$oEleve=$this->db->get('eleve');
    	return $oEleve->result();
    }

La clause $this->db->where

La clause $this->db->where va nous permettre de créer nos requête de projections.
Le premier paramètre est l’attribut de la table et le second est la valeur.
Par exemple :
$oEleve=$this->db->get(‘eleve’);
$this->db->where(‘nom’, ‘paul’);

donnera SELECT * FROM eleve WHERE nom = paul

On s’est occupé du modèle, on va pouvoir redescendre au contrôleur .
Bon là rien de nouveau :

    public function modifEleve()
    {
    	$this->load->model('ecoleMod');
    	$iIdEleve = $this->uri->segment(3);
		$aEleve = $this->ecoleMod->getEnfant(array('id'=>$iIdEleve));
		$aData['nom'] = $aEleve[0]->nom;
		$aData['prenom'] = $aEleve[0]->prenom;
		$aData['id'] = $aEleve[0]->id;
		$this->load->view('modifEleve',$aData);
    }

Pareil pour la vue modifEleve, on est sur du terrain connu

<html>
<body>
<h1>Modification d'un eleve</h1>

<?=form_open('ecoleCtr/updateEleve/'.$id);?>

<p>nom : <input type="text" name="nom" value ="<?=$nom?>"/></p>
<p>prenom : <input type="text" name="prenom" value ="<?=$prenom?>"/></p>
<p><input type="submit" value="envoyer"/></p>

</body>
</html>

La clause $this->db->update

pour faire un update avec un code igniter on a besoin de la méthodewhere et update.

$this->db->where(attribut,valeur)

Faites bien attention à cette méthode, une erreur et Code Igniter modifie tous les champs de la table.
(et oui ça m’est arrivé ^^)

$this->db->update(table,valeurs)

Notre méthode updateEleve va ressembler à ça :

    public function updateEleve()
    {
    	$this->db->where('id', $this->uri->segment(3));
		$this->db->update('eleve',$_POST);
		 redirect('/ecoleCtr/listeEleve', 'refresh');
    }

Voila ce tutoriel est terminé, votre base de données n’a plus qu’à bien se tenir.

Les préparatifs

Pour illustrer cet article, nous allons créer un site très simple pour une école (avec l’utilisation de Code Igniter).


Comme nous allons manipuler une base de données, je vous invite à créer une base de données école et à exécuter ce script sql. (La structure et les données sont toutes prêtes )


Configuration de Code Igniter pour la connexion à la BDD


Pour configurer la connexion de la base de données, il faut modifier le fichier database.php.
Pour le trouver, suivez le fil d’ariane ci-dessous:

ecole -> system -> application -> config -> database.php

code igniter

ecole : notre racine
systeme : Code Igniter
application : le site web
config : le dossier de configuration


database.php : le fichier de configuration pour la connexion à la base de données

La configuration du fichier est très intuitive. Voilà, ce que j’ai mis :

$db['default']['hostname'] = "localhost";
$db['default']['username'] = "root";
$db['default']['password'] = "";
$db['default']['database'] = "ecole";
$db['default']['dbdriver'] = "mysql";

Le chargement automatique de librairie avec Code igniter

On peut définir les librairies qui vont se charger automatiquement dans nos contrôleurs et vues.
Pour ceci, il faut se tourner vers le fichier autoload.php qui se trouve dans le dossier config.

ecole -> system -> application -> config -> autoload.php

Dans notre exemple, pour manipuler la base de données nous allons nous servir de la librairie database.

$autoload['libraries'] = array('database');

C’est pratique quand on est feignant comme moi .

Si la connexion se passe bien, dans la page d’accueil (pour ma part http://localhost/ecole/) vous devriez voir apparaître:

Si vous voyez un message d’erreur « A Database Error Occurred Unable to connect to your database server using the provided settings. » comme ceci :

C’est que la connexion s’est mal passée.
Il faut que vous vérifiez vos identifiants de connexion, ainsi que le bon fonctionnement de votre serveur de base de données (mysql, postgres …)

Notre premier select avec l’objet DB

Comme nous travaillons dans un environnement MVC, on va traiter nos requêtes dans la partie : Modèle.
Dans le framework Code Igniter, il faut se positionner dans le dossier models et créer un fichier ecoleMod.php
Si vous êtes perdus dans tous ces dossiers, suivez le guide juste en dessous :p

ecole -> system -> application -> models -> ecoleMod.php

Voici la structure type que nous allons adopter pour ecoleMod.php

class ecoleMod extends Model {
    public function __construct()
    {
        parent::__construct();
    }
    //notre fonction
    public function getEnfant()
    {
    }
}

Pour compliquer notre travail, dans un premier temps nous allons faire appel à notre modèle ecoleMod situé dans le contrôleur par défaut : welcome.php.

ecole -> system -> application -> controllers -> welcome.php

Dans index, il suffit de mettre :

function index()
	{
		$this->load->model('ecoleMod');
		$this->ecoleMod->getEnfant();
         }

Pour accéder à notre contrôleur, il suffit d’aller sur http://localhost/ecole.

Voilà, nous pouvons commencer



Pour manipuler la base de données, nous allons utiliser un objet très complet : db. De plus, nous allons voir ensemble les principales méthodes. Attention c’est très compliqué (non je plaisante :p)

Notre première requête

Nous allons faire une fonction qui renvoie la liste d’élève de notre classe.

Il y a 2 méthodes que l’on peut utiliser:

1 – Méthode passe partout.

2 – Méthode propre à la commande SELECT du SQL, qui peut être appliquée selon deux méthodes distinctes.

- Ma méthode passe partout query
La méthode query permet d’exécuter toutes les requêtes. Voici la syntaxe :
$this->db->query(Larequete);
Pour nous cela sera :

$oEleve = $this->db->query('SELECT id, nom, prenom FROM eleve');

- La méthode get propre aux requêtes SELECT.

Si elle n’a pas de restrictions, cette méthode réclame qu’un seul paramètre : le nom de la table
$oEleve=$this->db->get(‘NOM_DE_LA_TABLE‘);
Pour récupérer les élèves, cela donne :

$oEleve=$this->db->get('eleve');

Il est préférable d’utiliser cette commande, parce qu’elle permet de construire les requêtes plus
proprement. Aussi cela peut faciliter la relecture du code.:)


$oEleve, qu’es ce que c’est ?

C’est un objet où sont stockées les informations que la requête renvoie. Si vous avez une base de données mysql, vous aurez un objet du type CI_DB_mysql_result.

result_array();

Pour récupérer les informations de cet objet, nous allons faire appel à la méthode result_array(). Elle renvoie le résultat de la requête sous forme de tableau.

$oEleve=$this->db->get('eleve');
echo "<pre>";
var_dump($oEleve->result_array());
echo "</pre>";

Voici un extrait de résultats que renvoie result_array().

code igniter

result();

Un autre méthode intéressante à voir : result().Elle renvoie le résultat de la requête sous forme de stdclass.

stdclass est une classe native de PHP. On peux affecter toutes sortes de propriété à cette classe passe partout. Pratique

Pour notre exemple, pour récupérer les données vous pouvez utiliser cette boucle :

foreach ($oEleve->result() as $row)
{
	echo $row->id;
	echo $row->nom;
	echo $row->prenom;
}

Au final la fonction getEnfant de notre modèle ecoleMod va donner :

    public function getEnfant()
    {
    	$oEleve=$this->db->get('eleve');
    	return $oEleve->result();
    }

Vous voyez le code est vraiment compliqué !

Du Modèle à la Vue en passant par le Contrôleur

C’est là que nous allons nous motiver pour respecter une structure propre avec Code Igniter.

Nous allons créer notre contrôleur ecoleCtrl dans ce chemin :

ecole -> system -> application -> controllers -> welcome.php

Voici la structure de notre contrôleur :

class ecoleCtr extends Controller {
    public function __construct()
    {
        parent::__construct();
    }
    public function listeEleve()
    {
    }
}

Attaquons nous à notre fonction listeEleve().
Déjà il faut inclure notre modèle ecoleMod : $this->load->model(‘ecoleMod’);
Nous allons faire appel à notre méthode getEnfant() avec :
$aData['aEleve'] = $this->ecoleMod->getEnfant();

Voici notre belle fonction listeEleve

    public function listeEleve()
    {
    	$this->load->model('ecoleMod');
	$aData['aEleve'] = $this->ecoleMod->getEnfant();
    }

Voici le lien de notre contrôleur ; http://localhost/ecole/index.php/ecoleCtr/listeEleve.

La vue

On va pouvoir finaliser les traîtements de nos élèves en les affichant dans notre vue listeEleve.php

ecole -> system -> application -> views-> listeEleve.php

Voici l’arborescence que vous devriez avoir.

code igniter

Nous allons pouvoir traiter notre vue. Il n’y a rien de nouveau ça reste traditionnel.

<html>
<body>
<h1>Bienvenue</h1>
<table>
<tr><th>Id</th><th>Nom</th><th>Prenom</th></tr>
<?php  foreach ($aEleve as $oEleve):	?>
<tr>
	<td><?=$oEleve->id?></td>
	<td><?=$oEleve->nom?></td>
	<td><?=$oEleve->prenom?></td>
</tr>
<?php endforeach;?>
</table>
</body>
</html>

Ce qui va donner :

eh voila le chef d'oeuvre !

A travers toutes ces étapes on a pu voir les principales fonctions qui servent à récupérer les infomations de la base de données. Voici le pack qui continent tout le code source du site ecole.

Installation de smarty dans cake php :

Vous avez bien entendu téléchargé smarty depuis le site officiel ainsi que cake php.

Dans monProjet/vendors, créez le dossier smarty. Dedans, vous y mettrez:

cakephp smarty

Vous trouverez ces fichiers et dossiers dans le package smarty que vous avez téléchargé.

Dans app/views, vous créerez ce fichier smart.php, il contiendra le script suivant :

/**
* Include Smarty. By default expects it at ( VENDORS.'smarty'.DS.'Smarty.class.php' )
*/

/**
* CakePHP Smarty view class
*
* This class will allow using Smarty with CakePHP
*
* @version      1.1.0.0
* @package      cake
* @subpackage   cake.app.views
* @since        CakePHP v 1.2
*/
class SmartyView extends View
{
/**
* SmartyView constructor
*
* @param  $controller instance of calling controller
*/
function __construct (&$controller)
{
parent::__construct($controller);
App::import('Vendor', 'Smarty', array('file' => 'smarty'.DS.'Smarty.class.php'));
$this->Smarty = &new Smarty();
// requires views be in a 'smarty' subdirectory, you can remove this limitation if you aren't using other inherited views that use .tpl as the extension
//$this->subDir = 'smarty'.DS;
$this->ext= '.tpl';
$this->Smarty->plugins_dir[] = VIEWS.'smarty_plugins'.DS;
$this->Smarty->compile_dir = TMP.'smarty'.DS.'compile'.DS;
$this->Smarty->cache_dir = TMP.'smarty'.DS.'cache'.DS;
$this->Smarty->error_reporting = 'E_ALL & ~E_NOTICE';
$this->Smarty->debugging = true;
}

/**
* Overrides the View::_render()
* Sets variables used in CakePHP to Smarty variables
*
* @param string $___viewFn
* @param string $___data_for_view
* @param string $___play_safe
* @param string $loadHelpers
* @return rendered views
*/
function _render($___viewFn, $___data_for_view, $___play_safe = true, $loadHelpers = true)
{
if ($this->helpers != false && $loadHelpers === true)
{
$loadedHelpers =  array();
$loadedHelpers = $this->_loadHelpers($loadedHelpers, $this->helpers);

foreach(array_keys($loadedHelpers) as $helper)
{
$replace = strtolower(substr($helper, 0, 1));
$camelBackedHelper = preg_replace('/\w/', $replace, $helper, 1);

${$camelBackedHelper} =& $loadedHelpers[$helper];
if(isset(${$camelBackedHelper}->helpers) && is_array(${$camelBackedHelper}->helpers))
{
foreach(${$camelBackedHelper}->helpers as $subHelper)
{
${$camelBackedHelper}->{$subHelper} =& $loadedHelpers[$subHelper];
}
}
$this->loaded[$camelBackedHelper] = (${$camelBackedHelper});
$this->Smarty->assign_by_ref($camelBackedHelper, ${$camelBackedHelper});
}
}

$this->register_functions();

foreach($___data_for_view as $data => $value)
{
if(!is_object($data))
{
$this->Smarty->assign($data, $value);
}
}
$this->Smarty->assign_by_ref('view', $this);
return $this->Smarty->fetch($___viewFn);
}

/**
* Returns layout filename for this template as a string.
*
* @return string Filename for layout file (.ctp).
* @access private
*/
function _getLayoutFileName() {
if (isset($this->webservices) && !is_null($this->webservices)) {
$type = strtolower($this->webservices) . DS;
} else {
$type = null;
}

if (isset($this->plugin) && !is_null($this->plugin)) {
if (file_exists(APP . 'plugins' . DS . $this->plugin . DS . 'views' . DS . 'layouts' . DS . $this->layout . $this->ext)) {
$layoutFileName = APP . 'plugins' . DS . $this->plugin . DS . 'views' . DS . 'layouts' . DS . $this->layout . $this->ext;
return $layoutFileName;
}
}
$paths = Configure::getInstance();

foreach($paths->viewPaths as $path) {
if (file_exists($path . 'layouts' . DS . $this->subDir . $type . $this->layout . $this->ext)) {
$layoutFileName = $path . 'layouts' . DS . $this->subDir . $type . $this->layout . $this->ext;
return $layoutFileName;
}
}

// added for .ctp viewPath fallback
foreach($paths->viewPaths as $path) {
if (file_exists($path . 'layouts' . DS  . $type . $this->layout . '.ctp')) {
$layoutFileName = $path . 'layouts' . DS . $type . $this->layout . '.ctp';
return $layoutFileName;
}
}

if($layoutFileName = fileExistsInPath(LIBS . 'view' . DS . 'templates' . DS . 'layouts' . DS . $type . $this->layout . '.ctp')) {
} else {
$layoutFileName = LAYOUTS . $type . $this->layout.$this->ext;
}
return $layoutFileName;
}

/**
* Returns filename of given action's template file (.tpl) as a string.
* CamelCased action names will be under_scored! This means that you can have
* LongActionNames that refer to long_action_names.ctp views.
*
* @param string $action Controller action to find template filename for
* @return string Template filename
* @access protected
*/
function _getViewFileName($name = null) {
$subDir = null;

if (!is_null($this->webservices)) {
$subDir = strtolower($this->webservices) . DS;
}
if (!is_null($this->subDir)) {
$subDir = $this->subDir . DS;
}

if ($name === null) {
$name = $this->action;
}

if (strpos($name, '/') === false && strpos($name, '..') === false) {
$name = $this->viewPath . DS . $subDir . Inflector::underscore($name);
} elseif (strpos($name, '/') !== false) {
if ($name{0} === '/') {
if (is_file($name)) {
return $name;
}
$name = trim($name, '/');
} else {
$name = $this->viewPath . DS . $subDir . $name;
}
if (DS !== '/') {
$name = implode(DS, explode('/', $name));
}
} elseif (strpos($name, '..') !== false) {
$name = explode('/', $name);
$i = array_search('..', $name);
unset($name[$i - 1]);
unset($name[$i]);
$name = '..' . DS . implode(DS, $name);
}

$paths = $this->_paths($this->plugin);
foreach ($paths as $path) {
if (file_exists($path . $name . $this->ext)) {
return $path . $name . $this->ext;
} elseif (file_exists($path . $name . '.ctp')) {
return $path . $name . '.ctp';
} elseif (file_exists($path . $name . '.thtml')) {
return $path . $name . '.thtml';
}
}

return $this->_missingView($paths[0] . $name . $this->ext, 'missingView');
}

/**
* checks for existence of special method on loaded helpers, invoking it if it exists
* this allows helpers to register smarty functions, modifiers, blocks, etc.
*/
function register_functions() {
foreach(array_keys($this->loaded) as $helper) {

if (method_exists($this->loaded[$helper], '_register_smarty_functions')) {
$this->loaded[$helper]->_register_smarty_functions($this->Smarty);
}
}
}
}

Vous créerez aussi app_controller.php dans app/controllers, il contiendra :

class AppController extends Controller {

//pour utliser smarty en moteur de templates
var $view = 'Smarty';
}

Configuration Smarty

Les fichiers venant d’être créés vous servirons à configurer smarty et utiliser smarty pour les vues (templates).

Utilisation :
les lignes qui suivent servent à configurer smarty :

$this->ext= '.tpl';
$this->Smarty->plugins_dir[] = VIEWS.'smarty_plugins'.DS;
$this->Smarty->compile_dir = TMP.'smarty'.DS.'compile'.DS;
$this->Smarty->cache_dir = TMP.'smarty'.DS.'cache'.DS;
$this->Smarty->error_reporting = 'E_ALL & ~E_NOTICE';
$this->Smarty->debugging = true;

Vous configurez ainsi :

• le chemin des plugins smarty
• le chemin des fichiers compilés
• le chemin de cache smarty

Vous devez créer les dossier smarty_plugins, compile (/app/tmp/smarty/compile) et cache (/app/tmp/smarty/cache) dans les répertoires correspondant aux différents chemins que vous aurez choisi.

Vous avez aussi configuré le débuggage et le système d’erreur smarty.

Dans l’exemple vu dans l’installation et l’utilisation de cake php, nous avons vu comment créer une page.

La méthode ne change pas, et la méthode d’assignation non plus.

Vous devez simplement créer les templates avec l’extension sélectionnée pour paramétrer smarty et dans le template, vous devez utiliser la syntaxe de smarty pour l’affichage.

Vous devez créer mapage.tpl et utiliser une syntaxe de ce type {$sMaVariableVue}
non pas echo $sMaVariableVue;

CakePHP : Qu’est ce que c’est ?

CakePHP est un framework PHP gratuit, Open Source et reposant sur le modèle MVC. Il dispose de différents outils pour développer rapidement vos applications PHP, sans avoir à réinventer la roue pour chacune d’entre elles.

Installation de CakePHP :

Pour installer CakePHP, allez sur le site de CakePHP et téléchargez la dernière version.

cakephp

Décompresser, le dossier téléchargé dans votre répertoire web. Dans WampServer, il faut placer les différents éléments dans le répertoire www/monProjet/.

Votre projet sera accessible à l’adresse http://localhost/monProjet/ et affichera l’écran suivant :

Vous vous demandez qu’est c’est que tout ça et comment faire. C’est ce que l’on va voir.

Cake PHP vous demande de changer la valeur du paramètre « Security.salt », cette valeur correspond au grain de sel, un paramètre pour améliorer la sécurité.
Il vous demande aussi de configurer le fichier de base de données.
Pour éditer la page, il vous demande de créer home.ctp et default.ctp.

Organisation et configuration de cakePHP

CakePHP est organisé de la manière suivante :

• Le dossier app : contiendra les fichiers de votre application.
• Le dossier cake : contient les fichiers propres de cakePHP, c’est le noyau du système. Il n’est pas conseillé de les modifier.
• Le dossier vendors : contiendra les plugins de cakePHP.

Pour configurer cakePHP, il faudra modifier certains fichiers présents dans le dossier app. Les fichiers de configuration sont dans app/config.
Pour Modifier le paramètre « Security.salt », il faut modifier le fichier core.php, à la ligne suivante :

Ligne 151 : Configure::write(‘Security.salt’, ‘DyhG93b0qyJfIxfs2guVoUubWwvniR2G0FgaC9mi’);

Il est suffisant de modifier certaines lettres ou chiffres au hasard de la chaine incompréhensible suivante « DyhG93b0qyJfIxfs2guVoUubWwvniR2G0FgaC9mi ».

cakephp

Pour configurer la connection à la base de données, il faut renommer le fichier suivant « database.php.default » en « database.php » et modifier les lignes suivantes :
Lignes 81 à 89 :

var $default = array(
'driver' => 'mysql',
'persistent' => false,
'host' => 'localhost',
'login' => 'user',
'password' => 'password',
'database' => 'database_name',
'prefix' => '',
);

CakePHP vous demande de créer ces fichiers « home.ctp » et « default.ctp ». Ces Fichiers sont les vues utilisées par cakePHP, ils affichent donc vos page web. Ils faut créer le fichier « home.ctp » dans app/views/pages et « default.ctp » dans app/views/layouts.

Votre navigateur vous affiche maintenant une page blanche.

Ajouter du contenu

Organisation des vues :
layouts : contenant des pages, son contenu sera :

<html>
<head>
<title>Ma page</title>
</head>
<body>
<?php echo $content_for_layout; ?>

</body>
</html>

pages : contenu de votre page

Donc dans default.ctp vous aurez la structure html globale de votre page et dans home.ctp vous aurez votre page d’accueil de votre site.
Les fichiers ctp ont du contenu mêlant php et html. Pour le php, on fait juste de l’affichage de variables assignées dans le controller ou appel à des fonctions d’affichage. Je vous le concède, ce n’est pas super.

Gestion du contenu :

Pour le moment, il n’y a pas d’assignations de faites, le contenu n’est pas dynamique. Il faut les faire dans le controller. Les vues contenues dans pages sont gérées par le fichier pages_controller.php.
Les fichiers controller sont des classes qui étendent la classe AppController.
Pour avoir du contenu dynamique dans le dossier pages de views, il faut modifier le fichier routes.php dans app/config. Ce fichier définit la home page de votre site (son controller, sa méthode et la vue) et définit le controller et la méthode à utiliser pour un dossier donné dans views.

Nous allons commenter la ligne suivante :
Router::connect(‘/pages/*’, array(‘controller’ => ‘pages’, ‘action’ => ‘display’));

Dans views le dossier contenant votre page est pages, votre controller sera donc pages_controller.php et la classe sera PagesController

class PagesController extends AppController {

/**
* définir le nom du contrôleur
*
* @var string
* @access public
*/
var $name = 'Pages';

/**
* les assistants peuvent vous aider à créer des formulaires, des fonctionnalités
* AJAX, de paginer les données du modèle ou à délivrer des flux RSS
*
* @var array
* @access public
*/
var $helpers = array('Html');

/**
* modèle à utliser
*
* @var array
* @access public
*/
var $uses = array();

function display() {
$path = func_get_args();

$count = count($path);
if (!$count) {
$this->redirect('/');
}
$page = $subpage = $title = null;

if ( !is_null($path[0])) {
$page = $path[0];
}
if (!is_null($path[1])) {
$subpage = $path[1];

if ( !is_null($path[$count - 1])) {
$title = Inflector::humanize($path[$count - 1]);
}
$this->set(compact('page', 'subpage', 'title'));
$this->render(join('/', $path));
}
function mapage() {

//votre traitement
$sMavariable = 'Voici ma page';
//Mon assignation
$this->set('sMaVariableVue',$sMavariable);
}
}

Votre variable sera assignée dans la view de même nom que la méthode c’est à dire dans mapage.ctp
Votre fichier views/pages/mapage.ctp sera :

<?php echo $sTitrePage; ?>

Bien sûr, vous pouvez utiliser du code html pour afficher votre contenu.
Voilà votre première page est créée, si vous avez des questions n’hésitez pas à poster un commentaire

Pour commencer, il faut télécharger CodeIgniter sur le site www.CodeIgniter.com.

Normalement vous avez un fichier compressé CodeIgniter_xx.xx.xx.zip.

L’installation Code Igniter

Et voila ce que votre navigateur doit afficher :

code igniter installation

Super tout fonctionne !

L’ arborescence

On va aller sur le dossier www pour voir l’arborescence de votre site. La racine de l’arborescence de Code Igniter soit rassembler à cela :

arborescence code igniter

Nous allons nous intéresser au dossier system.

arborescence code igniter system

Maintenant nous allons sur le dossier application. C’est ici que nous allons développer notre site web.

arborescence code igniter scenario

Il y a deux dossiers importants :
- controllers où sont stockés les contrôleurs
- views où sont stockées les vues

La Base de Code Igniter

On va commencer par construire une page d’accueil toute banale.

Il faut aller dans ce fameux dossier controllers pour créer notre premier contrôleur.
Nommons le accueil.php. (le nom du contrôleur doit être en minuscule)

Un contrôleur est une simple classe php.

Le nom du contrôleur doit systématiquement commencer par une majuscule. Ce contrôleur(accueil.php) doit aussi hériter de la classe mère de Code Igniter qui est Controller. Cela sert à charger toute les fonctions de Code Igniter.

Dans acceuil.php, nous allons créer une fonction index qui va afficher un message.

class Accueil extends Controller {

function index(){
echo "Salut, cela fonctionne bien ";
}
}

Allons voir si ce code marche.:) Pour cela, rien de plus simple, il suffit d’ouvrir le navigateur et de saisir l’adresse suivante :
http://localhost/monsite/index.php/accueil/index

Composition de l’url de Code Igniter

Pour trouver l’adresse url de notre fonction.

Bon la on a triché un peu . On a affiché un message a partir du contrôleur, alors que l’affichage des données doit être le rôle de la vue (views pour CI)…

La vue de Code Igniter

Donc nous allons dans le dossier views du dossier application.
Nous allons créer notre vue « accueil_view.php ».

Voila l’arborescence que l’on doit avoir :

arborescence code igniter

Personne ne s’est trompé de dossier ?
On peu continuer.

Le rôle de notre vue accueil_view.php c’est d’afficher la page d’accueil.
Nous allons donc coder une page html toute basic

<html>
<head><title>Accueil<title></head>
<body><h1>Bienvenue !</h1></body>
</html>

Le contrôleur de Code Igniter

Maintenant faut indiquer à notre contrôleur, le chemin de notre vue pour qu’il fasse appel à elle.
On retourne donc dans notre contrôleur accueil.
On va utiliser cette commande :
$this->load->view([nom de la vue]);

Donc vous l’avez deviné ! Nous on faire écrire :
$this->load->view(« accueil_view.php »);

class Accueil extends Controller {

function index(){

$this->load->view("accueil_view.php");
}

}

En plus que faire appel à la vue, notre contrôleur va définir l’entête de la page et son titre. Pour cela rien de plus simple : On met les données nécessaires dans un tableau associatif (on va le nommer $aTableau),

Pour l’entête :
$aTableau['entete']=’Accueil’;

Pour le titre :
$aTableau['titre']=’Bienvenue’;

C’est-à-dire :
Au lieu de faire cette appel
$this->load->view(« accueil_view.php »);
On fait ceele-ci
$this->load->view(« accueil_view.php »,$aTableau);

class Accueil extends Controller {
function index(){
$aTableau['sEntete']='Accueil';
$aTableau['sTitre']='Bienvenue';
$this->load->view("accueil_view.php",$aTableau);
}
}

Maintenant que le contrôleur envoie les données à la vue.
La vue va faire son boulot à son tour.
C’est-à-dire elle va l’afficher !

Pour cela on remplace le texte par les balises php.

<html>
<head><title><?php echo $sEntete ?><title></head>
<body><h1><?php echo $sTitre ?></h1></body>
</html>

On utilise la commande traditionnelle echo pour afficher texte.
Et pour choisir la donnée à affichée on récupère la clé du tableau associatif et on ajoute un $. (comme une variable php).

Normalement notre page reste la même.

L’affichage de tableau dans Code Igniter

Maintenant on va afficher un tableau dans notre page d’accueil.
Pour cela il faut créer notre tableau dans le contrôleur. ( dans cet exmeple, on va dire que l’on va lister un groupe d’amis.)

$aTableau['aListeAmis']=array('Jean','Sophie','Pascal','Agnes');

Maintenant on va afficher la liste de nos amis sur la vue. Pour cela on utilisera la commande foreach.

<?php foreach($aListeAmis as $sAmi): ?>
<?php echo $sAmi ?>
<br />
<?php endforeach; ?>

Tout le monde a bien suivit ?

La gestion d’url par Code Igniter

On va attaquer un autre élément important présent dans tous les sites web ; les liens hypertext.

Comme vous pouvez l’imaginez CI utilise une librairie pour manipuler ces liens. Pour cela, il a besoin qu’on lui indique la racine url de notre site (http://localhost/monsite). Il faut aller dans les fichiers de configurations de Code Igniter. On sa donc faire un saut dans le dossier application pour aller dans le dossier config et enfin ouvrir le fichier config.php.

arborescence code igniter config

Vous avez bien suivit le plan ?

Comme vous le constatez, les paramètres de configuration de CI sont stockés dans un tableau associatif. Normalement au début du fichier php vous devez voir une variable $config['base_url'].
C’est ici que l’on va définir le chemin de notre site web.

Par défaut :
$config['base_url'] = « http://127.0.0.1/CodeIgniter/ »;

Nous allons remplacer par :
$config['base_url'] = « http://localhost/monsite »;

Voila, notre code igniter est configuré pour manipuler les liens

On va retourner dans notre contrôleur.

Comme on utilise la librairie qui manipule les urls, il faut la charger.

La commande pour charger la librairie c’est :

$this->load->helper(‘url’);

Comme on a fait une seul page, on va rediriger notre lien sur cette même page.
Nous allons utiliser la commande anchor.
Voici le code :

La commande anchor à besoin de deux paramètre :
1. l’adresse du lien
2. le texte du lien

Pour alléger la vue

Pour l’affichage, on peut remplacer le traditionnel <?php echo $sAmi ?>
Par <?=$sAmi?>

Ce qui donne au final :

<html>
<head><title><?=$sEntete?><title></head>
<body>
<h1><?=$sTitre?></h1>
<br/>
<?php foreach($aListeAmis as $sAmi):?>
<?=$sAmi?>
<br />
<?php endforeach;?>
<?=anchor('accueil/index','lien');?>
</body>
</html>