Attention, l'article est un chouilla trop long (beaucoup de lignes de code).

Mes fonctions de CRUD

Ajouter un enregistrement dans une table

/***
 *	insert des données dans la table en paramètre
 *	@datas	tableau des données à insérer dont la clé et le nom du champs dans la table
 *	@table	table dans laquelle insérer les données
 */
function add($datas, $table){
	$bdd = db(); //on ouvre la connexion à la base de données
	foreach($datas as $key => $value){
		$keys[] = $key;
		$values[] = $value;
	}
	$strSQL = "INSERT INTO ".$table." (";
	foreach($keys as $ky => $k){ $strSQL .= $k . ","; }
	$strSQL = substr($strSQL,0,-1) . ") VALUES(";
	foreach($values as $vl => $v){ $strSQL .= "?,"; }
	$strSQL = substr($strSQL,0,-1) . ")";
	$query = $bdd->prepare($strSQL);
	if($query->execute($values)) return $bdd->lastInsertId();
	else return false;
}

$datas = array(
	'nom' => $nom,
	'email' => $email,
	'commentaire' => $commentaire
);
if(add($datas,'comments')) {
	return "cool";
} else return "pas cool";

Mettre à jour les informations d'un enregistrement

/***
 *	met à jour les données de l'ID dans la table en paramètre
 *	@id	identifiant de la ligne à modifier
 *	@datas 	tableau des données à insérer dont la clé et le nom du champs dans la table
 *	@table 	table dans laquelle insérer les données
 */
function update($id, $datas, $table){
	$bdd = db();
	foreach($datas as $key => $value){
		$keys[] = $key;
		$values[] = $value;
	}
	$strSQL = "UPDATE ".$table." SET ";
	foreach($datas as $key => $value){
		$strSQL .= $key . " = ?,";
	} $strSQL = substr($strSQL,0,-1) . " WHERE id = ?";
	$values[] = $id;
	$query = $bdd->prepare($strSQL);
	if($query->execute($values)) return true;
	else return false;
}

Supprimer un enregistrement

/***
 *	supprime les données correspondant à l'ID dans la table en paramètre
 *	@id		identifiant de la ligne à supprimer
 *	@table	table sur laquelle on applique la suppression
 */
function delete($id, $table){
	$bdd = db();
	$strSQL = "DELETE FROM ".$table." WHERE id = ?";
	$query = $bdd->prepare($strSQL);
	//print_r(array($id));
	if($query->execute(array($id))) return true;
	else return false;
}

Retourner une liste d'enregistrements

/***
 * 	retourne le resultat d'un select
 *	@columns 	colonnes à selectionner pour la requête (ex: array('champ1','champ2') ou '*')
 *	@table 		nom de la table sur laquelle faire la requête
 *	@where 		champs sur lequels appliquer des conditions ( ex: array( 'champ1 =' => 'valeur', 'champ2 LIKE' => 'valeur%') )
 *	@concats 	[ AND | OR ]
 *	@order 		champs sur lequels appliquer le tri, et l'ordre pour chaque champs (ex: array('champ1' => 'ASC','champ2' => 'DESC') )
 *	@limit 		limit[0] => debut de la liste, limit[1] => nombre d'éléments dans la liste retournée (ex: array('0','20') )
 *
 *	return @retour	: tableau contenant la requête executée, les éventuelles erreurs et le resultat de la requête
 */
