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!

Introduction

Pourquoi choisir d’utiliser un framework PHP pour développer un tel projet? La raison est simple : pourquoi perdre son temps à réinventer la roue quand on a la possibilité d’utiliser des fonctions déjà toutes prêtes? Un framework est donc fort utile dans ce type de projet, surtout pour tout le back-end du site, ce que l’utilisateur ne voit pas, et sur lequel nous les développeurs, passons pas mal de temps à développer pour rendre la vie facile à l’utilisateur du site.

Pourquoi CodeIgniter comme base de travail? Pour moi qui n’avais pas l’habitude d’utiliser des frameworks PHP (j’aime bien me compliquer la vie), j’ai trouvé que CodeIgniter était le plus simple à prendre en main pour moi qui n’avais pour dire jamais fais de PHP Objet (ouh! le nul!).

Aussi, un framework permet de passer plus de temps sur le développement pur plutôt que de perdre son temps sur des petites choses bien chiantes comme il faut (la validation de formulaire me sort par les trous de nez!).

Quelles fonctionnalités pour notre CMS?

Avant de se lancer à la va vite dans le développement, il faut se demander à quoi servira notre moteur de site, est-ce qu’on gère un blog, un catalogue de produit, ou bien un simple site vitrine? Étant actuellement entrain de développer un site permettant d’afficher un catalogue de produits, j’aurai tendance à vouloir vous proposer de partir sur cette idée. Pour commencer je vous propose de nous concentrer sur une simple vitrine (ce qu’il y a de plus simple), et on verra ensuite pour le catalogue de produit.

Notre système devra donc comprendre:

• 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

Aujourd’hui on va simplement préparer le terrain en téléchargeant et en installant le framework sur notre serveur Web. Rendez-vous sur le site du framework et télécharger la version actuelle de CodeIgniter, au moment ou j’écris c’est la version 1.7.2.

Dézipper le contenu de l’archive et transférez les dossiers de CodeIgniter à la racine de votre serveur. Vous devriez avoir une arborescence comme présenté à droite:

Les dossiers important ici sont le dossier system, qui renferme tout les fichiers nécessaires au fonctionnement de CodeIgniter, et le dossier application, qu’il est possible de sortir du dossier system pour une meilleure organisation. Aussi on pourra se passer du dossier user_guide qui n’est qu’une version local du guide utilisateur disponible sur le site de CodeIgniter.

Vous remarquerez aussi les dossiers controllers, models et views, ce sont nos trois dossiers de travail. Eh oui, CodeIgniter utilise le Modèle MVC (Modèle-Vue-Controleur) aussi appeler application trois tiers, ce qui permet de séparer les opérations d’accès à notre base de données des opérations de traitement de ces données, ainsi que l’affichage de ces même données.

Passons maintenant à la configuration de CodeIgniter.

Ici c’est très simple, il suffit de modifier la variable $config['base_url'] du fichier application/config/config.php en renseigner l’adresse de notre serveur.

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

On va ensuite configurer l’accès à la base de données. Pour cela, direction application/config/database.php et renseigner les lignes suivantes avec vos informations de connexion.

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

Et voilà! Si vous vous rendez à l’adresse où vous avez installer CodeIgniter vous devriez avoir une joli page « Hello World » si vous avez bien suivi les étapes ci dessus.

Allez, je vous laisse ici pour aujourd’hui, la prochaine fois on s’intéressera à la création de la base de données et au système de login sécurisé.