RÉALISATION D’UNE APPLICATION WEB DE QUIZ EN PROGRAMMATION OBJET AVEC PHP

Table des matières

Introduction

L’objectif du projet est de développer une application accessible par internet, proposant à un utilisateur de choisir et de répondre à un quiz.
L’application permet à l’administrateur de gérer les quiz avec une interface d’administration.

Pourquoi présenter un quiz sur son site internet ?

 Le quiz peut s’employer de multiples façons sur un site internet et répondre à des objectifs d’interaction avec les visiteurs d’un site. Ils sont très utiles pour prendre contact avec les visiteurs, prolonger leur temps de présence sur un site et récupérer leurs coordonnées.

Plus largement, quels sont les différents types de questionnaires et leur emplois ?

Susciter l’intérêt et l’engagement Offrir des bons de réduction, des cadeaux Collecter des contacts : adresses mailQuiz amusant, offrant des cadeaux en échange d’une adresse mail
Tester les connaissances Collecter des contacts : adresses mailQuiz type scolaire Adapté pour un organisme de formation par exemple
Profiler pour déterminer l’offre la plus adaptée Collecter des contacts : adresses mail ou inciter à prendre contactQuestionnaire type profilage (selon le nombre de réponses A, nombres de réponses B, …),
Adapté par exemple pour un organisme proposant plusieurs offres personnalisées
Connaître les besoins pour adapter l’offre ou réaliser un devisQuestionnaire visant à obtenir les informations nécessaires pour aider la personne, établir un devis, Adapté par exemple à une agence immobilière, une offre sur devis

Si vous avez un projet de quiz ou de questionnaire pour votre site, discutons-en.

L’application

Et parce qu’une image vaut mieux qu’un long discours, voici le schéma de l’application.

L’utilisateur voit 3 pages : liste des quiz disponibles, liste des questions du quiz choisit et résultat.

Je définis un quiz comme étant un ensemble de questions sur un thème. Pour pouvoir jouer plusieurs fois sur un même thème, les questions sont choisies aléatoirement parmi une liste à chaque quiz.

Chaque question peut avoir plusieurs propositions correctes ou incorrectes. Pour chaque question, l’utilisateur choisit une proposition.

Lorsque les réponses aux questions sont envoyées, un score est calculé en fonction des bonnes réponses données. Le score est assorti d’un avis qui sera affiché sur la page de résultat.

Copies d’écrans

Voyons maintenant les copies d’écran de l’application, côté utilisateur.

Voici la copie d’écran de la liste des quiz disponibles.

Ecran d’accueil de l’utilisateur du quiz

Lorsque l’utilisateur a cliqué sur le bouton ‘Jouer’, il accède à un quiz, rassemblant des questions.

Ecran de jeu

Lorsque l’utilisateur a validé ses réponses en cliquant sur le bouton ‘Envoyer mes réponses’, il obtient, une page de résultat, comme par exemple :

Ecran de résultat

Les données

Pour faire fonctionner ce quiz, nous aurons besoin de plusieurs types de données.

Les Questionnaires contiennent les informations nécessaires pour afficher la liste de quiz disponibles : titre, description, nombre de questions du quiz, visibilité du quiz aux utilisateurs, logo, image de fond.
Les Questions sont les questions possibles pour un quiz, elles sont rattachées à un questionnaire. La seule information nécessaire est le libellé de la question.

Les Propositions sont les choix possibles pour l’utilisateur à la question. Les informations sont le libellé de la proposition et si cette proposition est une bonne réponse ou pas.

Les Avis contiennent les textes à afficher sur la page de résultat selon le score obtenu. Un avis est rattaché à un questionnaire. Les informations d’un avis sont le score minimum, le score maximum, le libellé de l’avis et l’effet associé à l’avis. Il ne peut y avoir qu’un seul avis pour un score. Et tous les scores possibles doivent avoir un avis.

Pour enregistrer les réponses des utilisateurs, nous avons également besoin des données sur les Quiz. Chaque quiz est rattaché à un questionnaire. Les informations à conserver sont le score et la date où le quiz a été joué.