function get($columns = null, $table = null, $where = null, $concats = "AND", $order = null, $limit = null){
	$bdd = db();
	$retour = array(); //variable de type tableau, retournée par la fonction
	$rows = "";
	$clause = "";
	$sort = "";
	$limitStr = "";
	if(!is_null($columns) && !is_null($table)){
		// si $rows est un tableau ou égale à * tout va bien.
		if(is_array($columns)){
			foreach($columns as $column) { $rows .= $column .', '; }
			$rows = substr($rows,0,-2);
		} elseif($columns == '*'){
			$rows = '*';
		} else {
			$retour['erreur'] = "Les champs selectionné doivent être appelé depuis une variable Tableau";
		}
		if(!in_array(strtolower($concats),array('and','or'))){
			$retour['erreur'] = "<strong>".$concats."</strong> n'est pas une valeur autorisée pour concaténer des conditions. Utilisez 'OR' ou 'AND'.";
		}
		/*
		si @where est renseigné, on filtre les résultats grâce au tableau @where construit comme suit :
			array ('colname operateur' => 'valeur');
			ex: array('page_id =' => 5);
		sinon, on ne filtre pas les résultats
		*/
		if(!is_null($where) && is_array($where)){
			foreach($where as $k => $v){
				$clause .= $k." ? ".$concats." ";
				$values[] = $v;
			}
			$clause = " WHERE ".substr($clause,0,(-(strlen($concats)+2)));
		} elseif(!is_null($where) && !is_array($where)){
			$retour['erreur'] = "La clause WHERE doit être construite via une variable Tableau";
		} else {
			$clause = "";
		}
		//si $order est un tableau et n'est pas null
		if(!is_null($order) && is_array($order)){
			foreach($order as $k => $v){ $sort .= $k." ".$v.", "; }
			$sort = " ORDER BY ".substr($sort,0,-2);
		} elseif(!is_null($order) && !is_array($order)) {
			$retour['erreur'] = "ORDER BY doit être construit via une variable Tableau";
		} else {
			$sort = "";
		}
		if(!is_null($limit) && is_array($limit) && is_numeric($limit[0]) && is_numeric($limit[1])){
			$debut = $limit[0];
			$nbRows = $limit[1];
			$limitStr = " LIMIT " . $debut . "," . $nbRows;
		} elseif(!is_null($limit) && !is_array($limit)){
			$retour['erreur'] = "LIMIT doit être construit via un tableau de deux entiers";
		} else {
			$limitStr = "";
		}
		// on construit la requête
		$strSQL = "SELECT ".$rows." FROM ".$table.$clause.$sort.$limitStr;
		if(empty($retour['erreur'])){
			$query = $bdd->prepare($strSQL);
			$query->execute(@$values);
			$retour['requete'] = $strSQL;
			$retour['reponse'] = $query->fetchAll(PDO::FETCH_ASSOC);
			$sqlTotal = "SELECT COUNT(*) as total FROM ".$table.$clause.$sort;
			$q = $bdd->prepare($sqlTotal);
			$q->execute(@$values);
			$tot = $q->fetchAll(PDO::FETCH_ASSOC);
			$retour['total'] = $tot[0]['total'];
		}
	} else {
		$retour['erreur'] = "Impossible de créer la requete, les champs à selectionner et la table sont vide";
	}
	return $retour;
}

$champs = array('id','titre','nom','contenu');
$conditions = array(
	'nom =' => 'nighcrawl',
	'date < =' => date('Y-m-d H:i:s'),
	'titre LIKE' => '%framework%'
);
$trier = array('date' => 'DESC');
$limite = array(0, 5);
$resultat = get($champs,'articles',$conditions,"AND",$trier,$limite);
if(isset($resultat['reponse'])){
	foreach($resultat['reponse'] as $row){
		echo "<article>
		<header>
			<h1>".$row['titre']."</h1>
		</header>
		<div>".$row['contenu']."</div>
		<footer>Auteur : ".$row['nom']."</footer>
		</article>";
	}
}
else echo $resultat['erreur'];

Mettre en place un système de pagination

/***
 *	génère des liens de pagination : numeros de pages, 'suivants', 'précédents'
 *	@total	nombre total d'enregistremnts à paginer
 *	@nbpp	nombre d'enregistrements à afficher par page
 *	@link	chaine qui servira à construire les liens vers les différentes pages
 */
