Comment j’ai réussi mon premier gros projet en Django …

1. Contexte et objectifs du projet

LITRevu est une application web de critiques de livres développée dans le cadre de ma formation de développeuse d’applications Python.
L’objectif était de concevoir une plateforme complète permettant à des utilisateurs de :

• Créer des tickets (demandes de critiques ou recommandations),
• Rédiger des avis de lecture,
• Suivre d’autres membres de la plateforme,
• Consulter un flux personnalisé combinant leurs propres contenus et ceux des utilisateurs suivis.

Au-delà de l’aspect fonctionnel, le projet devait démontrer ma capacité à :

• Structurer une application suivant les bonnes pratiques Django,
• Gérer l’authentification, les permissions et la sécurité,
• Assurer la qualité du code (tests, linting, couverture),
• Préparer une configuration de production (Docker, variables d’environnement, déploiement).

---

2. Architecture technique et choix de stack

2.1. Back-end : Python & Django

Pour le back-end, j’ai choisi Django afin de tirer parti :

• De son ORM pour modéliser les entités du domaine (utilisateurs, tickets, critiques, relations de suivi),
• De son système d’authentification intégré, que j’ai adapté à mon modèle utilisateur,
• De la gestion des formulaires (création / édition de tickets et de critiques),
• De la séparation claire entre vues, templates et logique métier.

J’ai défini des vues dédiées pour :

• Le flux principal (combinaison des tickets et critiques pertinents),
• La page “Mes posts” (contenus de l’utilisateur connecté),
• La gestion des abonnements (suivre / ne plus suivre un utilisateur),
• Les pages CRUD (création, modification, suppression) pour tickets et reviews.

2.2. Front-end : Django Templates & Tailwind CSS

Côté front-end, j’ai utilisé :

• Les templates Django pour générer les pages côté serveur,
• Tailwind CSS et DaisyUI pour :
• Structurer la mise en page,
• Gérer la typographie, les couleurs et les espacements,
• Construire des composants réutilisables (cartes, boutons, formulaires, alertes).

L’intégration Tailwind a été configurée au niveau du projet via Node/npm, avec un script de build dédié pour générer un CSS optimisé ensuite servi par Django.

---

3. Fonctionnalités principales de LITRevu

3.1. Authentification et gestion des utilisateurs

• Inscription, connexion et déconnexion des utilisateurs,
• Gestion d’un profil basique via le modèle utilisateur personnalisé,
• Protection des vues critiques par des décorateurs (login_required) et redirections appropriées.

3.2. Tickets et critiques (reviews)

• Création de tickets pour demander une critique d’ouvrage,
• Création d’avis de lecture :
• soit en réponse à un ticket existant,
• soit ticket + critique en une seule opération.
• Modification et suppression des tickets et critiques par leur auteur uniquement,
• Validation et messages d’erreur pour garantir la cohérence des données.

3.3. Flux personnalisé et “Mes posts”

• Flux (“feed”) unifié affichant :
• les tickets et critiques de l’utilisateur,
• les contenus des utilisateurs qu’il suit.
• Page “Mes posts” pour retrouver et gérer facilement ses propres tickets et avis,
• Pagination pour éviter les listes trop longues.

3.4. Système d’abonnements (follows)

• Recherche d’utilisateurs et possibilité de les suivre / ne plus suivre,
• Affichage de la liste des abonnements et abonnés,
• Intégration du système de suivi dans la génération du flux principal.

---

4. Démarche de développement et organisation

4.1. Analyse et conception

J’ai commencé par :

• Relire attentivement le cahier des charges (user stories, règles de gestion),
• Identifier les modèles Django nécessaires (User, Ticket, Review, UserFollows),
• Définir la navigation entre les écrans (home, flux, mes posts, abonnements, formulaires),
• Structurer le projet en plusieurs apps (reviews, users) pour faciliter la maintenance.

4.2. Implémentation itérative

J’ai développé le projet par itérations fonctionnelles :

1. Mise en place de l’authentification et des modèles.
2. Création des tickets et critiques (formulaires, vues, templates).
3. Construction du flux combiné et de la page “Mes posts”.
4. Ajout du système de suivi entre utilisateurs.
5. Intégration de Tailwind & amélioration de l’UI.
6. Mise en place de la configuration de production (Docker, Render, variables d’environnement).

À chaque étape, j’ai veillé à garder le code testable, lisible et cohérent.

---

5. Qualité, tests et intégration continue

5.1. Tests unitaires et fonctionnels

Pour garantir la stabilité du projet, j’ai ajouté des tests sur :

• Les modèles (création de tickets/reviews, relations entre entités),
• Les vues critiques (flux, création/modification/suppression de contenu),
• Les comportements d’authentification (accès aux pages selon le statut connecté).

5.2. Linting et CI avec GitHub Actions

J’ai configuré :

• Flake8 pour vérifier la qualité du code et la conformité PEP8,
• Coverage pour mesurer la couverture de tests,
• Un workflow GitHub Actions pour :
• Installer les dépendances du projet,
• Lancer les tests Django,
• Exécuter le linting à chaque push ou pull request.

Cette intégration continue m’a permis de détecter rapidement les régressions et d’assurer un niveau de qualité constant.

---

6. Containerisation et déploiement sur Render

6.1. Dockerisation de l’application

J’ai rédigé un Dockerfile pour :

• Installer Python, les dépendances Django et les outils Node nécessaires à Tailwind,
• Lancer le build Tailwind (npm run tailwind:build),
• Exécuter python manage.py migrate et collectstatic,
• Démarrer l’application via Gunicorn.

L’objectif était de disposer d’une image reproductible, utilisable aussi bien en local qu’en production.

6.2. Configuration de production

Sur Render, j’ai configuré :

• Les variables d’environnement (secret key, debug, allowed hosts, CSRF trusted origins),
• L’utilisation de Whitenoise pour servir les fichiers statiques,
• SQLite comme base de données légère pour ce prototype.

Le résultat est une application Django/Tailwind déployée en ligne, accessible via une URL publique et prête à être référencée depuis mon site portfolio.

---

7. Apports du projet et perspectives

Ce projet LITRevu m’a permis de :

• Consolider mes compétences en Django (modèles, vues, templates, formulaires, auth),
• Mettre en pratique une intégration front-end moderne avec Tailwind CSS,
• Travailler la qualité du code (tests, linting, CI),
• Gérer une mise en production réelle avec Docker et Render.

La base est suffisamment solide pour envisager des évolutions futures, comme :

• Une API REST pour un front-end SPA ou mobile,
• Une intégration avec une base de données plus robuste (PostgreSQL),
• Des fonctionnalités avancées (tags, recommandations personnalisées, notifications).

LITRevu est aujourd’hui une démonstration concrète de ma capacité à mener un projet full stack Python/Django, depuis la conception jusqu’au déploiement en production.