Enfin, pour relier le quiz avec ses questions et enregistrer les réponses à chaque question, nous avons besoin des Réponses (ou QuestionQuiz). Pour chaque question, on y trouve la réponse apportée par l’utilisateur. Chaque réponse est reliée à un quiz et une question, d’où l’appellation ‘QuestionQuiz’.

Voici le schéma des données :

Schéma des données

Pour gérer toutes ces données facilement, nous avons besoin d’une interface d’administration.
Cette interface permet de :

  • ajouter, voir, modifier, supprimer les questionnaires
  • ajouter, voir, modifier, supprimer les questions
  • ajouter, voir, modifier, supprimer les propositions
  • ajouter, voir, modifier, supprimer les avis

On retrouve les 4 opérations principales de gestion : Create, Read, Update, Delete ou CRUD.

Voici les copies d’écrans de l’interface d’administration.

  • Voir tous les questionnaires :
    A partir de cette page, on peut ajouter un questionnaire.
Ecran d’accueil de l’administrateur
  • Voir un questionnaire :
    A partir de cette page, on peut modifier le questionnaire, voir les avis et voir les questions.
Ecran de gestion d’un questionnaire
  • Voir les avis :
    A partir de cette page, on peut ajouter un nouvel avis, modifier ou supprimer un avis existant.
Ecran de gestion des avis d’un questionnaire
  • Voir les questions d’un questionnaire :
    A partir de cette page, on peut ajouter une nouvelle question, modifier ou supprimer une question existante, voir les propositions liées à une question.
    La suppression d’une question, entraîne la suppression des propositions qui lui sont rattachées.
Ecran de gestion des questions d’un questionnaire
  • Voir les propositions :
    A partir de cette page, on peut ajouter une nouvelle proposition, modifier ou supprimer une proposition existante.
Ecran de gestion des propositions d’une question

Dans le code

Le code est structuré selon le modèle MVC (Modèle – Vue – Contrôleur).
Les 3 composantes de l’application sont séparées. Le modèle gère la logique métier du code et la gestion des données. La vue contrôle l’affichage des données. Le contrôleur gère les échanges avec l’utilisateur. Il reçoit une requête, demande des actions au modèle et envoie le résultat à la vue pour affichage à l’utilisateur.

Ce modèle d’organisation permet notamment de séparer les fonctions de l’application. Ainsi un développeur peut travailler sur le modèle et un autre sur les vues en même temps et sans interférer.

Voici la structure, plutôt simple, du projet :

Le fichier index.php est le point d’entrée de l’application pour les utilisateurs. C’est le routeur qui va aiguiller vers les fonctions selon la demande de l’utilisateur.
Le fichier admin.php permet la gestion des données grâce aux aux fonctions d’administration. C’est le routeur côté administration. Son accès est protégé par un mot de passe.
Le fichier style.css regroupe les instructions de design.
Le répertoire images contient les images utiles au site.
Le répertoire templates contient les modèles de pages.
Le répertoire src contient le code source de l’application.

Dans le répertoire src, le répertoire model contient les fonctions métier, l’ingénierie de l’application.
Dans le répertoire lib, on trouve les fonctions de connexion à la base de données. Ces fonctions sont utilisées par les fonctions du répertoire model.
Le répertoire controllers regroupe les fonctions réalisant l’interface entre le modèle (répertoire model) et la vue (répertoire templates).

Le modèle

On retrouve dans le répertoire model, un fichier par type de données.

Chaque fichier contient les classes et les fonctions utiles pour décrire les données, y accéder, les sélectionner, modifier.

Voici par exemple, le contenu de avis.php.

<?php

namespace Application\Model\Avis;

require_once('src/lib/database.php');

use Application\Lib\Database\DatabaseConnection;

// Avis à afficher selon les résultats d'un quiz
class Avis
{
    public int $identifier;
    public int $minimum;
    public int $maximum;
    public string $avis;
    public string $effet;
    public int $idQuestionnaire;
}

class AvisRepository
{
    public DatabaseConnection $connection;

    // Récupération d'un avis par son identifiant
    public function getAvis(string $identifier): ?Avis
    {
        $statement = $this->connection->getConnection()->prepare(
            "SELECT id, minimum, maximum, avis, effet, questionnaire_id FROM avis WHERE id = ?"
        );
        $statement->execute([$identifier]);

        $row = $statement->fetch();
        if ($row === false) {
            return null;
        }

        $avis = new Avis();
        $avis->identifier = $row['id'];
        $avis->minimum = $row['minimum'];
        $avis->maximum = $row['maximum'];
        $avis->avis = $row['avis'];
        $avis->effet = $row['effet'];
        $avis->idQuestionnaire = $row['questionnaire_id'];

        return $avis;
    }