function pagination($total, $nbpp, $link){
	echo"<div class='pagination'>";
		/** Pagination **/
		//calcul du nombre de pages
		$nbLiens = ceil($total/$nbpp);
		if($nbLiens > 1){
			/** précédents **/
			if(isset($_GET['d']) && $_GET['d'] > 0){
				echo "<a href='".$link.($_GET['d']-$nbpp)."'>« Précédents</a>";
			} else {
				echo "<span>« Précédents</span>";
			}
			/** pages ***/
			for($i = 0; $i < $nbLiens; $i++){
				if($_GET['d'] == ($i*$nbpp)){
					echo "<span class='active_pagi'>".($i+1)."";
				} else {
					echo "<a href='".$link.($i*$nbpp)."'>".($i+1)."</a>";
				}
			}
			/** suivants **/
			if(isset($_GET['d']) && $_GET['d'] >= 0 && $_GET['d'] < ($total-$nbpp)){
				echo "<a href='".$link.($_GET['d']+$nbpp)."'>Suivants »</a>";
			} else {
				echo "<span>Suivants »</span>";
			}
		}
	echo "</div>";
}

$nbpp = 5; //5 articles par page
$limite = array(intval($_GET['d']),$nbpp);
$resultat = get($champs,'articles',$conditions,"AND",$trier,$limite);
if(isset($resultat['reponse'])){
	foreach ($resultat as $row) {
		//affichage des articles
		...
	}
	pagination($resultat['total'],$nbpp,'index.php?parametre=valeur&d=');
} else echo $resultat['erreur'];

Fin !

PHP se suffit à lui-même pour effectuer du templating, en déclarant toutes les variables dans un fichiers de traitement, et en les appelant dans un fichier d’affichage inclus à la fin du traitement. Pourquoi les développeurs utilisent-ils alors une surcouche ?

Mauvaises excuses

J’ai souvent entendu « pour que celui qui s’occupe de l’affichage n’aie pas besoin de connaissances en PHP » ou « pour appliquer simplement un cache par fichier « parsé » (inclus et interprété) ».

Effectivement la plupart de ces moteurs recréent une syntaxe simplifiée qui raccourcis le temps de codage et permettent une meilleur lisibilité du code telle que :

{variable}

au lieu de :

<?php echo $variable; ?>

La faiblesse d’un tel procédé

« Parser », c’est consommer. Pour pouvoir interpréter correctement la syntaxe il faut utiliser des procédés de réécriture qui pèsent au chargement. Heureusement, lorsque le script est bien conçu, on n’effectue cette réécriture (compilation) qu’une seule fois après chaque modification du fichier template. Cela dit pour celui sur qui ça tombe, un mauvais « parseur » peut entraîner un lourd ralentissement pour une simple page.

Les programmeurs aimant bien s’inventer leur propre syntaxe et l’optimiser pour leur utilisation, ils sont parfois trop gourmands et confèrent à celle-ci bien plus de portée qu’elle ne devrait en posséder.

En effet certains ont tendance à vouloir appliquer des fonctions (date(), htmlspecialchars_decode(), nl2br()) au moment de l’appel de la variable. Hors il s’agit de traitement, et le traitement des données doit s’effectuer avant l’affichage.

Plus la syntaxe est développée, moins elle a d’intérêt, puisque son seul but est de diminuer le temps de codage et de gagner en lisibilité. J’ai souvent vu des moteurs utiliser une syntaxe XML telle que :

<foreach nom="nom_du_bloc">
    <var nom="variable" />
</foreach>

qui possède un rapport performance/confort relativement faible par rapport à la syntaxe native :

<?php foreach ($nom_du_bloc as $row) : ?>
    <?php echo $row['variable']; ?>
<?php endforeach; ?>

A noter que la syntaxe PHP permet bien plus de souplesse dans la déclaration d’une boucle (concaténation, et « variable double » ($$variable) autorisées).

De plus, le cache peut être totalement indépendant. Il n’est donc pas nécessaire de passer par un moteur de templates pour pouvoir en appliquer un.

