Une application web pour gérer tes tâches du quotidien. Tu peux créer des tâches, les modifier, les supprimer, et suivre leur avancement — le tout avec un vrai système de comptes utilisateurs.
Imagine un carnet de tâches numérique. Tu crées un compte, tu te connectes, et tu peux :
- Ajouter des choses à faire ("Faire mes devoirs", "Appeler mamie"…)
- Suivre leur état : En attente → En cours → Terminé
- Modifier ou supprimer une tâche
- Filtrer par statut pour voir uniquement ce qui est en cours, par exemple
Et le plus important : tes tâches n'appartiennent qu'à toi. Personne d'autre ne peut les voir.
Choisis l'une des deux options :
- Python 3.12+ installé sur ton ordinateur
- Docker Desktop installé et lancé
1. Ouvre un terminal dans le dossier du projet
2. Crée et active l'environnement virtuel
python -m venv .venv
# Sur Windows :
.venv\Scripts\activate
# Sur Mac/Linux :
source .venv/bin/activate3. Installe les dépendances
pip install -r requirements.txt4. Lance le serveur
uvicorn app.main:app --reload5. Ouvre ton navigateur sur http://localhost:8000 🎉
1. Lance tout en une seule commande
docker compose up --buildC'est tout ! Docker s'occupe de tout installer automatiquement.
2. Ouvre ton navigateur sur http://localhost:8000 🎉
Pour arrêter : Ctrl+C dans le terminal, puis docker compose down.
Quand tu ouvres l'application, tu arrives sur l'écran de connexion.
Clique sur l'onglet "Inscription", puis remplis :
- Nom d'utilisateur : au moins 3 caractères (ex:
alice) - Mot de passe : au moins 8 caractères (ex:
monsecret123)
Clique sur "S'inscrire" — tu arrives directement sur ta liste de tâches !
💡 La prochaine fois, utilise l'onglet "Connexion" avec ton nom et mot de passe.
Remplis le formulaire en haut de la page :
| Champ | Description | Exemple |
|---|---|---|
| Titre (obligatoire) | Ce que tu dois faire | Faire mes devoirs de maths |
| Description (optionnel) | Des détails en plus | Exercices page 42 et 43 |
| Statut | Où en es-tu ? | En attente |
| Priorité | À quel point c'est urgent ? | Haute |
| Date limite (optionnel) | Quand ça doit être fait | 2026-04-01 |
Clique sur "Ajouter la tâche" — elle apparaît dans ta liste ! ✅
Chaque tâche dans la liste a deux boutons :
- 🟠 Éditer — Ouvre une fenêtre pour modifier le titre, la description, le statut, la priorité ou la date limite
- 🔴 Supprimer — Supprime la tâche (une confirmation te sera demandée)
| Statut | Ce que ça veut dire | Couleur |
|---|---|---|
| En attente | Pas encore commencé | 🟡 Jaune |
| En cours | Tu travailles dessus | 🔵 Bleu |
| Terminé | C'est fini ! | 🟢 Vert |
| Priorité | Ce que ça veut dire | Couleur |
|---|---|---|
| Basse | Pas urgent, quand tu as le temps | 🟢 Vert |
| Normale | La priorité par défaut | 🟡 Jaune |
| Haute | À faire en premier ! | 🔴 Rouge |
En haut de ta liste, tu as des boutons de filtre :
[ Toutes ] [ En attente ] [ En cours ] [ Terminées ]
Clique sur "En cours" pour ne voir que ce sur quoi tu travailles, par exemple.
Clique sur "Se déconnecter" en haut à droite. Tes tâches sont sauvegardées — elles t'attendent à ta prochaine connexion !
CRUD = Create, Read, Update, Delete (Créer, Lire, Modifier, Supprimer)
C'est le cœur de l'application. Elle expose des endpoints HTTP (des adresses web) que la page HTML utilise pour communiquer avec le serveur.
| Action | Endpoint | Ce que ça fait |
|---|---|---|
| Lister les tâches | GET /tasks/ |
Récupère toutes tes tâches |
| Créer une tâche | POST /tasks/ |
Ajoute une nouvelle tâche |
| Voir une tâche | GET /tasks/{id} |
Récupère une tâche par son numéro |
| Modifier une tâche | PUT /tasks/{id} |
Met à jour le titre, statut… |
| Supprimer une tâche | DELETE /tasks/{id} |
Efface une tâche |
Tu peux aussi tester ces endpoints directement sur la documentation interactive : http://localhost:8000/docs
Sans base de données, toutes tes tâches disparaîtraient à chaque redémarrage du serveur. Grâce à SQLite, elles sont sauvegardées dans un fichier (data/tasks.db) et persistent indéfiniment.
Ce que ça change concrètement :
- ✅ Tu redémarres le serveur → tes tâches sont toujours là
- ✅ Plusieurs utilisateurs peuvent utiliser l'app en même temps
- ✅ Avec Docker, les données sont dans un volume — même
docker-compose downne les efface pas
Pour effacer toutes les données (remise à zéro) :
# Sans Docker
rm data/tasks.db
# Avec Docker
docker-compose down -vJWT = JSON Web Token, une sorte de carte d'identité numérique temporaire
C'est le système qui fait que chaque utilisateur a son propre espace privé.
Comment ça marche (simplement) :
Tu t'inscris
↓
Le serveur vérifie ton nom et mot de passe
↓
Il te donne un "token" (une longue chaîne de caractères chiffrée)
↓
Tu envoies ce token à chaque requête, comme une carte d'identité
↓
Le serveur sait qui tu es et te donne UNIQUEMENT tes tâches
Les garanties :
- 🔒 Ton mot de passe est chiffré (hashé) — même les développeurs ne peuvent pas le lire
- ⏱️ Le token expire au bout de 30 minutes — si quelqu'un le vole, il ne sert plus longtemps
- 🚫 Sans token valide, impossible d'accéder aux tâches (
403 Forbidden) - 👤 Bob ne peut jamais voir les tâches d'Alice, et vice versa
Les endpoints d'authentification :
| Action | Endpoint | Description |
|---|---|---|
| Créer un compte | POST /auth/register |
S'inscrire avec username + password |
| Se connecter | POST /auth/login |
Récupérer un token JWT |
Chaque tâche peut avoir un niveau de priorité et une date limite, pour mieux t'organiser.
La priorité indique à quel point une tâche est urgente :
| Valeur | Affichage | Quand l'utiliser |
|---|---|---|
low |
🟢 Basse | Pas pressé, ça peut attendre |
medium |
🟡 Normale | Le niveau par défaut |
high |
🔴 Haute | À faire en priorité absolue |
La date limite (due_date) est optionnelle. Si tu la remplis, elle s'affiche sur la tâche pour te rappeler quand elle doit être terminée.
Exemple — créer une tâche urgente avec date limite :
curl -X POST http://localhost:8000/tasks/ \
-H "Authorization: Bearer TON_TOKEN" \
-H "Content-Type: application/json" \
-d '{"title": "Rendre le devoir", "priority": "high", "due_date": "2026-04-01"}'Docker, c'est comme une boîte magique qui contient tout ce dont l'application a besoin pour fonctionner — peu importe l'ordinateur sur lequel tu la lances.
Le problème que Docker résout :
Sans Docker, tu pourrais avoir ce genre de situation :
- "Ça marche sur mon ordi mais pas sur le tien…"
- "J'ai oublié d'installer Python / une dépendance…"
- "La version de Python n'est pas la même…"
Avec Docker, plus aucun de ces problèmes.
Les fichiers Docker du projet :
| Fichier | Rôle |
|---|---|
Dockerfile |
La recette pour construire l'image de l'application |
docker-compose.yml |
Configure et lance les services (app + volume) |
.dockerignore |
Liste les fichiers à ne pas inclure dans l'image |
.env.example |
Exemple de configuration (copie-le en .env) |
Commandes utiles :
# Construire et démarrer
docker compose up --build
# Démarrer en arrière-plan
docker compose up -d --build
# Voir les logs
docker compose logs -f
# Arrêter (garde les données)
docker compose down
# Arrêter ET supprimer les données
docker compose down -vConfiguration via variables d'environnement :
Copie .env.example en .env et personnalise :
cp .env.example .env# Génère une clé secrète sécurisée :
# python -c "import secrets; print(secrets.token_urlsafe(32))"
SECRET_KEY=ta-cle-secrete-ici
DATABASE_URL=sqlite:///./data/tasks.db
⚠️ Ne partage jamais ton fichier.env— il contient des secrets !
Task-Api/
├── app/
│ ├── auth/ # Tout ce qui concerne les comptes utilisateurs
│ │ ├── crud.py # Créer/chercher des utilisateurs en base
│ │ ├── dependencies.py # Vérifier le token JWT à chaque requête
│ │ ├── routers.py # Les endpoints /auth/register et /auth/login
│ │ ├── schemas.py # La forme des données (username, password…)
│ │ └── security.py # Chiffrement des mots de passe + tokens JWT
│ ├── routers/
│ │ └── tasks.py # Les endpoints /tasks/* (CRUD)
│ ├── static/
│ │ └── index.html # L'interface web (ce que tu vois dans le navigateur)
│ ├── config.py # Variables d'environnement (SECRET_KEY, DATABASE_URL)
│ ├── crud.py # Les opérations sur les tâches en base de données
│ ├── database.py # Connexion à SQLite
│ ├── main.py # Point d'entrée de l'application FastAPI
│ ├── models.py # Structure des tables (User, Task)
│ └── schemas.py # Validation des données entrantes/sortantes
├── tests/ # Tous les tests automatiques
├── data/ # Base de données SQLite (créée automatiquement)
├── .env.example # Exemple de configuration
├── .env # Tes secrets (ne pas partager !)
├── Dockerfile # Recette Docker
├── docker-compose.yml # Orchestration des services
└── requirements.txt # Liste des dépendances Python
Le projet a une suite de 102 tests automatiques qui vérifient que tout fonctionne correctement. La couverture de code est à 100% — chaque ligne de code est testée.
# Activer le venv d'abord (Option A uniquement)
.venv\Scripts\activate # Windows
source .venv/bin/activate # Mac/Linux
# Lancer tous les tests
python -m pytest
# Avec le rapport de couverture détaillé
python -m pytest --cov=app --cov-report=term-missing| Problème | Solution |
|---|---|
Port 8000 déjà utilisé |
Change le port : uvicorn app.main:app --port 8001 |
Impossible d'ajouter des tâches |
Supprime data/tasks.db et redémarre le serveur |
Token expiré / déconnecté automatiquement |
C'est normal après 30 min, reconnecte-toi |
Username déjà pris |
Choisis un autre nom d'utilisateur |
Docker ne démarre pas |
Vérifie que Docker Desktop est bien lancé |
FastAPI génère automatiquement une documentation interactive où tu peux tester tous les endpoints directement depuis le navigateur :
- Swagger UI → http://localhost:8000/docs
- ReDoc → http://localhost:8000/redoc