    // Récupération de l'avis correspondant à un questionnaire et selon un score
    public function getAvisByScore(int $idQuestionnaire, int $score): ?Avis
    {
        $statement = $this->connection->getConnection()->prepare(
            "SELECT id, minimum, maximum, avis, effet, questionnaire_id FROM avis WHERE questionnaire_id = ? AND minimum <= ? AND maximum >= ?"
        );
        $statement->execute([$idQuestionnaire,$score,$score]);

        $row = $statement->fetch();
        if ($row === false) {
            return null;
        }

        $avis = new Avis();
        $avis->identifier = $row['id'];
        $avis->minimum = $row['minimum'];
        $avis->maximum = $row['maximum'];
        $avis->avis = $row['avis'];
        $avis->effet = $row['effet'];
        $avis->idQuestionnaire = $row['questionnaire_id'];

        return $avis;
    }

    // Récupération des avis correspondant à un questionnaire
    public function getAllAvis(int $idQuestionnaire): ?array
    {
        $statement = $this->connection->getConnection()->prepare(
            "SELECT id, minimum, maximum, avis, effet, questionnaire_id FROM avis WHERE questionnaire_id = ?"
        );
        $statement->execute([$idQuestionnaire]);

        $allAvis = [];
        while (($row = $statement->fetch())) {
            $avis = new Avis();
            $avis->identifier = $row['id'];
            $avis->minimum = $row['minimum'];
            $avis->maximum = $row['maximum'];
            $avis->avis = $row['avis'];
            $avis->effet = $row['effet'];
            $avis->idQuestionnaire = $row['questionnaire_id'];

            $allAvis[] = $avis;
        }

        return $allAvis;
    }

    // Création en DB d'un avis associé à un questionnaire
    public function createAvis(string $idQuestionnaire, int $minimum, int $maximum, string $avis,string $effet): int
    {
        $statement = $this->connection->getConnection()->prepare(
            'INSERT INTO avis(questionnaire_id, minimum, maximum, avis, effet) VALUES(?, ?, ?, ?, ?)'
        );
        $affectedLines = $statement->execute([$idQuestionnaire, $minimum, $maximum, $avis, $effet]);
        $identifier = $this->connection->getConnection()->lastInsertId();

        return ($identifier);
    }

    // Mise à jour en DB d'un avis par son identifiant
    public function updateAvis(string $identifier, int $minimum, int $maximum, string $avis, string $effet): bool
    {
        $statement = $this->connection->getConnection()->prepare(
            'UPDATE avis SET minimum = ?, maximum = ?, avis = ?, effet = ? WHERE id = ?'
        );
        $affectedLines = $statement->execute([$minimum, $maximum, $avis, $effet, $identifier]);

        return ($affectedLines > 0);
    }

    // Suppression d'un avis par son identifiant
    public function deleteAvis(string $identifier): bool
    {
        $statement = $this->connection->getConnection()->prepare(
            'DELETE FROM avis WHERE id = ?'
        );
        $affectedLines = $statement->execute([$identifier]);
        return ($affectedLines > 0);
    }

    // Vérifie si un avis existe déjà pour les valeurs souhaitées
    // Retourne true si l'avis existe
    public function checkExistAvis($identifier, int $minimum, int $maximum): bool
    {
        $ok = false;
        for ($i=$minimum; $i<=$maximum; $i++) {
            $statement = $this->connection->getConnection()->prepare(
                'SELECT COUNT(*) AS nb FROM avis WHERE questionnaire_id = ? AND minimum <= ? AND maximum >= ?'
            );
            $statement->execute([$identifier,$i,$i]);
            $row = $statement->fetch();
            if ($row !== false) {
                if ($row['nb'] > 0) { $ok = true; }
            }
        }

        return $ok;
    }
}