Les bonnes pratiques

On utilise un tel outil pour séparer le traitement de l’affichage, et optionnellement pour minimiser son code et le rendre plus clair.

Plusieurs approches sont alors pertinentes face à la question des performances. C’est certain, regrouper ses variables dans une « boîte noire », loin des variables servant uniquement au traitement, est dans une certaine mesure très agréable. Mais avant de se jeter sur un moteur de templates, rélféchissez à quelle quantité de performance vous êtes prêt à céder.

Un moteur sans syntaxe personnalisée

C’est la solution la moins onéreuse. Le fameux framework CodeIgniter y a établi son camp. Pour gagner en confort, il est conseillé de trouver une solution pour séparer ses variables d’affichage à celles de traitement. L’une d’entre elles est de stocker ses variables dans un objet et inclure le fichier template dans une méthode en utilisant la fonction extract().

Un moteur à syntaxe

Prudence. Assurez-vous d’avoir une syntaxe suffisamment légère, et peu de fonctionnalités. Un moteur mettant à disposition l’appel de fonctions dans sa syntaxe doit être scrupuleusement analysé avant d’être employé. Le minimum nécessaire ? Appel de variables, boucles (appel de blocs) et conditions. Vérifiez que preg_replace(), preg_replace_callback() et preg_match_all() sont utilisées avec parcimonie car ils consomment des quantités astronomiques de performances.

Conclusion

Je ne me veux pas exhaustif sinon préventif quant à l’optimisation des performances. Avouez qu’écrire autant de code aussi complexe et moins souple que PHP pour perdre en performance est dénué de sens. Il est préconisé de chercher l’équilibre entre la performance et le confort, et enfin de garder en tête que le traitement n’est pas du ressort de l’affichage.

Dans un SELECT

SELECT 'fofo' REGEXP '^fo' FROM table;

Dans une clause WHERE

SELECT champ FROM table WHERE champ REGEXP '^([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})$' AND champ2 REGEXP '(chouette|cool|super)'

function generatePwd(){
	$chars = "azertyuiopqsdfghjklmwxcvbn0123456789";
	$lenght = strlen($chars);
	$chars = str_split($chars,1);
	$pwd = "";
	for($i=0;$i<9;$i++){
		shuffle($chars);
		$pwd .= $chars[rand(0,($lenght-1))];
	}
	return $pwd;
}

Configurer la classe Database

$dbconf['default']['hostname'] = "localhost";
$dbconf['default']['username'] = "root";
$dbconf['default']['password'] = "";
$dbconf['default']['database'] = "database_name";
$dbconf['default']['dbdriver'] = "mysql";
$dbconf['default']['dbprefix'] = "";
$dbconf['default']['pconnect'] = TRUE;
$dbconf['default']['db_debug'] = FALSE;
$dbconf['default']['cache_on'] = FALSE;
$dbconf['default']['cachedir'] = "";
$dbconf['default']['char_set'] = "utf8";
$dbconf['default']['dbcollat'] = "utf8_general_ci";

//config par défaut
$db['default']['hostname'] = "localhost";
$dbconf['default']['username'] = "root";
$dbconf['default']['password'] = "";
$dbconf['default']['database'] = "database_name";
$dbconf['default']['dbdriver'] = "mysql";
$dbconf['default']['dbprefix'] = "";
$dbconf['default']['pconnect'] = TRUE;
$dbconf['default']['db_debug'] = FALSE;
$dbconf['default']['cache_on'] = FALSE;
$dbconf['default']['cachedir'] = "";
$dbconf['default']['char_set'] = "utf8";
$dbconf['default']['dbcollat'] = "utf8_general_ci";
//config secondaire
$dbconf['test']['hostname'] = "host_name";
$dbconf['test']['username'] = "db_user";
$dbconf['test']['password'] = "db_pass";
$dbconf['test']['database'] = "database_name";
$dbconf['test']['dbdriver'] = "mysql";
$dbconf['test']['dbprefix'] = "";
$dbconf['test']['pconnect'] = TRUE;
$dbconf['test']['db_debug'] = FALSE;
$dbconf['test']['cache_on'] = FALSE;
$dbconf['test']['cachedir'] = "";
$dbconf['test']['char_set'] = "utf8";
$dbconf['test']['dbcollat'] = "utf8_general_ci";

