Ceci est un post que j’ai eu envie d’écrire pour aucune autre raison que celle d’être tombé sur l’un des premiers article du blog de Paweł Gryzbek. Je ne vais pas partager mon « setup » mais plutôt tous les IDE, au sens large, que j’ai utilisé jusqu’à maintenant pour le développement Web.

• Microsoft FrontPage
• Dreamweaver MX
• Komodo Edit
• Espresso
• Coda
• Adobe Brackets
• Sublime Text 2
• Sublime Text 3
• Atom
• Visual Studio Code

J’ai adoré utiliser Espresso pour le CSS et Coda pour le PHP, mais j’avoue que mon préféré jusqu’ici c’est VSCode. Déjà avant que GitHub soit racheté par Microsoft j’adorais coder dans Atom. Ça fait maintenant plus de 6 ans que je code dans VSCode et je ne compte pas changer !

Bien que très simple à mettre en place dans les faits, quand vient l’heure de nettoyer une chaîne de caractères pleine d’accents, de signes de ponctuation et autres caractères spéciaux, c’est la galère.

Voici la fonction que j’utilise pour nettoyer mes chaînes de caractères et les utiliser comme permalien

function clean($string) {
	$string = html_entity_decode(preg_replace('/&([a-zA-Z]{1,2})(?:acute|cedil|circ|grave|lig|orn|ring|slash|th|tilde|uml);/i', '$1', htmlentities($string, ENT_QUOTES, 'UTF-8')), ENT_QUOTES, 'UTF-8');
	$string = strtolower(trim(preg_replace('/[^0-9a-z]+/i', '-', $string), '-'));

	return $string;
}

Le principe ici est très simple. D’abord on converti tout les caractères qui peuvent l’être en entités HTML à l’aide de la fonction htmlentities(), ensuite on remplace chaque caractère par son équivalent sans accent, cédille, etc.

preg_replace('/&([a-zA-Z]{1,2})(?:acute|cedil|circ|grave|lig|orn|ring|slash|th|tilde|uml);/i', '$1', htmlentities($string, ENT_QUOTES, 'UTF-8')), ENT_QUOTES, 'UTF-8');

En appliquant la fonction html_entity_decode() sur la chaîne nettoyée de tout caractère accentué, on transforme à nouveau les entités HTML restantes en caractères normaux.

Enfin, on remplace tous les caractères n’étant pas des lettres ou des chiffres par un tiret, puis on supprime les tirets en trop à l’aide de la fonction trim().

J’espère que ce petit morceau de code vous aura été utile :).

N’hésitez pas à partager votre solution, ou vos remarques dans les commentaires.

Tchô !

L’intérêt d’un tel dispositif est de pouvoir « tracker » ce qu’un visiteur fait lorsqu’il parcours votre site Web, ou encore de savoir si une campagne emailing a bien été ouverte.

Pixel de suivi

Le code partagé ici est un exemple basique est ne reflète pas exactement la solution que j’ai utilisé pour tracker les visiteurs de nos sites Internet, mais le principe reste le même.

<?php
// On récupère d'abord l'adresse IP du visiteur
$ip = !empty($_SERVER['HTTP_CLIENT_IP']) ? $_SERVER['HTTP_CLIENT_IP'] : (!empty($_SERVER['HTTP_X_FORWARDED_FOR']) ? $_SERVER['HTTP_X_FORWARDED_FOR'] : $_SERVER['REMOTE_ADDR']);

// Navigateur utilisé
$browser = $_SERVER['HTTP_USER_AGENT'];

// URL de la page visité
$url = $_SERVER['REQUEST_URI'];

// Enregistrement dans un fichier de log
$handle = fopen('log.txt', 'a+');
$log_data = date('Y-m-d H:i:s') . ' -- ' . $ip . ' -- ' . $brower . ' -- '. $url . "\r\n";
fwrite($handle, $log_data);
fclose($handle);

// Création du pixel de suivi
$pixel = imagecreate(1,1);
$pixel = imagecolorallocatealpha($pixel, 255, 255, 255, 0);

// Enfin, on affiche le pixel de suivi
header('Content-Type: image/png');
imagepng($pixel);
imagedestroy($pixel)
?>

Intégrer le pixel de suivi

Maintenant que notre image de 1 pixel sur 1 pixel est créée, il ne reste plus qu’à l’insérer dans le code HTML des pages que l’on souhaite suivre. Une simple balise img juste avant la balise </body> suffira !

