Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Les cours de programmation

CRUD en AJAX sans rechargement de page

Ce cas pratique réalise une gestion complète des modules de formation sans aucun rechargement de page. Côté serveur, un contrôleur PHP orienté objet expose les actions lister, créer, modifier et suppr...

0 chapitres 0 QCM Accès gratuit
CRUD en AJAX sans rechargement de page

À propos de ce cours

Ce cas pratique réalise une gestion complète des modules de formation sans aucun rechargement de page. Côté serveur, un contrôleur PHP orienté objet expose les actions lister, créer, modifier et supprimer, répond en JSON avec des codes HTTP significatifs et réutilise le dépôt et la validation existants. Côté navigateur, une classe JavaScript affiche la table, ouvre une modale Bootstrap pour l'ajout et la modification, montre les erreurs de validation et met à jour la ligne concernée.

Objectifs de la leçon

  • Exposer un CRUD en JSON avec les bonnes méthodes HTTP.
  • Réutiliser dépôt et validation dans un contrôleur d'API.
  • Afficher et mettre à jour une table en JavaScript.
  • Gérer les erreurs de validation 422 dans une modale.
  • Appliquer une mise à jour optimiste et la sécurité CSRF.

1. Mise en situation

La coordinatrice gère une quarantaine de modules (code, intitulé, coefficient, heures). Avec le CRUD classique du chapitre 29, chaque modification provoque deux rechargements de page. Elle souhaite une interface de type application : modifier dans une fenêtre, voir la ligne changer immédiatement.

Nous allons réutiliser les classes existantes (Module, ModuleRepository) derrière un petit contrôleur JSON, et écrire côté navigateur une classe qui pilote la table. Créez la branche Git crud-ajax avant de commencer.

2. Les méthodes HTTP

Le CRUD en AJAX : méthodes et réponses

Le CRUD en AJAX : méthodes et réponses

ActionMéthodeURLSuccèsErreurs
ListerGET/api/modules200—
CréerPOST/api/modules201 + module422 validation
ModifierPATCH/api/modules/{id}200 + module404, 422
SupprimerDELETE/api/modules/{id}204404, 409 (notes liées)

Utiliser la bonne méthode et le bon code de réponse rend l'API prévisible : le JavaScript n'a qu'à tester le statut pour savoir quoi faire. C'est la base des API REST du chapitre 38.

3. La page HTML

<meta name="csrf" content="<?= $csrf->valeur() ?>">
<button class="btn btn-success mb-3" id="ajouter">+ Nouveau module</button>
<table class="table table-hover"><thead><tr><th>Code</th><th>Intitulé</th><th>Coef.</th><th>Heures</th><th></th></tr></thead>
  <tbody id="modules"></tbody></table>

<div class="modal fade" id="modale" tabindex="-1"><div class="modal-dialog"><form class="modal-content" id="form-module">
  <div class="modal-header"><h5 class="modal-title">Module</h5></div>
  <div class="modal-body">
    <input type="hidden" name="id">
    <div class="mb-2"><label class="form-label">Code</label><input class="form-control" name="code"><div class="invalid-feedback"></div></div>
    <div class="mb-2"><label class="form-label">Intitulé</label><input class="form-control" name="intitule"><div class="invalid-feedback"></div></div>
    <div class="mb-2"><label class="form-label">Coefficient</label><input class="form-control" name="coefficient" type="number" step="0.5"><div class="invalid-feedback"></div></div>
    <div class="mb-2"><label class="form-label">Heures</label><input class="form-control" name="heures" type="number"><div class="invalid-feedback"></div></div>
  </div>
  <div class="modal-footer"><button class="btn btn-primary">Enregistrer</button></div>
</form></div></div>

4. La classe JavaScript

class TableModules {
  #api = new ClientApi('/api');
  #corps = document.querySelector('#modules');
  #form = document.querySelector('#form-module');
  #modale = new bootstrap.Modal('#modale');

  async demarrer() {
    document.querySelector('#ajouter').addEventListener('click', () => this.#ouvrir());
    this.#form.addEventListener('submit', (e) => { e.preventDefault(); this.#enregistrer(); });
    const modules = await this.#api.get('/modules');
    this.#corps.replaceChildren(...modules.map((m) => this.#ligne(m)));
  }

  #ligne(m) {
    const tr = document.createElement('tr');
    tr.dataset.id = m.id;
    for (const valeur of [m.code, m.intitule, m.coefficient, m.heures]) {
      tr.insertCell().textContent = valeur;
    }
    const actions = tr.insertCell();
    actions.append(this.#bouton('Modifier', 'outline-primary', () => this.#ouvrir(m)),
                   this.#bouton('Supprimer', 'outline-danger', () => this.#supprimer(m, tr)));
    return tr;
  }

  #bouton(texte, style, action) {
    const b = Object.assign(document.createElement('button'), { textContent: texte, className: `btn btn-sm btn-${style} me-1` });
    b.addEventListener('click', action);
    return b;
  }

