Créer une application de planning en PHP et MySQL de zéro (sans framework)

Hello, dans ce court tutoriel, je vais vous présenter une appli assez simple et pratique et nous allons voir ensemble comment la construire. Il s’agit d’ une application de planning complète en PHP et MySQL, sans framework, en adoptant une architecture propre et structurée. L’objectif n’est pas seulement de faire fonctionner un calendrier, mais de comprendre comment concevoir une application maintenable, évolutive et correctement organisée.

Nous verrons également comment exécuter le projet en local, aussi bien dans un environnement classique (WAMP / Apache) qu’avec Docker, afin de couvrir les deux approches modernes de développement.

Prérequis :

Il est recommandé d’avoir déjà des bases en PHP et MySQL (variables, fonctions, requêtes SQL, PDO). Nous n’allons pas réexpliquer les fondamentaux, mais plutôt montrer comment les organiser proprement dans un projet réel.

Ce tutoriel est structuré en trois grandes parties :

1. Comprendre les fonctionnalités de l’application
2. Cloner et installer le projet sur votre machine
3. Tester et valider le fonctionnement complet

Comprendre les fonctionnalités de l’application

Avant de parler code ou installation, il est essentiel de comprendre ce que fait réellement l’application.

Il s’agit d’une application, un outils de planning moderne qui permet de :

• créer et gérer des événements calendaires,
• suivre des tâches avec statut (done / not done),
• organiser les éléments via des tags,
• visualiser des statistiques (priorités, statuts, volumes),
• exporter les données au format JSON ou ICS.

L’architecture repose sur plusieurs principes forts :

• un backend séparé du frontend,
• une logique métier centralisée dans des services,
• aucune requête SQL dans les vues,
• des migrations SQL versionnées pour garantir la reproductibilité.

Ce n’est donc pas un simple projet PHP, mais un exemple concret de structuration propre.

Cloner et installer le projet sur votre PC

Une fois que vous comprenez la logique du produit, vous pouvez passer à l’installation.

Deux options sont possibles :

Option 1 : Installation classique (sans Docker)

Cette approche convient si vous utilisez WAMP, XAMPP ou un environnement Apache local.

Étapes générales :

1. Cloner ou télécharger le projet en se rendant sur github via ce lien
2. Placer le dossier dans votre répertoire www.
3. Configurer la connexion MySQL si nécessaire.
4. Lancer les migrations SQL pour créer les tables.

php bin/migrate.php

5. Ouvrir l’URL locale dans votre navigateur.

http://localhost/simpleschedule/

Cette méthode est simple, rapide et adaptée à un développement individuel.

Option 2 : Installation avec Docker

Si vous préférez un environnement isolé et reproductible, Docker permet de lancer PHP + MySQL sans configuration système complexe. Votre notre tutoriel sur Docker.

Étapes générales :

1. Installer Docker Desktop.
2. Lancer docker compose up -d --build.
3. Exécuter les migrations dans le conteneur.
4. Accéder à l’application via le port configuré.

Cette approche est plus professionnelle et plus proche d’un environnement de production.

Tester et valider le fonctionnement

Une fois l’application lancée, il est important de vérifier qu’elle fonctionne correctement.

Voici ce que vous devez tester :

• Création d’un événement
• Ajout et association de tags
• Modification du statut d’une tâche
• Affichage correct des statistiques
• Recherche et filtrage
• Export JSON ou ICS

Ces tests permettent de valider à la fois :

• la cohérence du modèle de données,
• la solidité des services métier,
• la communication entre frontend et API,
• la fiabilité des migrations.

Si tout fonctionne comme prévu, vous disposez alors d’une base propre, prête à évoluer.

Présentation des interfaces (captures UI)

Avant d’entrer dans les détails techniques, voici un aperçu des principales interfaces de l’application.

Dashboard

Le tableau de bord affiche :

• statistiques globales,
• tâches prioritaires,
• événements récents,
• graphiques de répartition.

Gestion des événements

Interface principale de création et modification d’événements :

• titre
• description
• priorité
• statut
• dates
• tags associés

Gestion des tags

Permet d’organiser les événements et filtrer les vues.

Statistiques

Vue analytique avec graphiques (Chart.js) :

• nombre d’événements par statut
• répartition par priorité
• activité récente

Détails techniques de l’architecture

ne repose pas sur un framework complet comme Laravel ou Symfony. Le projet est volontairement développé en PHP pur afin de mieux maîtriser chaque couche et de comprendre précisément les responsabilités de chaque composant.

La couche Domain

La couche Domain représente le cœur logique de l’application.
On y trouve :

• les entités principales (Event, Tag),
• les interfaces de repository (EventRepositoryInterface, TagRepositoryInterface).

Cette couche ne contient aucune dépendance technique.
Elle définit simplement les règles et contrats métier.

C’est ici que l’on décrit ce qu’est un événement, un tag, et comment ils doivent être manipulés, indépendamment de la base de données ou de l’interface utilisateur.

La couche Application

La couche Application orchestre les cas d’usage.

On y retrouve :

• EventService
• TagService
• DashboardService
• StatsService
• des objets DTO comme EventPayload et EventFilters

C’est ici que se trouve la logique métier testable :

• création d’un événement,
• mise à jour du statut d’une tâche,
• filtrage par date ou priorité,
• calcul des statistiques.

Aucune requête SQL ne doit apparaître ici.
La couche Application appelle uniquement les interfaces définies dans Domain.

La couche Infrastructure

C’est la couche technique concrète.

Elle contient :

• ConnectionFactory (PDO),
• PdoEventRepository,
• PdoTagRepository,
• les requêtes SQL réelles.

Toutes les interactions avec MySQL sont centralisées ici.

Cela permet de :

• changer de base de données plus facilement,
• éviter la duplication de requêtes,
• garder la logique métier propre et indépendante.

La couche Presentation

Cette couche regroupe :

• les endpoints API JSON (api/)
• les pages PHP du frontend
• la gestion des requêtes HTTP

Les endpoints appellent les services de la couche Application, récupèrent les données et les renvoient en JSON.

Le frontend consomme ensuite cette API pour afficher :

• le dashboard,
• le calendrier,
• les tâches,
• les statistiques.

Bootstrap et composition

Le projet utilise :

• un autoloader personnalisé,
• un container de dépendances simple,
• un fichier bootstrap/app.php pour composer les services.

Cela permet d’initialiser proprement :

• la connexion base de données,
• les repositories,
• les services,
• les contrôleurs.

La composition est centralisée, ce qui évite les instanciations sauvages dans le code.

Migrations versionnées

Le dossier database/migrations contient les scripts SQL versionnés.

Le runner :

php bin/migrate.php

• crée la base si nécessaire,
• applique uniquement les migrations non exécutées,
• enregistre l’historique dans schema_migrations.

Ce mécanisme garantit la reproductibilité du projet sur n’importe quelle machine.

En résumé

Voilà, téléchargez le projet sur le dépot GitHub, tester l »application et améliorez là à votre guise. Ce serai d’avoir un retour d’expérience de vos améliorations.

A très bientôt !