$this->load->database($dbconf);

$db1 = $this->load->database('default');
$db2 = $this->load->database('test');

Ma première requête SQL avec CodeIgniter

mysql_query() à la sauce CI

$sql = "SELECT * FROM some_table WHERE id = ? AND status = ? AND author = ?";
$this->db->query($sql, array(3, 'live', 'Rick'));

La classe Active Record

$this->db->get()

$query = $this->db->get('mytable');
// équivalent: SELECT * FROM mytable

$query = $this->db->get('mytable', 10, 20);
// équivalent : SELECT * FROM mytable LIMIT 20, 10

$this->db->get_where()

$query = $this->db->get_where('mytable', $where, $limit, $offset);

SELECT, FROM, WHERE

$this->db->select('title, content, date');
$query = $this->db->get('articles');
// équivalent: SELECT title, content, date FROM articles

$this->db->select('title, content, date');
$this->db->from('articles');
$this->db->where(array('id' => 7));
$query = $this->db->get();

$this->db->select('title, content, date')->from('articles')->where(array('id' => 7));
$query = $this->db->get();

Affichage des résultats

$query = $this->db->get('mytable');
foreach ($query->result() as $row){
             echo $row->title;
}

Conclusion

Introduction

L'accès aux données relatives aux pages du site

class Page_model extends Model {
	function Page_model(){
		parent::Model();
	}
}

function add($data){
	return $this->db->insert('pages',$data);
}

function update($id,$data){
	$this->db->where('id',$id);
	return $this->db->update('pages',$data);
}
function delete($id){
	return $this->db->delete('pages',array('id'=>$id));
}

//retourne la liste des pages
function getListe(){
	//SELECT * FROM pages
	$query = $this->db->get('pages');
	if($query->num_rows() > 0){
		$rows = $query->result();
		return $rows;
	}
}
//retourne l'enregistrement dans la
//base de données correspondant à l'id
//passée en paramètre
function get($id){
	//SELECT * FROM pages WHERE id = '$id'
	$query = $this->db->get_where('pages',array('id'=>$id));
	if($query->num_rows()>0){
		$rows = $query->result();
		return $rows[0];
	}
}

Le traitement des données

class Admin extends Controller {
	//constructeur de la classe
	function Admin() {
		parent::Controller();
		$this->load->model('user_model');
		$this->load->library('form_validation');
	}
	//affiche l'admin si la session existe, sinon le formulaire de login
	function index(){
		if($this->user_model->isLoggedIn()){
			redirect('admin/dashboard','refresh');
		} else {
			redirect('admin/login','refresh');
		}
	}
	//traitement du formulaire de login
	function login(){
		if($this->user_model->isLoggedIn()){
			redirect('admin','refresh');
		} else {
			//on charge la validation de formulaires
			$this->load->library('form_validation');
			//on définit les règles de succès
			$this->form_validation->set_rules('username','Login','required');
			$this->form_validation->set_rules('password','Mot de passe','required');
			//si la validation a échouée on redirige vers le formulaire de login
			if(!$this->form_validation->run()){
				$this->load->view('loginform');
			} else {
				$username = $this->input->post('username');
				$password = $this->input->post('password');
				$validCredentials = $this->user_model->validCredentials($username,$password);
				if($validCredentials){
					redirect('admin/dashboard','refresh');
				} else {
					$data['error_credentials'] = 'Wrong Username/Password';
					$this->load->view('loginform',$data);
				}
			}
		}
	}
	//affichage de l'adminstration
	function dashboard(){
		if($this->user_model->isLoggedIn())
			$this->load->view('admin');
	}
	//deconnexion
	function logout(){
		$this->user_model->logout();
		redirect('admin','refresh');
	}
}