  #ouvrir(m = {}) {
    this.#form.reset();
    this.#form.querySelectorAll('.is-invalid').forEach((c) => c.classList.remove('is-invalid'));
    for (const [cle, valeur] of Object.entries(m)) { if (this.#form.elements[cle]) this.#form.elements[cle].value = valeur; }
    this.#modale.show();
  }

  async #enregistrer() {
    const donnees = Object.fromEntries(new FormData(this.#form));
    try {
      const m = donnees.id ? await this.#api.patch(`/modules/${donnees.id}`, donnees) : await this.#api.post('/modules', donnees);
      const nouvelle = this.#ligne(m);
      const ancienne = this.#corps.querySelector(`tr[data-id="${m.id}"]`);
      ancienne ? ancienne.replaceWith(nouvelle) : this.#corps.prepend(nouvelle);
      this.#modale.hide();
    } catch (e) {
      if (e.statut !== 422) throw e;
      for (const [champ, message] of Object.entries(e.details)) {
        const c = this.#form.elements[champ];
        c.classList.add('is-invalid');
        c.nextElementSibling.textContent = message;
      }
    }
  }

  async #supprimer(m, tr) {
    if (!confirm(`Supprimer le module ${m.code} ?`)) return;
    tr.classList.add('opacity-50');                       // mise à jour optimiste
    try { await this.#api.delete(`/modules/${m.id}`); tr.remove(); }
    catch (e) { tr.classList.remove('opacity-50'); alert(e.message); }   // 409 : module utilisé par des notes
  }
}

new TableModules().demarrer();

5. Mise en pratique : le contrôleur d’API ModuleApiController

<?php
declare(strict_types=1);

final class ModuleApiController
{
    public function __construct(private ModuleRepository $modules, private Autorisation $autorisation) {}

    public function lister(): ReponseJson
    {
        return ReponseJson::ok($this->modules->tous());                    // Module implémente JsonSerializable
    }

    public function creer(array $donnees): ReponseJson
    {
        $this->autorisation->exigerRole(Role::Responsable);
        $module = Module::depuisFormulaire($donnees);                        // lève ValidationException
        $this->modules->enregistrer($module);
        return ReponseJson::cree($module);
    }

    public function modifier(int $id, array $donnees): ReponseJson
    {
        $this->autorisation->exigerRole(Role::Responsable);
        $module = $this->modules->trouver($id) ?? throw NonTrouveException::entite('Module', $id);
        $module->modifier($donnees);
        $this->modules->enregistrer($module);
        return ReponseJson::ok($module);
    }

    public function supprimer(int $id): ReponseJson
    {
        $this->autorisation->exigerRole(Role::Responsable);
        $module = $this->modules->trouver($id) ?? throw NonTrouveException::entite('Module', $id);
        $this->modules->supprimer($module);                                  // lève ModuleUtiliseException (409)
        return ReponseJson::vide();
    }
}

// public/api.php : aiguillage minimal (un vrai routeur arrive au chapitre 34)
$verificateur->verifier($_SERVER['REQUEST_METHOD'], $_POST, getallheaders());   // CSRF
$corps = json_decode(file_get_contents('php://input') ?: '[]', true, flags: JSON_THROW_ON_ERROR);
preg_match('#^/api/modules(?:/(\d+))?$#', parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH), $m) || ReponseJson::erreur('Introuvable', 404)->envoyer();
$id = isset($m[1]) ? (int) $m[1] : null;
try {
    $reponse = match ([$_SERVER['REQUEST_METHOD'], $id === null]) {
        ['GET', true] => $c->lister(),
        ['POST', true] => $c->creer($corps),
        ['PATCH', false] => $c->modifier($id, $corps),
        ['DELETE', false] => $c->supprimer($id),
        default => ReponseJson::erreur('Méthode non autorisée', 405),
    };
} catch (ValidationException $e) {
    $reponse = ReponseJson::erreur('Données invalides', 422, $e->erreurs());
}
$reponse->envoyer();

Le contrôleur d’API des modules

Diagramme de classe UML de ModuleApiController

Le contrôleur ne contient ni SQL ni HTML : il orchestre des objets existants et renvoie des objets ReponseJson. Les exceptions non capturées ici (404, 409, 403) sont traduites par le gestionnaire global du chapitre 26.

Exercice Activités
  1. Quel code HTTP renvoyer après une création réussie ? Après une suppression ?
  2. Pourquoi PATCH plutôt que POST pour une modification ?
  3. Qu'est-ce qu'une mise à jour optimiste ?
  4. Pourquoi les contrôles de rôle sont-ils dans le contrôleur PHP et pas seulement dans le JavaScript ?
  5. Ajoutez un tri par colonne côté client en cliquant sur les en-têtes.
  6. Pourquoi TableModules construit-il les cellules avec textContent?
Correction
  1. 201 Created (avec l'objet créé) ; 204 No Content.
  2. PATCH exprime une modification partielle d'une ressource existante ; l'API devient prévisible et conforme aux conventions REST.
  3. Mettre à jour l'interface avant la réponse du serveur (ici, griser la ligne), puis annuler visuellement si le serveur renvoie une erreur.
  4. Le JavaScript s'exécute chez le client et peut être contourné ; seule la vérification côté serveur protège réellement.
  5. Garder la liste des modules dans un tableau, trier avec modules.sort((a, b) => String(a[col]).localeCompare(String(b[col]), 'fr', { numeric: true })), puis réafficher les lignes.
  6. Pour qu'un intitulé contenant du HTML ne soit jamais interprété : protection contre les XSS.

Résumé

  • Une API JSON : GET, POST, PATCH, DELETE avec des codes 200, 201, 204, 404, 409, 422.
  • Le contrôleur d'API réutilise dépôt, objets métier et autorisation.
  • Une classe JavaScript pilote la table et la modale Bootstrap.
  • Erreurs 422 affichées sous chaque champ ; mise à jour optimiste.
  • Sécurité côté serveur : session, rôle, jeton CSRF.

Cet article vous a-t-il aidé ?