Le fichier contient :

  • La classe Avis
    • Les données : $identifier, $minimum, $maximum, $avis, $effet, $idQuestionnaire;
  • La classe AvisRepository
    • Les fonctions : getAvis, getAvisByScore, getAllAvis, createAvis, updateAvis, deleteAvis, checkExistAvis

Les fonctions contiennent des requêtes SQL pour échanger avec la base de données.

Pour les questionnaires, le fichier questionnaire.php contient :

  • La classe Questionnaire
    • Les données : $identifier, $title, $description, $frenchCreationDate, $nBQuestions, $logo, $fond
    • La fonction : getQuestionnaire
  • La classe QuestionnaireRepository
    • Les fonctions : getQuestionnaire, getQuestionnaires, createQuestionnaire, updateQuestionnaire

Pour les questions, le fichier question.php contient :

  • La classe Question
    • Les données : $identifier, $question, $idQuestionnaire
    • Les fonctions : getQuestion, getRandomQuestions
  • La classe QuestionRepository
    • Les fonctions : getQuestion , getQuestions, getRandomQuestions, createQuestion , updateQuestion , deleteQuestion , countQuestions

Pour les propositions, le fichier propositions.php contient :

  • La classe Proposition
    • Les données : $identifier, $idQuestion, $proposition, $correct
    • Les fonctions : getProposition, getPropositionsByQuestion
  • La classe PropositionRepository
    • Les fonctions : getProposition , getRandomPropositions, getPropositions, createProposition, updateProposition, deleteProposition, deletePropositions

Pour les quiz, le fichier quiz.php contient :

  • La classe Quiz
    • Les données : $identifier, $score, $idQuestionnaire, $frenchCreationDate
    • Les fonctions : viewQuiz, addQuiz, getQuestions, updateQuiz
  • La classe QuizRepository
    • Les fonctions : getQuiz, addQuestionsQuiz, createQuiz, updateQuiz

Pour les réponses, le fichier questionquiz.php contient :

  • La classe QuestionQuiz
    • Les données : $identifier, $idQuestion, $response, $idQuiz
    • La fonction : addQuestionQuiz
  • La classe QuestionQuizRepository
    • Les fonctions : getQuestionQuiz, getQuestionQuizsByQuiz, createQuestionQuiz, updateQuestionQuiz

Les contrôleurs

Dans ce répertoire, se trouvent deux fichiers homepage.php. L’un gère la page d’accueil de l’utilisateur, l’autre celle de l’administrateur.
Un fichier par type de données contient toutes les fonctions utiles pour faire l’interface entre le modèle, et la vue.

Voici par exemple le contrôleur pour les avis, utile pour la gestion des avis par l’administrateur :

<?php

namespace Application\Controllers\Admin\Avis;

require_once('src/lib/database.php');
require_once('src/model/questionnaire.php');
require_once('src/model/avis.php');

use Application\Lib\Database\DatabaseConnection;
use Application\Model\Questionnaire\QuestionnaireRepository;
use Application\Model\Avis\AvisRepository;

class Avis
{
    public function view($identifier,string $message)
    {
        $connection = new DatabaseConnection();

        // Récupération des infos du questionnaire
        $questionnaireRepository = new QuestionnaireRepository();
        $questionnaireRepository->connection = $connection;
        $questionnaire = $questionnaireRepository->getQuestionnaire($identifier);

        // Récupération des avis du questionnaire
        $avisRepository = new AvisRepository();
        $avisRepository->connection = $connection;
        $avis = $avisRepository->getAllAvis($identifier);

        // Appel de la vue
        require('templates/admin/view_avis.php');
    }