function page($action = 'list', $id = null){
		if($this->user_model->isLoggedIn()):
			$this->load->model('page_model');
			switch($action){
				case 'list':
					//affichage de la liste des pages
				break;
				case 'edit':
					//affichage du formulaire de modification d'une page
				break;
				case 'update': //mise a jour de la page
					//modification d'une page
				break;
				case 'add': //ajout d'une page
					//création d'un page
				break;
				case 'delete':
					//suppression de la page
				break;
			}
		else:
			redirect('admin/login');
		endif;
	}

case 'list': //affichage de la liste des pages
	$data['liste'] = $this->page_model->getListe();
	$this->load->view('list_page',$data);
break;
case 'edit': //affichage du formulaire de modification d'une page
	if(isset($id) && $id != 0){
		$data['page'] = $this->page_model->get($id);
		$this->load->view('edit_page',$data);
	}
break;
case 'delete':
	if(isset($id) && $id != 0){
		if($this->page_model->delete($id)){
			echo "page supprimé";
		}
	}
break;

case 'update': //mise a jour de la page
	if(isset($id) && $id != 0){
		//définition des règles de validation
		//$this->load->helper('form_validation');
		$this->form_validation->set_rules('titre_page','Titre','required');
		$this->form_validation->set_rules('contenu_page','Contenu','required');
		if($this->form_validation->run()){
			//les champs obligatoires sont fournis
			//on créé un tableau dans lequel on passe les infos du formulaire
			$data = array(
				'title' => $this->input->post('titre_page'),
				'content' => $this->input->post('contenu_page'),
			);
			//on regarde si le champs keywords est renseigné
			if($this->input->post('keywords_page')){
				$data['keywords'] = $this->input->post('keywords_page');
			}
			//on fait la même chose pour le champs description
			if($this->input->post('description_page')){
				$data['description'] = $this->input->post('description_page');
			}
			//enregistrement dans la base de données
			if($this->page_model->update($id,$data)){
				echo "Page mis à jour";
			}
		} else {
			//certains champs obligatoires sont manquants
			redirect('admin/page/edit/'.$id);
		}
	}
break;

case 'add': //ajout d'une page
	$this->form_validation->set_rules('titre_page','Titre','required');
	$this->form_validation->set_rules('contenu_page','Contenu','required');
	if($this->form_validation->run()){
		//les champs obligatoires sont fournis
		//on créé un tableau dans lequel on passe les infos du formulaire
		$data = array(
			'title' => $this->input->post('titre_page'),
			'content' => $this->input->post('contenu_page'),
		);
		//on regarde si le champs keywords est renseigné
		if($this->input->post('keywords_page')){
			$data['keywords'] = $this->input->post('keywords_page');
		}
		//on fait la même chose pour le champs description
		if($this->input->post('description_page')){
			$data['description'] = $this->input->post('description_page');
		}
		//enregistrement dans la base de données
		if($this->page_model->add($data)){
			echo "page ajouté";
		}
	} else {
		//certains champs obligatoires sont manquants
		$this->load->view('add_page');
	}
break;

Le troisième tiers de notre application: les vues

La liste des pages présentes dans la base

foreach($liste as $page):
	echo "<h2>".anchor('admin/page/edit/'.$page->id,$page->title)."</h2>
	".$page->content."<div><small><strong>Tags:</strong> ".$page->keywords."</small></div>
endforeach;

Le formulaire d'ajout d'une page

echo form_open('admin/page/add/');
echo validation_errors();
echo form_input('titre_page',set_value('titre_page'));
echo form_textarea('contenu_page',set_value('contenu_page'));
echo form_submit('','Ajouter');
echo form_close();

Le formulaire de modification

echo form_open('admin/page/update/'.$page->id);
echo form_input('titre_page',$page->title);
echo form_textarea('contenu_page',$page->content);
echo form_submit('','Modifier');
echo form_close();