<img src="pixel.php" width="1" height="1" />

Eh voilà ! J’espère que ce petit bout de code vous aura plu. Si vous avez d’autres solutions, n’hésitez pas à les partager dans les commentaires.

Tchô !

Lorsque je travaillais encore chez CBC Informatique, nous n’utilisions pas les principes de la programmation orientée Objet et nous préférions développer nous même les sites Web de nos clients plutôt que de s’appuyer sur des solutions toutes faites, afin de garder la maitrise de notre code. C’est dans cette optique que j’avais développé notre mini-framework/CMS.

Depuis presque 1 an maintenant,  je travaille chez Ibakus Europe et à nouvelle équipe nouvelle façon de travailler. Pour concevoir les nouvelles applications Web IBAKUS, nous utilisons la programmation orientée Objet et les principes du MVC. Nos applications gérant des données plutôt sensibles, il a été décidé de développer notre propre framework PHP Objet, afin de garder au maximum la main sur le code et pouvoir le modifier plus facilement.

Les bases du framework PHP Objet

D’abord, nous avons écrit une classe maîtresse que l’on a appelée Container. Elle nous permet entre autre d’initialiser le framework avec un fichier de configuration, de définir les différentes routes et de charger les différents Modèles et Contrôleurs.

Une classe abstraite Model définit les méthodes utilisées pour agir sur la base de données puis chacun de nos modèles étendent cette classe afin de gérer les spécificités qui leur sont propres.

Mon but n’étant pas de publier le code source de notre framework, je m’intéresserai uniquement aux méthodes CRUD de notre classe abstraite Model.

Structure de la classe abstraite Model

La classe abstraite Model est définie par deux propriétés $db et $table et cinq méthodes : get(), getDatas(), set(), delete() et save().

La propriété $db est une instance de la classe PDO établissant la connexion à notre base de données, $table quand à elle contient le nom de la table sur laquelle les opérations des méthodes save() et delete() vont être faites. Voici la structure de notre classe :

abstract class Model {
  protected $db;
  protected $table;
  
  public function __construct() {
    $this -> db = Container::getDb();
    $this -> table = $this; 
  }
  
  /**
   * Un echo de $this retournera le nom de la table associée au modèle.
   * Par exemple 'pages' pour le modèle 'PagesModel'
   */
  public function __toString() {
    return strtolower(substr(get_class($this), 0, -5));
  }
  
  // GETTERS
  public function get($attr) {
    return $this -> $attr;
  }
  
  /**
   * Retourne tous les attributs de l'objet
   */
  public function getDatas() {
    $datas = array();
    foreach (get_object_vars($this) as $key => $value)
        $datas[$key] = $value;
    
    return $datas;
  }
  