    public function add(int $idQuestionnaire, ?array $input, string $message)
    {
        $connection = new DatabaseConnection();

        // It handles the form submission when there is an input.
        if ($input !== null) {
            $message = '';
            if (!empty($input['avis']) && $input['minimum']>=0 && $input['maximum']>=0 && ($input['minimum']<=$input['maximum'])) {
                $minimum = $input['minimum'];
                $maximum = $input['maximum'];
                $avis = $input['avis'];
                $effet = $input['effet'];
            } else {
                throw new \Exception('Les données du formulaire sont invalides.');
            }

            $avisRepository = new AvisRepository();
            $avisRepository->connection = $connection;
            if ($avisRepository->checkExistAvis($idQuestionnaire,$minimum,$maximum)) {
                $message = "Attention ! Un avis avec des valeurs entre le minimum (". $minimum . ") et le maximum (" . $maximum . ") existe déjà.";
                header('Location: admin.php?action=voiravis&idquestionnaire=' . $idQuestionnaire.'&message='.$message);
            }

            $identifier = $avisRepository->createAvis($idQuestionnaire, $minimum, $maximum,$avis,$effet);
            if (!$identifier) {
                throw new \Exception("Impossible d'ajouter l'avis' !");
            } else {
                $message = "L'avis a été ajouté avec succès.";
                header('Location: admin.php?action=voiravis&idquestionnaire=' . $idQuestionnaire.'&message='.$message);
            }
        } else {
            // Otherwise, it displays the form.
            $questionnaireRepository = new QuestionnaireRepository();
            $questionnaireRepository->connection = $connection;
            $questionnaire = $questionnaireRepository->getQuestionnaire($idQuestionnaire);
            require('templates/admin/add_avis.php');
        }
            
    }

    public function update(int $identifier,$input,string $message)
    {
        $connection = new DatabaseConnection();

        // It handles the form submission when there is an input.
        if ($input !== null) {
            $minimum = 0;
            $maximum = 0;
            $avis = null;
            $effet = null;
            if ((isset($input['avis'])) && (isset($input['minimum'])) && (isset($input['maximum']))) {
                $avis = $input['avis'];
                $minimum = $input['minimum'];
                $maximum = $input['maximum'];
                $effet = $input['effet'];
            } else {
                throw new \Exception('Les données du formulaire sont invalides.');
            }

            $avisRepository = new AvisRepository();
            $avisRepository->connection = $connection;
            $success = $avisRepository->updateAvis($identifier, $minimum, $maximum, $avis, $effet);
            if (!$success) {
                throw new \Exception('Impossible de modifier l\'avis !');
            } else {
                $message = 'L\'avis a été modifié avec succès';
                header('Location: admin.php?action=modifieravis&id=' . $identifier.'&message='.$message);
            }
        } else {

            // Otherwise, it displays the form.

            $avisRepository = new AvisRepository();
            $avisRepository->connection = $connection;
            $avis = $avisRepository->getAvis($identifier);
            
            if ($avis === null) {
                throw new \Exception("L\'avis numéro $identifier n'existe pas.");
            }

            $questionnaireRepository = new QuestionnaireRepository();
            $questionnaireRepository->connection = $connection;
            $questionnaire = $questionnaireRepository->getQuestionnaire($avis->idQuestionnaire);

            if ($questionnaire === null) {
                throw new \Exception("Le questionnaire numéro $identifier n'existe pas.");
            }

            require('templates/admin/modify_avis.php');
        }
    }

    public function delete(int $identifier)
    {
        $message='';
        $connection = new DatabaseConnection();

        $avisRepository = new AvisRepository();
        $avisRepository->connection = $connection;
        $avis = $avisRepository->getAvis($identifier);
        if ($avis === null) {
            throw new \Exception("L'avis numéro $identifier n'existe pas.");
        }
        $success = $avisRepository->deleteAvis($identifier);
        if (!$success) {
            throw new \Exception("Impossible de supprimer l'avis' !");
        } else {
            $message = "L'avis a été supprimé avec succès";
            header('Location: admin.php?action=voiravis&idquestionnaire=' . $avis->idQuestionnaire .'&message='.$message);
        }
    }

    public function infoAvis($idQuestionnaire): string
    {
        $erreur = 0; $scores=[];
        $connection = new DatabaseConnection();
        $questionnaireRepository = new QuestionnaireRepository();
        $questionnaireRepository->connection = $connection;
        $questionnaire = $questionnaireRepository->getQuestionnaire($idQuestionnaire);

        $avisRepository = new AvisRepository();
        $avisRepository->connection = $connection;

        if ($questionnaire === null) {
            throw new \Exception("Le questionnaire numéro $idQuestionnaire n'existe pas.");
        }
        for ($i=0;$i<=$questionnaire->nbQuestions;$i++) {
            $reponse = $avisRepository->checkExistAvis($idQuestionnaire,$i,$i);
            if (!$reponse) {
                $erreur ++;
                $scores[] = $i;
            }
        }
        if ($erreur === 0) { $message = 'Tous les avis nécessaires existent pour ce questionnaire.'; }
        elseif ($erreur === 1) {
            $message = 'Il manque un avis pour le score ' . $scores[0];
        } else {
            $message = 'Il manque un avis pour les scores ';
            foreach ($scores as $score) {
                $message .= $score . ', ';
            }
            $message = substr($message, 0, -2) .  '.';
        }

        return($message);
    }
}