Conclusion

Avant de commencer

Création de la base de données

CREATE TABLE users (
  id int NOT NULL AUTO_INCREMENT,
  username varchar(50) UNIQUE NOT NULL,
  password varchar(255) NOT NULL,
  PRIMARY KEY (id)
);

CREATE TABLE pages (
  id int NOT NULL AUTO_INCREMENT,
  title varchar(100) NOT NULL,
  content longtext NOT NULL,
  keywords text NOT NULL,
  description text NOT NULL,
  PRIMARY KEY (id)
);

Création du Modèle Users_model.php

<?php
class User_model extends Model {
     function User_model(){
          parent::Model();
     }
}
?>

function validCredentials($username,$password){
     $this->load->library('encrypt');
     $password = $this->encrypt->sha1($password);
     //requête préparée, beaucoup plus sécurisé
     $q = "SELECT * FROM users WHERE username = ? AND password = ?";
     $data = array($username,$password);
     $q = $this->db->query($q,$data);
     if($q->num_rows() > 0){
          $r = $q->result();
          $session_data = array('username' => $r[0]->username,'logged_in' => true);
          $this->session->set_userdata($session_data);
          return true;
     } else { return false; }
}

Que ce passe-t-il ici?

function isLoggedIn(){
     if($this->session->userdata('logged_in'))
     { return true; } else { return false; }
}

Il reste encore du monde? On passe au Contrôleur

class Admin extends Controller {
     //constructeur de la classe
     function Admin() {
          parent::Controller();
          $this->load->model('user_model');
     }
}

function index(){
     if($this->user_model->isLoggedIn()){
          redirect('admin/dashboard','refresh');
     } else {
          redirect('admin/login','refresh');
     }
}

function login(){
     if($this->user_model->isLoggedIn()){
          redirect('admin','refresh');
     } else {
          //on charge la validation de formulaires
          $this->load->library('form_validation');
          //on définit les règles de succès
          $this->form_validation->set_rules('username','Login','required');
          $this->form_validation->set_rules('password','Mot de passe','required');
          //si la validation a échouée on redirige vers le formulaire de login
          if(!$this->form_validation->run()){
               $this->load->view('loginform');
          } else {
               $username = $this->input->post('username');
               $password = $this->input->post('password');
               $validCredentials = $this->user_model->validCredentials($username,$password);
               if($validCredentials){
                    redirect('admin/dashboard','refresh');
               } else {
                    $data['error_credentials'] = 'Wrong Username/Password';
                    $this->load->view('loginform',$data);
               }
          }
     }
}

function dashboard(){
     if($this->user_model->isLoggedIn())
          $this->load->view('admin');
}

<?php
echo form_open('admin/login');
     echo form_label('Login','username');
     echo form_input('username',set_value('username'));
     echo form_label('Mot de passe','password');
     echo form_password('password');
     echo form_submit('submit','Connexion');
echo form_close();
echo validation_errors();
echo @$error_credentials;
?>

Conclusion

Introduction

Quelles fonctionnalités pour notre CMS?

• un accès sécurisé au back-end.
• un gestionnaire de page
• on devra pouvoir uploader des images
• pourquoi pas pouvoir modifier le design du site?

Installer et configurer CodeIgniter

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

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

<?php
/**
 * Fonction getRelativeTime
 * par Jay Salvat - http://blog.jaysalvat.com/
 */
