Documentation sphynx

.coveragerc

@@ -0,0 +1,5 @@
+[run]
+omit =
+    */tests/*
+    */migrations/*
+    */__init__.py

.dockerignore

@@ -0,0 +1,7 @@
+.env
+.git
+.gitignore
+__pycache__/
+*.pyc
+*.pyo
+*.pyd

.github/workflows/pipeline.yml

@@ -0,0 +1,86 @@
+name: Pipeline
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  compile:
+
+    runs-on: ubuntu-latest
+
+    env:
+      SECRET_KEY: ${{ secrets.SECRET_KEY }}
+      SENTRY_DSN: ${{ secrets.SENTRY_DSN }}
+      USE_SQLITE: "True"
+
+    steps:
+      # 1. Checkout
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # 2. Install Python
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      # 3. Install dependencies
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      # 4. Lint (flake8)
+      - name: Run flake8
+        run: flake8 .
+
+      # 5. Tests + coverage
+      - name: Run tests with coverage
+        run: pytest --cov=. --cov-report=term-missing --cov-fail-under=80
+
+
+  containerize:
+
+    needs: compile
+
+    if: github.ref == 'refs/heads/master'
+
+    runs-on: ubuntu-latest
+
+    steps:
+      # 1. Checkout repository
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # 2. Login Docker Hub
+      - name: Login to Docker Hub
+        run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin
+
+      # 3. Build Docker image (SHA + latest)
+      - name: Build Docker image
+        run: |
+          docker build -t ${{ secrets.DOCKER_USERNAME }}/oc_lettings_site:${{ github.sha }} .
+          docker tag ${{ secrets.DOCKER_USERNAME }}/oc_lettings_site:${{ github.sha }} ${{ secrets.DOCKER_USERNAME }}/oc_lettings_site:latest
+
+      # 4. Push Docker images
+      - name: Push Docker image (SHA)
+        run: |
+          docker push ${{ secrets.DOCKER_USERNAME }}/oc_lettings_site:${{ github.sha }}
+
+      - name: Push Docker image (latest)
+        run: |
+          docker push ${{ secrets.DOCKER_USERNAME }}/oc_lettings_site:latest
+
+  deploy:
+
+    needs: containerize
+
+    if: github.ref == 'refs/heads/master'
+
+    runs-on: ubuntu-latest
+
+    #Trigger Render deployment
+    steps:
+      - name: Trigger Render Deploy Hook
+        run: curl -X POST ${{ secrets.RENDER_DEPLOY_HOOK }}

.gitignore

@@ -1,3 +1,8 @@
 **/__pycache__
 *.pyc
 venv
+.idea/
+.env
+*.log
+db.sqlite3
+docs/build/

Dockerfile

@@ -0,0 +1,30 @@
+# Base image
+FROM python:3.10-slim
+
+# Prevent Python from buffering stdout/stderr
+ENV PYTHONUNBUFFERED=1
+
+# Set work directory
+WORKDIR /app
+
+# Copy requirements first (cache optimization)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project
+COPY . .
+
+# Collect statics
+RUN SECRET_KEY=dummy-secret-key \
+    USE_SQLITE=true \
+    python manage.py collectstatic --noinput
+
+# Expose port
+EXPOSE 8000
+
+# Run server with start.sh script
+RUN chmod +x start.sh
+
+CMD ["./start.sh"]

README.md

@@ -1,59 +1,168 @@
-## Résumé
+# Orange County Lettings 
 
-Site web d'Orange County Lettings
+## Présentation du projet 
 