  // SETTER
  public function set($attr, $data) {
    if (property_exists($this, $attr)
        $this -> $attr = $data;
  }
  
  // METHODES
  public function delete() {}
  
  public function save() {}
}

La méthode save()

cette méthode permet d’enregistrer l’objet dans la base de données, que ce soit pour son insertion ou lors de sa modification. Pour définir si l’on va faire un INSERT ou un UPDATE, on testera la valeur de l’attribut id de l’objet courant. Si elle n’est pas nulle on souhaite modifier l’objet, sinon on crée une nouvelle entrée dans la base.

public function save($type = null) {
  if ($this -> get('id') == null) {
    $query = 'INSERT INTO ' . $this -> get('table') . ' SET';
    $nbDatas = count($this -> getDatas());

    $i = 0;
    foreach ($this -> getDatas() as $key => $value) {
      $i++;
      $query .= ' ' . $key . ' = :' . $key;
      if ($i < $nbDatas) $query .= ','; else $query .= ';'; } } else { $query = 'UPDATE ' . $this -> get('table') . ' SET';
    $nbDatas = count($this -> getDatas());

    $i = 0;
    foreach ($this -> getDatas() as $key => $value) {
      $i++;
      if ($key != 'id') {
        $query .= ' ' . $key . ' = :' . $key;
        if ($i < $nbDatas) $query .= ','; } } $query .= ' WHERE id = :id;'; } $query = $this -> get('db') -> prepare($query);

  foreach ($this -> getDatas() as $key => $value)
    $query -> bindValue(':' . $key, $value);

  $executed = $query -> execute();

  if ($executed && $this -> get('id') == null)
    $this -> set('id', $this -> get('db') -> lastInsertId());

  return $executed;
}

La méthode delete()

Pour supprimer les données de l’objet enregistré, rien de vraiment compliqué, on execute simplement une requête préparée avec la classe PDO et on supprime l’enregistrement dont id correspond à l’attribut id de l’objet courant.

public function delete() {
  $query = $this -> get('db') -> prepare('DELETE FROM ' . $this -> get('table') . ' WHERE id = :id;');
  $query -> bindValue(':id', $this -> get('id'));
  
  return $query -> execute();
}

Pour finir : construire un CMS

Construire un CMS sur base d’une classe abstraite comme celle-ci permet d’écrire très simplement les différents modules dont on aura besoin.

Si l’on souhaite gérer des pages de contenu, il suffira d’écrire un modèle héritant de la classe Model, par exemple pagesModel et d’y définir les attributs de l’objet en regard de la structure de la table pages de la base de données.

Cette classe héritant de la classe abstraite, nous n’auront pas besoin de réécrire nos méthodes save() et delete() et l’on pourra se concentrer sur des méthodes permettant par exemple, de retourner un menu de navigation, des méta-tags pour le référencement naturel, etc.

Bien sûr, il faudra écrire un contrôleur permettant de traiter les données à passer au modèle, qui se chargera ensuite de les enregistrer en base de données, mais ça se fait rapidement  .

Là dessus, bonne semaine (et bonne année) !

Personnellement j’aime passer du temps à peaufiner un design. je déteste réécrire les mêmes fonctions pour chaque projet. Alors oui, il des frameworks PHP, mais pourquoi utiliser un bazooka lorsqu’on doit abattre une mouche ?

MAJ 11/01/2016 : Si le PHP Objet vous parle, vous pouvez lire Créer son framework PHP Objet qui est un peu plus récent 

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

Oui utiliser une CMS déjà tout fait c’est bien, oui utiliser un framework en PHP Objet c’est bien. Seulement parfois, utiliser une arme de destruction massive n’est pas la bonne méthode à appliquer pour régler les choses les plus simples.

Ces dernier mois, au fil des projets qui le permettaient, j’ai pu me construire ma propre bibliothèque de fonctions, en essayant de l’améliorer à chaque itérations, tout en restant le plus générique possible pour permettre une très bonne portabilité de projet en projet. Bien sûr je n’ai pas hésité à piquer des idées dans les frameworks PHP, mais plutôt que de me trimballer toute la clique, j’ai maintenant un petit « framework » qui me permet de faire juste ce dont j’ai besoin. Cela m’a aussi permis de monter facilement notre propre CMS, lui aussi très basique.

Aujourd’hui j’ai donc envie de partager avec vous quelques unes de mes fonctions, car ça fait un petit moment que je n’ai pas publié un peut de code PHP dans mes pages.

Mes fonctions de CRUD

Etape obligatoire lorsqu’on souhaite agir sur des informations stockées en base de données, les célèbres fonctions INSERT, SELECT, UPDATE et DELETE. Après plusieurs itérations je suis arrivé à des fonctions quasiment utilisable par n’importe quel projet, même si je pense qu’elles ne sont pas encore parfaites, pour le moment elles me suffisent. Cependant, si vous avez de quoi les améliorer n’hésitez pas à me donner votre avis !

Ajouter un enregistrement dans une table

Après pas mal de projet dans lesquels j’avais une fonction d’ajout pour chaque type de contenu (page, article, etc.) enregistrés dans des tables différentes, j’ai essayé de trouver un moyen simple d’ajouter n’importe quelle données dans n’importe quelle table. Je suis donc passé de plusieurs fonction plus ou moins lourde à une bête fonction d’une quinzaine de ligne avec laquelle je peux faire ce que je veux, simplement en lui passant un tableau des données à ajouter, et le nom de la table dans laquelle faire cet INSERT.

/***
 *  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;
}

Comment utiliser la fonction ?

Après avoir vérifiées, échappées, etc., les informations soumisent à mon formulaire, il me suffit de créer un tableau dont les clés seront les noms des champs que je veux renseigner pendant mon INSERT.

Exemple : je veux renseigner le nom, l’adresse email et le commentaire dans la table « comments ».

$datas = array(
  'nom' => $nom,
  'email' => $email,
  'commentaire' => $commentaire
);

if(add($datas,'comments')) {
  return "cool";
} else return "pas cool";

Si tout c’est bien passé, la fonction add() me renvoie l’ID de l’enregistrement créé.

Mettre à jour les informations d’un enregistrement

Là aussi, c’est une fonction vraiment très simple. comme ma fonction add(), ma fonction update() requiert un tableau des données et le nom de la table à modifier. Seul petit changement, on doit aussi fournir l’ID de l’enregistrement à modifier.

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

Rien de bien compliqué là non plus, on supprime l’enregistrement dont l’ID est passé en paramètre dans la table elle aussi en paramètre.

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

Cette dernière est l’une des fonctions que j’ai eu le plus de mal à rendre générique tout en me permettant de faire beaucoup de choses avec, comme par exemple préparer le terrain pour l’utiliser dans le cadre des données scindées sur plusieurs pages.

Ici ma fonction me permet de récupérer à la fois les enregistrements de ma requête, le total d’enregistrements que retournerai ma requête si aucun paramètre LIMIT n’était renseigné, la requête exécutée (pour les tests en phase de développement) ou les erreurs possibles quant à l’exécution de cette requête.

/***
 *  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;
}

Comment utiliser la fonction ?

Exemple : Je veux récupérer les cinq articles les plus récents écrits par nighcrawl dont le titre contient le mot « framework » publié depuis la date à laquelle la requête est exécutée.

$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

Je m’arrêterai ici parce que l’article est déjà pas mal long, et si vous êtes arrivé jusqu’ici je vous dis chapeau. Personnellement je me serai déjà arrêté :). On fini donc avec une fonction très utile pour générer rapidement des liens de pagination afin de répartir les données d’une requête sur plusieurs pages. Voici donc la belle fonction :

/***
 *  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>";
}

La pagination va s’effectuée en deux temps, d’abord l’appel de la fonction get(), puis l’appel de la fonction pagination(). Si on réutilise l’exemple précédent :

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

Merci de m’avoir lu jusqu’au bout. Je vous libère ici ! En espérant que ces quelques fonctions puissent vous être utiles. Elles ne sont pas parfaites et certaines pourraient être encore améliorées, alors si vous avez des idées, n’hésitez pas à les partager dans les commentaires.

Le principe ici était, pour moi, de générer une chaine de 8 caractères alphanumériques choisis aléatoirement. J’ai volontairement choisi de ne pas inclure de caractères accentués ni caractères spéciaux afin que les mots de passes générés soit relativement simple à retenir, tout en étant « difficile » à cracker. Bien sûr, les mot de passes sont cryptés en base, mais ça n’est pas la question.

Voici donc notre petite fonction :

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

Ici, je définis les caractères que je souhaite utiliser pour mon mot de passe. Je range ensuite chaque caractères dans un tableau grâce à str_split(). Vient ensuite la génération de la chaîne aléatoire dans une boucle for() qui s’executera 8 fois ( je veux 8 caractères). Pour augmenter sensiblement la difficulté du mot de passe, je mélange mon tableau de caractères à chaque passage dans la boucle, et choisi un caractère  du tableau au hasard.

Fonction super simple, je vous l’accorde, mais ça pourra toujours servir, libre à vous de le modifier et l’utiliser comme bon vous semble 

Ok, avant de voir comment utiliser CodeIgniter pour exécuter des requêtes SQL, on va voir comment déclarer plusieurs configuration de base de données, pour par exemple avoir une configuration différente selon si l’on travaille en local ou bien sur serveur.

Configurer la classe Database

Afin de permettre à CodeIgniter de « discutailler » avec notre base de données, il faut lui donner les infos pour y accéder. Ouvrez le fichier database.php se trouvant dans le dossier config de l’application (application/config/database.php), vous trouverez les réglages de la base de données stockés dans un  tableau multidirectionnel $db comme ci-dessous.

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

L’intérêt d’utiliser un tableau multidirectionnel pour enregistrer les infos relatives à la base de données, c’est de pouvoir définir un autre tableau  avec des informations différentes, pour ensuite choisir lequel de ces tableaux utiliser. Ainsi, si l’on souhaite déclarer deux configurations différentes, rien de plus simple :

//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";

Il suffira ensuite de définir la valeur de la variable $active_group à « test » pour utiliser notre configuration secondaire. Easy!

Pour établir la connexion à la base de données il faudra alors faire appelle à la librairie Database dans votre classe, grâce à la ligne suivante :

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

Il est aussi possible d’instancier deux connexion en faisant comme suit :

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

Ma première requête SQL avec CodeIgniter

On y est, notre connexion à la base est active, on va pouvoir manipuler les données (j’adore ça, manipuler des données)!

Avec CodeIgniter, ce qu’il y a de bien c’est qu’on a vraiment le choix des armes pour construire nos requêtes : soit on les construit comme au bon vieux temps des mysql_*() soit on utilise la méthode objet (PDO), ou encore mieux on utilise les nombreuses fonctions du Framework!

Comme il y a toute une flopée de fonctions préexistantes je vais volontairement ne présenter que les plus courantes.

mysql_query() à la sauce CI

C’est la fonction query() de la classe Database qui permet d’exécuter simplement des requêtes SELECT simple. La fonction s’utilise très simplement : $this->db->query('SELECT * FROM table');

Si l’on souhaite construire des requêtes avec paramètres, il sera obligatoire de les échapper avec les fonction escape(), escape_str() ou escape_like_str(), équivalents de la fonction mysql_real_escape_string().

La fonction escape() permet d’échapper les données quelque soit leur type (string, int, float, etc…), tandis que escape_str() n’accepte que des données de type string. escape_like_str() quant à elle, permet d’échapper des requêtes avec des conditions LIKE.

Query() peut aussi être utilisé avec des requêtes préparées, comme avec l’objet PDO. Ainsi pour exécuter une requête, rien de bien compliqué:

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

L’intérêt ici, comme avec PDO c’est que les valeurs passées en paramètre sont automatiquement échappées.

CodeIgniter pourrait s’arrêter là, mais dans ce cas qu’aurait-il de plus que le simple objet PDO ? La réponse : l’Active Record!

La classe Active Record

Utiliser l’Active Record, c’est hype, branché et trop in the move!

Pourquoi? Parce que cela permet entre autre de laisser de côté l’histoire « Ma base est en MySQL, SQL Server, Postgre, … ? », en clair on ne s’occupe pas du SGBD utilisé, on lui pose juste les questions. Conséquence, notre appli a une meilleure portabilité.

CodeIgniter propose pas mal de fonctions permettant de construire des requêtes sans se fouler, j’irai même jusqu’à dire « sans même en connaître un radis en SQL ». Regardons ce qui nous est proposé.

$this->db->get()

get() permet d’exécuter en un rien de temps un SELECT sur une table et ainsi retourner tout ses enregistrements

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

Si l’on veut limiter le nombre de résultats retournés, par exemple dans le cadre d’une pagination, rien de plus simple il suffit juste de passer deux autres paramètres à get() en plus de la table sur laquelle on travaille.

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

$this->db->get_where()

Vraiment besoin d’explications? get_where() permet tout simplement de faire un get() avec des conditions.

Les différentes condition seront à présenter sous forme d’un tableau (on vera ça ensuite dans la fonction where()) .

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

Avec ces deux fonctions, c’est le Framework qui s’occupe de construire nos requêtes. Si l’on veut les générer nous même tout en utilisant l’Active Directory, c’est maintenant qu’on va retrouver une pelletée  de méthodes.

SELECT, FROM, WHERE

Ok, admettons que l’on veuille retourner le titre, le contenu et la date d’un article dans notre base.

Clairement ici get_where() boufferai de la ressource inutilement puisqu’il nous retournerai d’autres champs dont on aurait pu se passer. select() est là pour nous ravir les amis!

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

Attends voir, là on récupère le titre, le contenu et la date de tout les articles dans la base… Quel œil vif! C’est ici qu’interviennent nos amis from() et where() :

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

C’est pas beautiful ? CodeIgniter a un sac plein de fonctions équivalentes aux fonction SQL comme SUM(), AVG(), COUNT(), etc.  Je ne les traiterai pas ici mais vous pourrez les retrouver sur dans le Guide Utilisateur de CodeIgniter.

Chose pratique, on peut concaténer toutes ses fonctions, pour économiser en ligne de code. Ainsi, notre requête précédente pourrait s’écrire :

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

Affichage des résultats

On finira ce billet très rapidement sur la façon d’afficher le résultat de nos différentes requêtes.

Ici on fera un simple foreach() comme on a l’habitude d’en faire quand on utilise PDO (pour moi en tout cas).

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

Conclusion

Ici on a donc vu pas mal de méthodes bien utile lorsqu’il s’agit d’interroger une base de donnée lorsqu’on développe dans le cadre d’une application Web sous CodeIgniter.

Petite parenthèse, je tiens à m’excuser pour l’attente interminable entre le moment ou j’ai annoncé faire cet article, et sa publication. J’ai eu deux bons gros mois de taff bien chargés, autant au boulot, qu’au niveau perso (notamment le site du WDFR sur lequel je travail avec @Fran6, @Twikito, @ClementRoy et @C_Beghin, et tout le workgroup WDFR), ce qui explique en partie ce petit retard.

J’en profite aussi pour souhaité avec du retard, une très bonne année 2011, pleine de bonnes choses et d’argent (surtout) ^^

Introduction

La semaine le mois dernier (désolé) on avait vu comment CodeIgniter construisait les pages de notre site en utilisant le modèle MVC, c’est à dire la séparation du code source en trois couches qui ont chacune une « mission » : accéder aux données stockées dans la base (couche Modèles) traiter les données (couche Contrôleurs), afficher les données (couche Vues).

Nous avions donc créé un contrôleur Admin qui se chargeait de traiter les données renvoyées par notre modèle User_model qui s’occupait de voir si pour les infos de connexion passées via notre vue loginform.php on avait un résultat dans la base, auquel cas, on donnait accès à l’administration du site. Et on s’était arrêté là. Aujourd’hui… la suite!

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

Ayant pris l’habitude de bien séparer les différentes parties des sites que je développe, et parce que c’est plus pratique pour s’y retrouver par la suite, je vous propose de créer un nouveau modèle qui ne s’intéressera qu’à nos données stockées dans notre table pages.

Dans le dossier application/models, créez un nouveau fichier que vous appellerez page_model.php contenant le code suivant:

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

Qui nous permet de  définir notre classe Page_model comme étant un Model. Ensuite, nous allons ajouter différentes méthodes à l’intérieur de cette classe qui nous permettront de modifier les données présentent dans notre table pages. C’est ce qu’on appelle les fonctions CRUD (Create, Read, Update, Delete).

Okay, premièrement on va s’occuper de la fonction d’ajout dans la base.

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

Ici, c’est allé super vite n’est-ce pas? En effet dans notre modèle on ne s’occupe que de l’insertion des données dans la base, leur traitement pour savoir si oui ou non les données sont conformes se fera avant ça, dans notre contrôleur.

Pour ce qui est des fonctions de modification, et de suppression, c’est aussi rapide, donc les voici toutes les deux:

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

Passons maintenant à nos fonction de « lecture » ici, on a deux fonctions, la première servira pour retourner toutes les pages présentent dans la base, alors que la seconde ne retournera qu’une seule page.

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

Nous en avons fini avec notre modèle, passons à notre contrôleur. Ici on va reprendre notre contrôleur Admin et y ajouter une méthode appelée page… Originale n’est-ce pas ^^.

C’est dans cette méthode que nous allons traiter les données passées à nos formulaires d’ajout/modification des pages, que nous renverrons au modèle rédigé juste avant.

Pour rappel, voilà notre contrôleur Admin là où on s’est arrêté le mois dernier:

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

Ajoutons maintenant notre fonction page. Elle prendra en paramètres deux variables : $action qui nous permettra de savoir qu’est-ce que l’on doit faire lorsqu’on appelle cette fonction, et $id qui donnera l’identifiant de la page à modifier/supprimer dans la base. Voici la structure générale de notre méthode, je détaillerai les différentes étapes par la suite.

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

Ici on attend donc les deux paramètres $action et $id qui ont par défaut les valeurs respectives ‘list’ et null, ainsi si la fonction est appelée sans aucun paramètre, on affichera l’action list, donc la liste des pages, tandis que l’identifiant de page sera nul. Aussi, avant de traiter les données, on s’assure que l’utilisateur est bien loggué en administrateur via la commande $this->user_model->isLoggedIn().

Passons à l’écriture des actions possible. Je vais faire les actions list, edit et delete en même temps car elle sont simple et ne nécessites pas vraiment qu’on s’y attarde.

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;

Ici rien de bien compliqué, si $action est égale à ‘list’, on appelle la méthode getListe() de notre modèle Page que l’on stocke dans la variable $data, de type array, et dont l’identifiant sera ‘liste’. Ensuite on charge la vue list_page en lui passant les données stockées dans la variable $data, ce qui nous permettra, lorsqu’on rédigera cette vue, de récupérer les données de la méthode getListe via la variable $liste. Vous suivez toujours?

Si l’on passe la valeur ‘edit’ à notre variable $action, on vérifie que notre variable $id ne soit pas nulle, et on envoi les données retournées par la méthode get() à notre vue edit_page.

Enfin, si $action vaut ‘delete’ et que $id n’est pas nulle, on appelle la méthode delete() de notre modèle Page.

Okay, maintenant on passe à la modification d’une page, via l’action update. Ici, le principe c’est que via l’action edit on a récupéré les données stockées dans la base et on a peuplé le formulaire de la vue edit_page. Ce formulaire renvoi les données à l’action update, via une URL du style /admin/page/update/$id. On doit donc vérifier si les données renvoyées sont bonne avant de modifier leur valeur dans la base.

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;

Pour l’insertion d’une nouvelle page dans la base de données le principe est le même, sauf que j’ai choisi de réunir les deux étapes de l’appel du formulaire et celle de la vérification des données. Voici ce que ça donne:

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

On en a enfin fini avec notre contrôleur! On passe maintenant au troisième tiers de notre application, les vues. Ici je ne vais pas vous donner plus d’explications, les trois vues sont relativement simples a comprendre même en ne connaissant pas trop bien la syntaxe utilisée par CodeIgniter. Voici donc les trois vues list_page.php, add_page.php et edit_page.php.

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

Après avoir développé notre système de login sécurisé, on a vu ici comment construire simplement et rapidement un module de gestion pour les pages que contiendra notre futur site Web.

Avec ce nouvel article, notre système pourrait très bien s’arrêter là, il est fonctionnel et relativement sécurisé tant au niveau de l’accès par login/mot de passe, qu’au niveau de la vérification des valeurs saisies dans les différents formulaires, du fait que c’est le framework lui-même qui s’occupe de vérifier les données et d’échapper les données avant de les enregistrer dans la base.

La prochaine fois, on vera comment intégrer un éditeur de texte comme TinyMCE à notre CMS afin de pouvoir mettre en forme notre texte facilement, et puis surement d’autre petites choses. Par contre, je ne sais pas encore quand est-ce que je vous pondrait çà 

Avant de commencer

Cet article est le second d’un ensemble d’article sur la création d’un système de gestion de contenu en utilisant le framework PHP CodeIgniter. Je vous invite donc à lire le précédent article pour partir sur de bonnes bases et avoir une installation saine de CodeIgniter pour l’article actuel.

Okay, on a donc convenu mercredi que l’on partira sur un simple CMS pour l’instant, donc ici pas de gestion de catalogue produit, pas de blog, juste un gestionnaire de pages (bien qu’intégrer un blog ne soit pas franchement différent de ce dernier). Allez, on se lance!

Création de la base de données

Comme notre CMS sera très simple, on aura pas beaucoup de tables dans notre base de données, et quand je dis pas beaucoup, c’est déjà trop. On aura donc une table users qui nous permettra d’enregistrer les infos de connexion des différents utilisateurs de notre CMS. Ici rien de très compliqué:

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

On a donc ici un champ username qui devra être unique, un champ password pour le mot de passe que l’on cryptera en SHA1, je n’aime pas trop MD5 même si ça peut faire l’affaire ici.

Ensuite, la dernière table de notre base sera une table dans laquelle on enregistrera le contenu des pages présentent sur le site. La encore rien de compliqué, j’ai même choisi de disposé de champs afin de renseigner les balises meta pour l’indexation des pages dans Google (un peu de SEO ne fait pas de mal).

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

J’ai vraiment besoin d’expliquer?

Okay, on va maintenant créer le fichier qui permettra de récupérer les données présentes dans la base de données.

Création du Modèle Users_model.php

Qu’est-ce que ça veut bien dire? Vous vous rappelez dans le précédent article on a parlé de Modèle MVC, et bien Users_model.php c’est le ‘M’ de ‘MVC’. C’est ici qu’on va écrire nos fonctions « CRUD » (Create, Read, Update, Delete), on utilisera ensuite ces fonction dans notre Contrôleur, qui traitera les données retournées par notre Modèle, et les affichera dans la Vue.

Allez on se lance, ce sera plus clair quand on aura mit les pieds dans le code. Donc, dans le dossier application/models on créé le fichier u_sers_model.php_ qui contiendra ceci :

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

Ici on créé la classe User_model qui hérite de la classe Model, puis on instancie la classe avec le constructeur User_model (on aurai pu aussi utiliser __constructor pour l’instancier).

On va maintenant créer notre fonction qui vérifiera les infos de login passées au formulaire qu’on verra plus tard. Dans la classe User_model, sous notre constructeur du même nom, ajoutez la fonction suivante :

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?

D’abord on charge la librairie encrypt avec la commande $this->load->library('encrypt') ce qui nous permet d’utiliser les fonctions de cette librairie dans notre modèle. Ensuite on crypte en SHA1 le mot de passe passé en paramètre à la fonction. Enfin, on exécute la requête stockée dans la variable $q avec $this->db->query() en lui passant le tableau $data pour remplacer les points d’interrogation dans notre requête ; c’est une requête préparée, j’en avais parlé l’an dernier dans un article sur l’Objet PDO.

Si la requête nous renvoi un résultat, on créé deux variable de sessions username et logged_in qui permettra de savoir si on a accès ou non à notre admin. Sinon validCredentials nous retourne false.

On va ajouter aussi une autre fonction pour savoir si on est bien loggué. On pourrait s’en passer mais ça nous évitera quelques lignes de code dans notre contrôleur. Celle ci est simple, ajoutez la fonction suivante à l’intérieur de votre Modèle:

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

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

Maintenant qu’on a notre Modèle pour l’accès à la base de données, il est temps de les manipuler ces petites données! Créez un fichier  admin.php dans le dossier a_pplication/controllers_ et mettez y le code suivant:

class Admin extends Controller {

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

Ici comme notre avec notre User_model, on crée une classe Admin qui hérite de la classe Controller, et on l’initialise grace à son constructeur, dans lequel on charger notre modèle User_model, ce qui nous permettra d’utiliser ses fonctions dans notre contrôleur Admin.

Maintenant que notre contrôleur est instancié, on va ajouter les fonctions (ou méthodes) qui nous permettrons d’envoyer les données du formulaire de login à notre Modèle et ainsi définir si on a accès ou non à notre backoffice.

La première fonction qu’on va inclure dans notre classe Admin, et la fonction index() qui nous servira de page d’accueil. En gros lorsqu’on accédera à l’adresse http://localhost:8888/cms/index.php/admin, c’est notre fonction iindex() qui sera appelée.

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

Ici on vérifie si on est bien loggué, dans ce cas on redirige à l’adresse http://localhost:8888/index.php/admin/dashboard qui est le tableau de bord de notre CMS, sinon on redirige au formulaire de login.

Parlons du formulaire de login. Pour traiter les données soumises au formulaire, on va créer une méthode login() dans notre contrôleur.

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

Ici on vérifie d’abord si on est loggué, dans ce cas on redirige vers l’admin, sinon on traite le formulaire. On charge la librairie form_validation, qui va nous permettre d’accéder à des fonctions de validation de champs déjà toute prête, notamment la fonction set_rules qui nous permettra de définir quels champs sont obligatoire, quel type de données accepter, etc. Lorsque nos règles d’acceptation sont validées, on vérifie que les login/mot de passe passés en paramètres retournent un résultant dans la base de données, via notre fonction validCredentials() qu’on a définit dans notre modèle User_model. Si un résultat est retourné, la fonction validCredentials créée la variable de session logged_in et nous redirige vers le dashboard.

Dernière méthode de notre contrôleur, la fonction dashboard() qui se chargera d’afficher notre tableau de bord.

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

Passons maintenant à nos deux « vues », loginform et admin. Ce sont les deux fichiers que l’on appelle avec la fonction $this->load->view() dans notre contrôleur. Dans le dossier application/views créez les fichier loginform.php et admin.php. La vue admin n’ayant pas trop d’intérêt pour l’instant, on va juste voir la vue loginform, qui nous permettra de voir comment créer facilement un formulaire avec CodeIgniter.

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

Ici on ouvre un tag <form> qui enverra le formulaire à la méthode login() du contrôleur Admin. Puis on affiche les erreurs de validation si il y a lieu avec la fonction validation_errors() et les erreurs de login/mot de passe avec notre variable $error_credentials.

Eh voilà, votre formulaire de login sécurisé est terminé!

Conclusion

Ici on a vue comment bien utiliser l’architecture trois tiers qui permet de séparer la couche présentation (nos Views), de la couche métier (notre Controller) et de la couche réseau (notre Model). Ainsi, si l’on veut changer de système de gestion de base de données et passer sur une base Oracle plutôt que MySQL, nous n’aurons qu’a changer les méthodes écrient dans notre modèle User_model.

Dans le prochain article, on s’attardera sur LE coeur de notre système, à savoir la gestion des pages. Allez, bon week-end!