Django Blog - Projet d'apprentissage

Ce projet est un blog simple développé avec Django, créé dans le but d'apprendre et de comprendre les concepts fondamentaux du framework Django.

📚 Concepts Django appris

Ce projet couvre les concepts essentiels suivants :

1. Architecture MVT (Model-View-Template)

• Models : Création d'un modèle BlogPost avec différents types de champs
• Views : Utilisation de vues génériques basées sur les classes (CBV)
• Templates : Système de templates avec héritage et inclusion

2. Modèles et Base de données

• Création d'un modèle avec différents types de champs (CharField, TextField, BooleanField, DateField, etc.)
• Relations entre modèles (ForeignKey avec le modèle User)
• Génération automatique de slug à partir du titre
• Méthodes personnalisées (__str__, save, propriétés)
• Configuration avec SQLite (possibilité de basculer vers PostgreSQL)

3. Vues génériques (Class-Based Views)

• ListView : Afficher la liste des articles
• DetailView : Afficher un article en détail
• CreateView : Créer un nouvel article
• UpdateView : Modifier un article existant
• DeleteView : Supprimer un article

4. Système d'authentification

• Restriction d'accès aux vues avec @login_required
• Affichage conditionnel dans les templates selon l'authentification
• Filtrage des articles publiés pour les utilisateurs non authentifiés

5. URLs et Routing

• Configuration des URLs au niveau du projet et de l'application
• Utilisation de app_name pour les espaces de noms
• URLs dynamiques avec paramètres (slug)
• Fonction reverse_lazy pour les redirections

6. Interface d'administration Django

• Configuration personnalisée de l'admin avec ModelAdmin
• list_display : Colonnes affichées dans la liste
• list_editable : Modification rapide depuis la liste

7. Templates et Héritage

• Template de base (base.html) avec blocs réutilisables
• Héritage de templates avec {% extends %}
• Utilisation de {% block %} pour les sections personnalisables
• Fichiers statiques (CSS) avec {% static %}
• Tags de template ({% url %}, {% if %}, etc.)

8. Fonctionnalités supplémentaires

• Integration de django-livereload pour le rechargement automatique en développement
• Organisation du projet avec une structure claire
• Gestion des fichiers statiques

🏗️ Structure du projet

django_blog/
├── .env/                          # Environnement virtuel Python
├── src/                           # Code source du projet
│   ├── blog/                      # Configuration du projet Django
│   │   ├── settings.py           # Paramètres du projet
│   │   ├── urls.py               # URLs principales
│   │   └── wsgi.py               # Configuration WSGI
│   ├── posts/                     # Application "posts"
│   │   ├── migrations/           # Migrations de base de données
│   │   ├── templates/posts/      # Templates de l'application
│   │   │   ├── blogpost_list.html
│   │   │   ├── blogpost_detail.html
│   │   │   ├── blogpost_create.html
│   │   │   ├── blogpost_edit.html
│   │   │   └── blogpost_confirm_delete.html
│   │   ├── static/               # Fichiers statiques (CSS, JS, images)
│   │   ├── models.py             # Modèle BlogPost
│   │   ├── views.py              # Vues de l'application
│   │   ├── urls.py               # URLs de l'application
│   │   └── admin.py              # Configuration de l'admin
│   ├── templates/                 # Templates globaux
│   │   └── base.html             # Template de base
│   ├── manage.py                  # Script de gestion Django
│   └── db.sqlite3                 # Base de données SQLite

🚀 Installation et utilisation

Prérequis

• Python 3.x
• pip

Installation

1. Activer l'environnement virtuel (si ce n'est pas déjà fait) :

   .\.env\Scripts\Activate.ps1

2. Installer les dépendances :

   pip install django django-livereload-server

3. Appliquer les migrations :

   python src\manage.py migrate

4. Créer un superutilisateur (pour accéder à l'admin) :

   python src\manage.py createsuperuser

5. Lancer le serveur de développement :

   python src\manage.py runserver

Utilisation

• Page d'accueil : http://localhost:8000/blog/
• Interface d'administration : http://localhost:8000/admin/
• Créer un article : http://localhost:8000/blog/create/ (nécessite d'être connecté)

Fonctionnalités

• ✅ Afficher la liste des articles publiés
• ✅ Voir le détail d'un article
• ✅ Créer un nouvel article (utilisateur connecté uniquement)
• ✅ Modifier un article existant
• ✅ Supprimer un article
• ✅ Publier/dépublier un article depuis l'admin
• ✅ Génération automatique du slug depuis le titre
• ✅ Filtrage des articles non publiés pour les visiteurs

📝 Modèle de données

BlogPost

• title : Titre de l'article (CharField, unique)
• slug : Slug généré automatiquement (SlugField, unique)
• author : Auteur de l'article (ForeignKey vers User)
• content : Contenu de l'article (TextField)
• published : Statut de publication (BooleanField)
• created_on : Date de création (DateField)
• last_updated : Date de dernière modification (DateTimeField, auto)

🔐 Authentification

• Les utilisateurs non authentifiés ne voient que les articles publiés
• Les utilisateurs authentifiés voient tous les articles
• La création d'articles nécessite une authentification
• L'interface d'administration nécessite un compte superutilisateur

🎓 Ce que j'ai appris

Ce projet m'a permis de comprendre :

• Comment structurer un projet Django
• L'utilisation de l'ORM Django pour interagir avec la base de données
• Les vues génériques et leur puissance pour réduire le code
• Le système de templates et l'héritage
• La gestion de l'authentification et des permissions
• L'interface d'administration Django et sa personnalisation
• Le routing des URLs
• L'organisation du code en applications réutilisables

🔧 Technologies utilisées

• Django 5.2.8 : Framework web Python
• SQLite : Base de données (possibilité de passer à PostgreSQL)
• django-livereload : Rechargement automatique en développement
• Python 3.x : Langage de programmation

📌 Notes

• La SECRET_KEY et les credentials sont exposés dans ce projet car il s'agit d'un projet d'apprentissage local
• En production, il faudrait :
  • Utiliser des variables d'environnement pour les secrets
  • Mettre DEBUG = False
  • Configurer ALLOWED_HOSTS
  • Utiliser une base de données plus robuste (PostgreSQL)
  • Configurer les fichiers statiques avec un serveur web (nginx/Apache)

---

Projet créé à des fins d'apprentissage de Django 🎯