Il contient :

La classe Avis et ses fonctions :

  • view : permet de voir les avis d’un questionnaire. Elle récupère les informations du questionnaire (getQuestionnaire) et les avis qui lui sont rattachés (getAllAvis). Elle appelle ensuite la vue view_avis.php.
  • add : permet d’ajouter un avis à un questionnaire. Si aucune donnée n’est envoyée, elle affiche le formulaire de saisie en appelant la vue add_avis.php. Sinon elle vérifie les données et si elles sont correctes, elle crée l’avis (createAvis). Elle vérifie aussi si un avis existe déjà pour une des valeurs comprises entre le minimum et le maximum (checkExistAvis) et affiche un message pour alerter si c’est le cas. Elle renvoie ensuite vers la page de gestion des avis.
  • update : permet de modifier un avis. Si aucune donnée n’est envoyée, elle affiche le formulaire de saisie en appelant la vue modify_avis.php. Sinon elle vérifie les données et si elles sont correctes, elle modifie l’avis (updateAvis). Elle renvoie ensuite vers la page de modification de l’avis pour que l’utilisateur vérifie que tout est OK.
  • delete : elle récupère les informations de l’avis (getAvis), puis le supprime (deleteAvis) et affiche la page de gestion des avis.
  • infoAvis : cette fonction renvoie un message qui sera affiché sur la page de visualisation d’un questionnaire, afin d’indiquer à l’administrateur si les avis nécessaires pour jouer ce questionnaire existent. Par exemple, un questionnaire comportant 10 questions doit posséder des avis qui correspondent aux scores compris entre 0 et 10. S’il manque un avis pour une des valeurs, la fonction indiquera les scores pour lesquels il manque un avis.
    Cette fonction récupère les informations du questionnaire (getQuestionnaire). Pour chaque valeur de score, elle appelle la fonction de test (checkExistAvis). Puis elle renvoie un message construit en fonction des tests.

Les vues

Dans le répertoire, se trouvent les templates (vues) pour gérer l’affichage pour l’utilisateur.

  • homepage.php : page d’accueil, liste des questionnaires jouables,
  • quiz.php : page du quiz avec le formulaire présentant les questions et les propositions possibles,
  • resultat.php : page affichant le score et l’avis (message) correspondant à ce score

Et deux templates généraux :

  • layout.php : contient le code commun à toutes les pages,
  • error.php : contient le code pour l’affichage d’une page d’erreur

Dans le sous-répertoire admin on trouve les templates (vues) pour l’affichage pour l’administrateur.

  • Les modèles d’ajout : questionnaire, question, proposition, avis,
  • Les modèles de modification : formulaires pour questionnaire, question, proposition, avis,
  • Les modèles de visualisation : questionnaire, question, proposition, avis,
  • Et la page d’accueil homepage.php, affichant la liste des questionnaires existants.

Les routeurs

Voici un extrait de code de index.php.

<?php

require_once('src/controllers/homepage.php');
require_once('src/controllers/questionnaire.php');
require_once('src/controllers/quiz.php');

use Application\Controllers\Homepage\Homepage;
use Application\Controllers\Questionnaire\Questionnaire;
use Application\Controllers\Quiz\Quiz;