-## Développement local
+Orange County Lettings est une application web développée avec Django pour une start-up spécialisée dans la location de biens immobiliers aux États-Unis.
+
+Ce projet a consisté à améliorer une application existante en la restructurant autour d'une architecture Django modulaire et en mettant en place une chaîne d'intégration et de déploiement continus (CI/CD).
+
+La documentation complète du projet est disponible ici : 
+
+## Fonctionnalités
+
+L'application permet de consulter les principales informations du service Orange County Lettings à travers une interface web développée avec Django.
+
+Les fonctionnalités disponibles sont les suivantes :
+
+- consultation des annonces immobilières ;
+- consultation des profils utilisateurs ;
+- accès à l'interface d'administration Django pour la gestion des données.
+
+## Architecture
+
+Le projet est organisé selon une architecture Django modulaire composée de trois applications principales :
+
+- **oc_lettings_site** : configuration générale du projet (settings, routage, serveur WSGI) ;
+- **lettings** : gestion des annonces immobilières ;
+- **profiles** : gestion des profils utilisateurs.
+
+Cette organisation permet de séparer les responsabilités de chaque composant et facilite la maintenance ainsi que l'évolution de l'application.
+
+L'application est conteneurisée avec Docker et déployée automatiquement via une pipeline CI/CD sur la plateforme Render.
+
+Pour une description détaillée de l'architecture, du déploiement et de l'infrastructure, consultez la documentation complète du projet.
+
+## Stack technique
+
+Le projet s'appuie sur les technologies suivantes :
+
+- **Langage :** Python 3.10
+- **Framework :** Django 3.0
+- **Bases de données :** SQLite (développement rapide), PostgreSQL (Docker et production)
+- **Conteneurisation :** Docker, Docker Compose
+- **CI/CD :** GitHub Actions
+- **Tests et qualité :** pytest, pytest-django, coverage, flake8, black
+- **Monitoring :** Sentry
+- **Production :** Gunicorn, WhiteNoise, Render
+- **Configuration :** python-dotenv
+
+## Utilisation en local
 
 ### Prérequis
 
-- Compte GitHub avec accès en lecture à ce repository
-- Git CLI
-- SQLite3 CLI
-- Interpréteur Python, version 3.6 ou supérieure
+Pour exécuter le projet localement, les outils suivants sont nécessaires :
 
-Dans le reste de la documentation sur le développement local, il est supposé que la commande `python` de votre OS shell exécute l'interpréteur Python ci-dessus (à moins qu'un environnement virtuel ne soit activé).
+- Git ;
+- Python 3.10 ou supérieur ;
+- Docker et Docker Compose (optionnel, pour une exécution conteneurisée).
 
-### macOS / Linux
+### Installation
 
-#### Cloner le repository
+Clonez le dépôt puis installez les dépendances dans un environnement virtuel :
 
-- `cd /path/to/put/project/in`
-- `git clone https://github.com/OpenClassrooms-Student-Center/Python-OC-Lettings-FR.git`
+```bash
+git clone https://github.com/OpenClassrooms-Student-Center/Python-OC-Lettings-FR.git
+cd Python-OC-Lettings-FR
 
-#### Créer l'environnement virtuel
+python -m venv venv
+source venv/bin/activate    # Linux / macOS
+# ou
+venv\Scripts\activate       # Windows
 
-- `cd /path/to/Python-OC-Lettings-FR`
-- `python -m venv venv`
-- `apt-get install python3-venv` (Si l'étape précédente comporte des erreurs avec un paquet non trouvé sur Ubuntu)
-- Activer l'environnement `source venv/bin/activate`
-- Confirmer que la commande `python` exécute l'interpréteur Python dans l'environnement virtuel
-`which python`
-- Confirmer que la version de l'interpréteur Python est la version 3.6 ou supérieure `python --version`
-- Confirmer que la commande `pip` exécute l'exécutable pip dans l'environnement virtuel, `which pip`
-- Pour désactiver l'environnement, `deactivate`
+pip install -r requirements.txt
+```
 
-#### Exécuter le site
+Créez ensuite un fichier .env à la racine du projet et renseignez les variables d'environnement nécessaires.
 
-- `cd /path/to/Python-OC-Lettings-FR`
-- `source venv/bin/activate`
-- `pip install --requirement requirements.txt`
-- `python manage.py runserver`
-- Aller sur `http://localhost:8000` dans un navigateur.
-- Confirmer que le site fonctionne et qu'il est possible de naviguer (vous devriez voir plusieurs profils et locations).
+### Lancement de l'application
 
-#### Linting
+#### Avec Django
 