function getRelativeTime($date) {
    // Déduction de la date donnée à la date actuelle
    $time = time() - strtotime($date); 
    // Calcule si le temps est passé ou à venir
    if ($time > 0) {
        $when = "il y a";
    } else if ($time < 0) {
        $when = "dans environ";
    } else {
        return "il y a moins d'une seconde";
    }
    $time = abs($time); 
    // Tableau des unités et de leurs valeurs en secondes
    $times = array( 31104000 =>  'an{s}',       // 12 * 30 * 24 * 60 * 60 secondes
                    2592000  =>  'mois',        // 30 * 24 * 60 * 60 secondes
                    86400    =>  'jour{s}',     // 24 * 60 * 60 secondes
                    3600     =>  'heure{s}',    // 60 * 60 secondes
                    60       =>  'minute{s}',   // 60 secondes
                    1        =>  'seconde{s}'); // 1 seconde         
    foreach ($times as $seconds => $unit) {
        // Calcule le delta entre le temps et l'unité donnée
        $delta = round($time / $seconds); 
        // Si le delta est supérieur à 1
        if ($delta >= 1) {
            // L'unité est au singulier ou au pluriel ?
            if ($delta == 1) {
                $unit = str_replace('{s}', '', $unit);
            } else {
                $unit = str_replace('{s}', 's', $unit);
            }
            // Retourne la chaine adéquate
            return $when." ".$delta." ".$unit;
        }
    }
}
?>

<?php echo getRelativeTime ('2010-03-01 13:25:00'); ?>

Il y a quelques jours, je travaillais sur l’intégration d’un design dans le système de blog WordPress, plateforme que j’utilise notamment ici. Dans ma charte graphique, chaque élément du menu de navigation est suivi d’une petite phrase expliquant ce que l’on trouvera dans la page lié. J’avais décidé d’enregistrer ces phrases dans un champ personnalisé pour pouvoir l’afficher très simplement et rapidement avec l’une des fonctions qu’intègre WordPress comme wp_page_menu() ou wp_list_page().

Malheureusement, comme me l’a confirmé mon ami @clawfire, ces deux fonctions n’entrent pas dans ce qu’on appelle la Boucle ou Loop dans le jargon WP, il me fallait donc coder moi même l’affichage du menu intégrant ce champ personnalisé. Voilà la marche à suivre

Sur quelles tables de la base de données doit on travailler?

D’abord il faut savoir dans quelles tables sont enregistrés les données qui nous intéresses.  On remarquera que WordPress enregistre les données d’un article dans la table wp_posts, et la table wp_postmeta enregistre d’autres informations moins primordiales comme par exemple quel modèle de page utilise l’article, ET les différents champs personnalisés attachés à l’article.

Au boulot!

Maintenant qu’on sait sur quoi faire notre requête SQL, il est temps de passer à la programmation!

try{
$db = new PDO('mysql:dbname=database;host=localhost','root','pass');
} catch(PDOException $e){
echo "connexion echoué : ".$e->getMessage();
}
//on récupère l'ID de la page statique qui sert de page d'accueil du site
$strHomepage = "SELECT option_value FROM wp_options WHERE option_name = 'page_on_front'";
$stmt = $db->prepare($strHomepage);
$stmt->execute();
$home_id = $stmt->fetch(PDO::FETCH_OBJ)->option_value;
//on récupère la valeur de l'option siteurl
$strHomeUrl = "SELECT option_value FROM wp_options WHERE option_name = 'siteurl'";
$stmt = $db->prepare($strHomeUrl);
$stmt->execute();
$home_url = $stmt->fetch(PDO::FETCH_OBJ)->option_value;
//on récupère les infos neccessaires à l'affichage du menu avec la taglines
$strTagline = "SELECT * FROM wp_posts p, wp_postmeta m WHERE p.ID = m.post_id
AND meta_key = 'nav_tagline' AND post_parent = 0
AND post_type ='page' AND post_status = 'publish'
ORDER BY menu_order ASC";
//echo $home_id;
$stmt = $db->prepare($strTagline);
$stmt->execute();
echo "<ul>";
while($r = $stmt->fetch()){
if($r['ID'] == $home_id){
} else {
echo "<li><a href='".$home_url."/?page_id=".$r['ID']."'>".$r['post_title']."<span>".$r['meta_value']."</span></a></li>";
}
}
echo "<ul>";

Et voilà, notre menu avec un custom field est terminé!