try {
    if (isset($_GET['action']) && $_GET['action'] !== '') {
        switch ($_GET['action']) {
           case 'repondre':      // Répondre à un quiz
                if (isset($_GET['id']) && $_GET['id'] > 0) {
                    $identifier = $_GET['id'];
                    $input = null;
                    if ($_SERVER['REQUEST_METHOD'] === 'POST') {
                        $input = $_POST;
                    }
                    (new Quiz())->answerQuiz($identifier,$input);
                } else {
                    throw new Exception('Impossible de répondre, aucun identifiant de quiz envoyé');
                }
                break;

        case 'jouer':       // Jouer à un quizz
            if (isset($_GET['id']) && $_GET['id'] > 0) {
                $identifier = $_GET['id'];

                (new Questionnaire())->play($identifier);
            } else {
                throw new Exception('Impossible de jouer, aucun identifiant de questionnaire envoyé');
            }
            break;
...

Selon, l’action demandée, le routeur appellera la fonction de l’objet souhaité.

Sans action définie, le fichier envoie vers la page d’accueil, qui présente les questionnaires qu’il est possible de jouer. Les autres actions possibles sont :

  • repondre : envoyer ses réponses à un quiz et obtenir son score,
  • jouer : lancer un quiz

Voici un extrait du fichier admin.php :

Les actions sont beaucoup plus nombreuses pour ce routeur !

<?php

require_once('src/controllers/admin/homepage.php');
require_once('src/controllers/questionnaire.php');
require_once('src/controllers/question.php');
require_once('src/controllers/proposition.php');
require_once('src/controllers/admin/avis.php');

use Application\Controllers\Admin\Homepage\Homepage;
use Application\Controllers\Questionnaire\Questionnaire;
use Application\Controllers\Question\Question;
use Application\Controllers\Proposition\Proposition;
use Application\Controllers\Admin\Avis\Avis;

try {
    if (isset($_GET['action']) && $_GET['action'] !== '') {
        switch ($_GET['action']) {
            case 'voirquestionnaire':           // Voir les détails d'un questionnaire
                if (isset($_GET['id']) && $_GET['id'] > 0) {
                    $identifier = $_GET['id'];
                    (new Questionnaire())->view($identifier);
                } else {
                        throw new Exception('Aucun identifiant de questionnaire envoyé');
                }
                break;

            case 'ajouterquestionnaire':        // Ajouter un questionnaire
                $input=null;
                $message='';
                if ($_SERVER['REQUEST_METHOD'] === 'POST') {
                    $input = $_POST;
                }
                (new Questionnaire())->add($input,$message);
                break;
...

Sans action définie, le fichier envoie vers la page d’accueil, qui présente les questionnaires existants. Les autres actions possibles sont :

  • voirquestionnaire : voir les détails d’un questionnaire,
  • ajouterquestionnaire : ajouter un nouveau questionnaire, affiche le formulaire de saisie et vérifie et enregistre les données soumises,
  • modifierquestionnaire : modifier un questionnaire existant, affiche le formulaire de modification ou réalise les modifications si des données valides sont soumises,
  • supprimerquestionnaire : après confirmation, supprime le questionnaire,
  • voirquestions : voir les questions d’un questionnaire,
  • ajouterquestion : ajouter une nouvelle question à un questionnaire, affiche le formulaire de saisie, vérifie et enregistre les données soumises,
  • modifierquestion : modifier une question existante, affiche le formulaire de modification ou enregistre les modifications si des données valides sont soumises,
  • supprimerquestion : après confirmation, supprime la question et les propositions qui lui sont rattachées,
  • voirpropositions : voir les propositions d’une question,
  • ajouterproposition : ajouter une nouvelle proposition à une question, affiche le formulaire de saisie, vérifie et enregistre les données soumises,
  • modifierproposition : modifier une proposition existante, affiche le formulaire de modification ou enregistre les modifications si des données valides sont soumises,
  • supprimerproposition : après confirmation, supprime la proposition,
  • voiravis : voir les avis d’un questionnaire,
  • ajouteravis : ajouter un avis à un questionnaire,
  • modifieravis : modifier un avis existant, affiche le formulaire de modification ou enregistre les modifications si des données valides sont soumises,
  • supprimeravis : après confirmation, supprime l’avis,

Conclusion

Cette application est un bon exercice de programmation orientée objet avec PHP en utilisant le modèle Modèle-Vue-Contrôleur (MVC). Mais c’est surtout une application utilisable sur de nombreux sites internet.

Elle peut permettre de collecter des contacts tout en offrant une expérience amusante aux utilisateurs. Elle peut aussi être adaptée pour répondre à des besoins particuliers. Par exemple, elle peut être adaptée pour proposer des questionnaires de profilage ou des questionnaires pour l’établissement d’un devis.

Laisser un commentaire