-- `cd /path/to/Python-OC-Lettings-FR`
-- `source venv/bin/activate`
-- `flake8`
+```bash
+python manage.py migrate
+python manage.py runserver
+```
 
-#### Tests unitaires
+#### Avec Docker Compose
 
-- `cd /path/to/Python-OC-Lettings-FR`
-- `source venv/bin/activate`
-- `pytest`
+```bash
+docker compose up --build
+```
+
+L'application est ensuite accessible à l'adresse :
 
-#### Base de données
+http://localhost:8000
+
+Pour plus d'informations sur la configuration de l'environnement, les variables d'environnement ou l'utilisation de Docker Compose, consultez la documentation complète.
+
+## Tests et qualité du code
+
+Les principaux outils de qualité peuvent être exécutés depuis la racine du projet :
+
+```bash
+flake8        # Analyse statique
+pytest        # Tests unitaires
+pytest --cov  # Couverture des tests
+```
+
+Ces vérifications sont également exécutées automatiquement par la pipeline CI/CD à chaque `push` et à chaque Pull Request.
+
+## Pipeline CI/CD
+
+Le projet utilise une pipeline GitHub Actions pour automatiser les contrôles qualité, la construction de l'image Docker et le déploiement en production.
+
+```text
+Push / Pull Request
+        │
+        ▼
+GitHub Actions
+        │
+        ▼
+Job "compile"
+        │
+        ├── Installation des dépendances
+        ├── Analyse statique (flake8)
+        └── Tests unitaires + couverture
+        │
+        └──────────────► Validation réussie
+                          │
+                          ▼
+                 (push sur master uniquement)
+                          │
+                          ▼
+                 Job "containerize"
+                          │
+                          ├── Build Docker
+                          ├── Tag SHA
+                          ├── Tag latest
+                          └── Push DockerHub
+                          │
+                          ▼
+                    Job "deploy"
+                          │
+                          ▼
+                         Render
+```
+
+Les informations sensibles utilisées par la pipeline sont stockées dans les **GitHub Actions Secrets** et ne sont jamais versionnées dans le dépôt.
+
+## Déploiement
+
+L'application est déployée automatiquement sur **Render** à partir de la pipeline GitHub Actions.
+
+Lorsqu'un changement est fusionné sur la branche `master`, la pipeline :
+
+1. construit une image Docker ;
+2. publie cette image sur Docker Hub ;
+3. déclenche le déploiement sur Render via un Deploy Hook.
+
+Au démarrage du conteneur, le script `start.sh` applique automatiquement les migrations Django avant de lancer le serveur Gunicorn.
+
+L'application s'exécute en production avec une base de données PostgreSQL managée par Render. L'ensemble de la configuration est assuré au moyen de variables d'environnement et le service est vérifié automatiquement par le mécanisme de **Health Check** de Render.
+
+## Autres commandes utiles
+
+### Base de données
 
 - `cd /path/to/Python-OC-Lettings-FR`
 - Ouvrir une session shell `sqlite3`
@@ -64,14 +173,22 @@ Dans le reste de la documentation sur le développement local, il est supposé q
   Python-OC-Lettings-FR_profile where favorite_city like 'B%';`
 - `.quit` pour quitter
 
-#### Panel d'administration
+### Panel d'administration
 
 - Aller sur `http://localhost:8000/admin`
 - Connectez-vous avec l'utilisateur `admin`, mot de passe `Abc1234!`
 
-### Windows
+## Liens utiles
+
+Les documentations officielles suivantes permettent d'approfondir les technologies utilisées dans ce projet :
+
+- GitHub : https://docs.github.com/fr
+- Docker : https://docs.docker.com/
+- GitHub Actions : https://docs.github.com/fr/actions
+- Render : https://render.com/docs
+
+## Auteur
 
-Utilisation de PowerShell, comme ci-dessus sauf :
+Jérémy Muller, étudiant en développement applicatif python chez OpenClassrooms.
 
-- Pour activer l'environnement virtuel, `.\venv\Scripts\Activate.ps1` 
-- Remplacer `which <my-command>` par `(Get-Command <my-command>).Path`
+GitHub : https://github.com/Jeremuller/