Aller au contenu principal

Module PHP.13 – Mini-projet

Objectif​

Créer un backend simple avec CRUD complet pour valider toutes les compétences PHP acquises.

Théorie​

CRUD​

CRUD signifie Create, Read, Update, Delete (Créer, Lire, Modifier, Supprimer).

Opérations de base :

  • Create : Créer une nouvelle entrée
  • Read : Lire/afficher des entrées
  • Update : Modifier une entrée existante
  • Delete : Supprimer une entrée

Architecture du projet​

Structure recommandée :

projet-crud/
├── public/
│   └── index.php          # Point d'entrée
├── src/
│   ├── Models/
│   │   └── Task.php       # Modèle de données
│   ├── Controllers/
│   │   └── TaskController.php
│   └── Views/
│       ├── list.php
│       ├── create.php
│       └── edit.php
├── data/
│   └── tasks.json         # Stockage (simule BDD)
└── README.md

Spécifications du projet​

Fonctionnalités​

1. Créer une tâche (Create)

  • Formulaire avec : titre, description, priorité, date
  • Validation des champs
  • Sauvegarde dans JSON
  • Message de confirmation

2. Lister les tâches (Read)

  • Afficher toutes les tâches
  • Afficher les détails de chaque tâche
  • Filtrer par statut (toutes, actives, terminées)
  • Trier par date, priorité

3. Modifier une tâche (Update)

  • Formulaire pré-rempli
  • Modification des champs
  • Sauvegarde des modifications
  • Message de confirmation

4. Supprimer une tâche (Delete)

  • Confirmation avant suppression
  • Suppression de la tâche
  • Message de confirmation

5. Fonctionnalités bonus

  • Marquer comme terminée
  • Recherche de tâches
  • Statistiques (nombre total, terminées, actives)

Structure de données​

Format JSON :

[
    {
        "id": 1,
        "titre": "Apprendre PHP",
        "description": "Maîtriser les bases",
        "priorite": "haute",
        "date": "2026-01-26",
        "termine": false,
        "date_creation": "2026-01-25"
    }
]

Guide de développement​

Étape 1 : Modèle (Model)

// src/Models/Task.php
class Task
{
    private int $id;
    private string $titre;
    private string $description;
    private string $priorite;
    private string $date;
    private bool $termine;
    
    // Constructeur, getters, setters
    // Méthodes : toArray(), fromArray()
}

Étape 2 : Service de données

// src/Services/TaskService.php
class TaskService
{
    private string $fichier = 'data/tasks.json';
    
    public function getAll(): array
    {
        // Lire et retourner toutes les tâches
    }
    
    public function getById(int $id): ?Task
    {
        // Retourner une tâche par ID
    }
    
    public function create(Task $task): bool
    {
        // Créer une nouvelle tâche
    }
    
    public function update(Task $task): bool
    {
        // Modifier une tâche
    }
    
    public function delete(int $id): bool
    {
        // Supprimer une tâche
    }
}

Étape 3 : Controller

// src/Controllers/TaskController.php
class TaskController
{
    private TaskService $service;
    
    public function index()
    {
        // Afficher la liste
    }
    
    public function create()
    {
        // Afficher formulaire création
    }
    
    public function store()
    {
        // Traiter création
    }
    
    public function edit(int $id)
    {
        // Afficher formulaire modification
    }
    
    public function update(int $id)
    {
        // Traiter modification
    }
    
    public function delete(int $id)
    {
        // Supprimer
    }
}

Étape 4 : Routes simples

// public/index.php
$action = $_GET['action'] ?? 'index';
$id = $_GET['id'] ?? null;

$controller = new TaskController();

switch ($action) {
    case 'create':
        $controller->create();
        break;
    case 'store':
        $controller->store();
        break;
    case 'edit':
        $controller->edit($id);
        break;
    case 'update':
        $controller->update($id);
        break;
    case 'delete':
        $controller->delete($id);
        break;
    default:
        $controller->index();
}

Critères d'évaluation​

Fonctionnalité (40%) :

  • CRUD complet fonctionnel
  • Validation des données
  • Gestion des erreurs

Code (30%) :

  • Structure MVC
  • Code organisé et commenté
  • Respect des bonnes pratiques

Sécurité (20%) :

  • Protection XSS
  • Validation des entrées
  • Gestion sécurisée des fichiers

Design (10%) :

  • Interface claire
  • Messages utilisateur appropriés

Exercice - Développement​

Suivez ces étapes pour développer votre projet :

  1. Setup (30 min)

    • Créez la structure de dossiers
    • Configurez l'autoloading
    • Créez le fichier JSON initial

  2. Modèle (1h)

    • Créez la classe Task
    • Implémentez toutes les méthodes
    • Testez avec PHP CLI

  3. Service (1h)

    • Créez TaskService
    • Implémentez CRUD
    • Testez chaque méthode

  4. Controller (1h30)

    • Créez TaskController
    • Implémentez toutes les actions
    • Gestion des erreurs

  5. Vues (1h30)

    • Créez les formulaires
    • Créez la liste
    • Ajoutez le style CSS

  6. Intégration (1h)

    • Connectez tout
    • Testez toutes les fonctionnalités
    • Corrigez les bugs

  7. Améliorations (1h)

    • Ajoutez les fonctionnalités bonus
    • Améliorez l'UX
    • Finalisez le design

Quiz de révision​

Avant de commencer, vérifiez vos connaissances :

  1. Comment créer une classe en PHP ?
  2. Comment lire/écrire un fichier JSON ?
  3. Comment valider les données POST ?
  4. Comment protéger contre XSS ?
  5. Comment structurer un projet MVC ?

Ressources​

Si vous êtes bloqué :

  • Revisitez les modules précédents
  • Documentation PHP officielle : php.net
  • Stack Overflow pour problèmes spécifiques

Bonnes pratiques à respecter :

  • Validation de toutes les entrées
  • Protection XSS partout
  • Gestion d'erreurs appropriée
  • Code commenté et documenté
  • Structure claire et organisée

Objectif final​

Créer une application CRUD complète qui démontre :

  • Maîtrise de la syntaxe PHP
  • Compréhension de la POO
  • Gestion des fichiers et JSON
  • Bonnes pratiques de sécurité
  • Organisation professionnelle du code

Validation : Vous avez terminé PHP quand votre application CRUD est fonctionnelle, sécurisée et bien organisée.

Félicitations ! Vous avez terminé l'apprentissage complet de PHP. Vous êtes maintenant capable de créer des applications web backend professionnelles.