Projet MAI : Système de Réservation de Taxis —
Dossier Complet
1. Introduction
Ce document présente un projet complet pour un système de réservation de taxis destiné à un cours de
MAI (Modélisation et Analyse Informatique). Il comprend : la problématique, les exigences, les modèles
conceptuels et logiques des données, les diagrammes UML (classes, cas d'utilisation, séquences), le
schéma de base de données (SQL), l'API REST proposée, les cas de test, et les étapes de déploiement.
2. Problématique
Comment concevoir et modéliser un système informatique qui facilite la réservation de taxis entre des
clients et des chauffeurs tout en assurant la gestion des courses, des paiements et des disponibilités ?
Objectifs généraux
Permettre aux clients de réserver un taxi, aux chauffeurs de recevoir et gérer les demandes, et au
gestionnaire de suivre les activités et revenus.
Objectifs spécifiques
• Enregistrer et gérer les clients, chauffeurs et véhicules.
• Gérer les réservations et l’assignation des courses.
• Calculer automatiquement le montant des courses selon la distance ou tarifs définis.
• Suivre l'état des taxis (disponible, en course, en maintenance).
• Fournir des rapports journaliers/mensuels de recettes et d’activité.
3. Exigences fonctionnelles & non-fonctionnelles
Exigences fonctionnelles (FR)
• FR1 : Inscription/Authentification des clients et chauffeurs.
• FR2 : Création et annulation de réservations par le client.
• FR3 : Acceptation/rejet d’une réservation par le chauffeur.
• FR4 : Calcul du tarif et enregistrement du paiement.
• FR5 : Gestion du catalogue des taxis et disponibilités.
• FR6 : Génération de rapports (courses, revenus).
Exigences non-fonctionnelles (NFR)
• NFR1 : Sécurité des données (authentification, stockage sécurisé des mots de passe).
• NFR2 : Disponibilité raisonnable (service 24/7 attendu).
• NFR3 : Performance : réponses rapides pour recherche de chauffeurs.
• NFR4 : Scalabilité pour augmenter le nombre d’utilisateurs et courses.
• NFR5 : Conformité aux règles locales de la fiscalité et transport.
4. Acteurs et cas d'utilisation (Use Cases)
Acteurs principaux : Client, Chauffeur, Administrateur
Cas d'utilisation principaux :
• UC1 : S’inscrire / Se connecter
• UC2 : Rechercher et réserver un taxi
• UC3 : Accepter une réservation (chauffeur)
• UC4 : Démarrer / Terminer une course
• UC5 : Payer une course
• UC6 : Consulter l’historique des courses
• UC7 : Gérer le parc de taxis (administrateur)
5. Modèle Conceptuel de Données (MCD)
Entités et attributs (avec clés primaires en majuscules) :
ENTITÉ ATTRIBUTS (PK)
Client idClient (PK), nom, prenom, telephone, email, mot_de_passe, date_inscription
Chauffeur idChauffeur (PK), nom, prenom, telephone, permis, statut (disponible/en_course)
Taxi idTaxi (PK), matricule, marque, modele, capacite, etat, idChauffeur (FK)
Réservation idReservation (PK), idClient (FK), idTaxi (FK), idChauffeur (FK), depart, destination, date_he
Course idCourse (PK), idReservation (FK), distance_km, duree_min, montant, date_heure_debut, da
Paiement idPaiement (PK), idCourse (FK), montant, mode, date_paiement, statut_paiement
6. Modèle Logique (MLD) & Schéma relationnel
Proposition de tables SQL (types indicatifs) :
CREATE TABLE Client ( idClient SERIAL PRIMARY KEY, nom VARCHAR(100) NOT NULL,
prenom VARCHAR(100), telephone VARCHAR(20), email VARCHAR(150) UNIQUE,
mot_de_passe VARCHAR(255) NOT NULL, date_inscription TIMESTAMP DEFAULT
CURRENT_TIMESTAMP ); CREATE TABLE Chauffeur ( idChauffeur SERIAL PRIMARY KEY,
nom VARCHAR(100) NOT NULL, prenom VARCHAR(100), telephone VARCHAR(20), permis
VARCHAR(50), statut VARCHAR(20) DEFAULT 'disponible' ); CREATE TABLE Taxi (
idTaxi SERIAL PRIMARY KEY, matricule VARCHAR(20) UNIQUE, marque VARCHAR(50),
modele VARCHAR(50), capacite INT, etat VARCHAR(20), idChauffeur INTEGER
REFERENCES Chauffeur(idChauffeur) ); CREATE TABLE Reservation ( idReservation
SERIAL PRIMARY KEY, idClient INTEGER REFERENCES Client(idClient), idTaxi INTEGER
REFERENCES Taxi(idTaxi), idChauffeur INTEGER REFERENCES Chauffeur(idChauffeur),
depart VARCHAR(255), destination VARCHAR(255), date_heure TIMESTAMP, statut
VARCHAR(20) -- (en_attente, acceptée, annulée) ); CREATE TABLE Course ( idCourse
SERIAL PRIMARY KEY, idReservation INTEGER REFERENCES Reservation(idReservation),
distance_km NUMERIC(8,2), duree_min INTEGER, montant NUMERIC(10,2),
date_heure_debut TIMESTAMP, date_heure_fin TIMESTAMP ); CREATE TABLE Paiement (
idPaiement SERIAL PRIMARY KEY, idCourse INTEGER REFERENCES Course(idCourse),
montant NUMERIC(10,2), mode VARCHAR(50), date_paiement TIMESTAMP DEFAULT
CURRENT_TIMESTAMP, statut_paiement VARCHAR(20) );
Indexes et requêtes utiles
• 1) Liste des chauffeurs disponibles près d'un point (requête avec géolocalisation si coordonnés
stockées).
• 2) Requêtes de rapport mensuel : SELECT SUM(montant) FROM Course WHERE date_heure_debut
BETWEEN ...
• 3) Historique client : SELECT * FROM Reservation WHERE idClient = ? ORDER BY date_heure DESC
7. Diagramme de classes UML (description)
Classes principales (attributs + méthodes publiques proposées) :
Client
Attributs : idClient, nom, prenom, telephone, email, motDePasse
Méthodes : sInscrire(), seConnecter(), reserverTaxi()
Chauffeur
Attributs : idChauffeur, nom, prenom, telephone, permis, statut
Méthodes : accepterReservation(), demarrerCourse(), terminerCourse()
Taxi
Attributs : idTaxi, matricule, marque, modele, capacite, etat
Méthodes : mettreAJourEtat()
Reservation
Attributs : idReservation, idClient, idChauffeur, depart, destination, dateHeure, statut
Méthodes : annuler(), confirmer()
Course
Attributs : idCourse, idReservation, distanceKm, dureeMin, montant
Méthodes : calculerMontant()
Paiement
Attributs : idPaiement, idCourse, montant, mode, datePaiement, statut
Méthodes : effectuerPaiement()
8. Diagrammes de séquence (scénarios clés)
Scénario : Réservation d’un taxi
• Client -> Système : Demande de réservation (depart, destination, date_heure)
• Système -> Base : Recherche chauffeurs disponibles
• Système -> Chauffeur : Envoi de la notification de demande
• Chauffeur -> Système : Accepte la réservation
• Système -> Client : Confirme la réservation
• Système -> Taxi/Chauffeur : Création de la course
Scénario : Paiement après course
• Client -> Système : Demande de paiement (mode choisi)
• Système -> ServicePaiement : Traitement du paiement (ex: Mobile Money)
• ServicePaiement -> Système : Confirmation du paiement
• Système -> Base : Enregistrement du Paiement
• Système -> Client/Chauffeur : Envoi du reçu
9. Proposition d'API REST
Endpoints principaux (exemples) :
• POST /api/auth/register (inscription client/chauffeur)
• POST /api/auth/login
• GET /api/taxis/available?lat=...&lng;=...&radius;=...
• POST /api/reservations (créer une réservation)
• PUT /api/reservations/{id}/cancel (annuler)
• PUT /api/reservations/{id}/accept (chauffeur accepte)
• POST /api/courses/{id}/complete (terminer course et calculer montant)
• POST /api/payments (enregistrer paiement)
• GET /api/reports/daily?date=YYYY-MM-DD
10. Interface utilisateur (wireframes décrits)
• Écran d'accueil : bouton réserver, connexion, accéder à l'historique.
• Écran réservation : champs départ/destination/date-heure, bouton Rechercher.
• Écran chauffeur : liste des demandes entrantes (Accepter/Rejeter).
• Écran course : démarrer/terminer, voir itinéraire et montant estimé.
• Écran administrateur : tableau de bord (nombre de courses, revenus).
11. Plan de tests (exemples)
• Test 1 : Inscription et connexion client (cas valides/invalides).
• Test 2 : Création d’une réservation et acceptation par le chauffeur.
• Test 3 : Calcul du montant selon distance et tarifs (cas limites).
• Test 4 : Annulation d’une réservation et remboursement (si applicable).
• Test 5 : Génération d’un rapport journalier de revenus.
12. Architecture technique & Déploiement
Proposition d'architecture : Client mobile (Flutter/React Native) ou Web (React) -> API REST
(Node.js/Express ou Django REST) -> Base de données relationnelle (PostgreSQL). Service de paiement
tiers (Mobile Money), service de géolocalisation (Google Maps / OpenStreetMap).
Étapes de déploiement
• 1. Définir les exigences détaillées et rédiger les user stories.
• 2. Concevoir la base de données et les diagrammes UML (MCD, classes).
• 3. Implémenter l'API et la couche de persistance (CRUD).
• 4. Développer l'interface client et chauffeur.
• 5. Intégrer le service de paiement et la cartographie.
• 6. Tests, correction des bugs et mise en production.
13. Annexes : requêtes SQL utiles
-- Total recettes pour une date donnée SELECT SUM(montant) AS total_recettes
FROM Course WHERE date_heure_debut::date = '2025-10-24'; -- Historique d'un
client SELECT r.*, c.montant FROM Reservation r LEFT JOIN Course c ON
c.idReservation = r.idReservation WHERE r.idClient = 123 ORDER BY r.date_heure
DESC; -- Chauffeurs disponibles SELECT * FROM Chauffeur WHERE statut =
'disponible';
14. Conclusion
Ce dossier fournit un guide complet pour réaliser un projet MAI sur un système de réservation de taxis. Tu
peux l'utiliser tel quel pour ton rendu : il contient les schémas conceptuels et logiques, la proposition d'API,
les cas d'utilisation et un plan de tests. Si tu veux, je peux maintenant : générer les diagrammes UML
visuels (images), fournir le script SQL prêt à exécuter, ou préparer un diaporama de présentation.
