Formulaire de connexion (vue)
Pour que l'on puisse se connecter il nous faudra en premier lieu, un formulaire digne de ce nom
avec un identifiant unique "Nom d'utilisateur" ou comme ici "Email" et un mot de passe.
On remarquera aussi quelques lignes de php simplement pour l'affichage des messages d'erreur.
<form action="" method="post">
<span><?php echo $error["login"]??""; ?></span>
<label for="email">Email</label>
<input type="email" name="email" id="email">
<span><?php echo $error["email"]??""; ?></span><br>
<label for="password">Mot de passe</label>
<input type="password" name="password" id="password">
<span><?php echo $error["pass"]??""; ?></span><br>
<input type="submit" value="Connexion">
</form>
Traitement du formulaire (contrôleur)
Notre traitement commencera par la fonction session_start qui permet l'accès aux variables de
session.
On notera que je défini la durée de vie des cookies utilisé ici à 3600 secondes.
Le nettoyage des cookies se fait à un rythme aléatoire, donc ils ne seront pas forcément
détruit après 3600 secondes.
// On lance la gestion des variables de session.
session_start([
"cookie_lifetime" => 3600
]);
// On vérifie si la variable de session logged existe et si elle est
// égale à true.
if(isset($_SESSION["logged"]) && $_SESSION["logged"] == true){
// Si connecté, on retourne l'utilisateur à la page d'accueil
header("Location: ../index.php");
exit;
}
Si l'utilisateur est déjà connecté, il n'a pas à avoir accès à cette page, on le renvoi donc vers l'index.
Nous déclarons ensuite les variables que l'on utilisera dans cette page.
La suite de notre code se trouvera dans une condition vérifiant si on arrive en méthode POST.
Et finira par l'inclusion de notre vue.
$email = $pass = "";
$error = array();
// Je vérifie si on arrive ici en méthode post.
if($_SERVER["REQUEST_METHOD"] == "POST"){
# Tout le reste de mon code ici #
}
// j'inclu mon formulaire.
include("../views/connexion.php");
On vérifie si les champs email et mot de passe ne sont pas vide.
Puis on retire les possibles espaces en trop.
// je vérifie si mes champs de formulaire ne sont pas vide.
if(empty($_POST["email"])){
$error["email"] = "Veuillez entrer un email.";
}else{
$email = trim($_POST["email"]);
}
if(empty($_POST["password"])){
$error["pass"] = "Veuillez entrer un mot de passe.";
}else{
$pass = trim($_POST["password"]);
}
On vérifie qu'il n'y ai pas d'erreur puis inclu notre modèle afin de pouvoir rechercher notre utilisateur avec la fonction "selectByEmail" qu'on aura défini dans celui-ci.
// On vérifie qu'il n'y ai pas d'erreur.
if(empty($error)){
// On inclu notre modèle puis recherche si on
// a un utilisateur avec cet email.
include("../models/user-model.php");
$user = selectByEmail($email);
// On vérifie si il y a bien un utilisateur correspondant
if($user){
# suite du code ici #
}
else{
$error["login"] = "Email ou Mot de passe incorrecte.";
}
}
Une fois notre sélection d'utilisateur faite, on vérifie
qu'on a bien obtenu un utilisateur.
sinon on donne un message d'erreur qui sera commun au nom
d'utilisateur et au mot de passe.
Pour des raisons de sécurité on ne précise pas où l'utilisateur
s'est trompé.
Avec password_verify(), on peut vérifier notre mot de passe en passant en argument notre mot de passe haché et celui donné par l'utilisateur lors de la connexion.
// On vérifie si le mot de passe correspond
if(password_verify($pass, $user["password"])){
// On défini des variables de session.
$_SESSION["logged"] = true;
$_SESSION["username"] = $user["username"];
$_SESSION["email"] = $user["email"];
$_SESSION["expire"] = time()+ (60*60);
header("location: ../index.php");
}
else{
$error["login"] = "Email ou Mot de passe incorrecte.";
}
Ensuite on défini nos variables de session avant de rediriger vers not accueil (ou autre):
- $_SESSION["logged"] servira à vérifier si l'utilisateur est connecté.
- $_SESSION["username"] et $_SESSION["email"] nous permettrons d'utiliser l'username et l'email de notre utilisateur sur d'autres pages sans relancer de connexion à la base de donnée.
- $_SESSION["expire"] nous permet de définir de façon plus efficace quand est ce que notre connexion prendra fin. (voir plus bas)
Obtenir le mot de passe (modèle)
Pour obtenir le mot de passe, on utilisera l'identifiant unique de l'utilisateur, selon les sites email ou username. (ici email)
function selectByEmail($email){
// On appelle notre fonction connexion();
$pdo = connexion();
// On prépapre notre requête.
$prep = $pdo->prepare(
'SELECT * FROM user WHERE email = :em'
);
// On execute notre requête.
$prep->execute([
"em" => $email
]);
// On retourne ce que l'on a trouvé :
return $prep->fetch();
}
En sélectionnant notre utilisateur de cette façon, si il n'est pas dans notre base de donnée, il n'y aura aucun résultat, donc notre contrôleur pourra renvoyer une erreur.
Vérifier la connexion (contrôleur bonus)
Être connecté est une chose, mais comment limiter certaines
de nos pages aux utilisateurs connectés?
C'est ce qu'on va faire avec le code suivant tout en vérifiant
que leur session n'est pas terminé.
session_start();
/* Si la session existe et si l'heure actuelle dépasse celle
enregistré dans la variable de session, alors on détruit notre session */
if(isset($_SESSION["expire"]) && time() > $_SESSION["expire"]){
$_SESSION = array();
session_destroy();
}
// Si l'utilisateur n'est pas connecté, l'accès est interdit.
if(!isset($_SESSION["logged"])){
header("Location: ../index.php");
exit;
}
Ce code peut être inserré dans toute page devant être
réservé à un utilisateur connecté.
On pourrait même y ajouter une modification de la variable
de session "expire" dans le cas où l'on voudrait qu'elle se
termine que si notre utilisateur est inactif pendant un
certain temps.
Deconnexion (contrôleur bonus)
On va faire simple, si on veut une déconnexion, il nous suffira d'un lien vers ce contrôleur :
session_start();
// On défini toute notre session comme un tableau vide
$_SESSION = array();
// On détruit notre session
session_destroy();
// puis on redirige notre utilisateur
header("location: login.php");
exit;
Vider la session et ajouter le exit; sont là par sécurité afin de prévenir de possibles erreurs, normalement détruire la session serait suffisant.