Initial commit: EduLab Backend for Hugging Face Spaces

.env.exemple

@@ -0,0 +1,53 @@
+"""
+==============================================
+FICHIERS DE CONFIGURATION
+==============================================
+"""
+
+# ============================================
+# .env.example
+# ============================================
+
+# Django Settings
+SECRET_KEY=your-secret-key-here-change-in-production
+DEBUG=True
+ALLOWED_HOSTS=localhost,127.0.0.1,yourdomain.com
+
+# Database
+DB_NAME=educonnect_db
+DB_USER=postgres
+DB_PASSWORD=your_db_password
+DB_HOST=localhost
+DB_PORT=5432
+
+# CORS
+CORS_ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173,https://yourdomain.com
+
+# Redis (pour Celery et Channels)
+REDIS_HOST=localhost
+CELERY_BROKER_URL=redis://localhost:6379/0
+CELERY_RESULT_BACKEND=redis://localhost:6379/0
+
+# Email Configuration
+EMAIL_HOST=smtp.gmail.com
+EMAIL_PORT=587
+EMAIL_HOST_USER=your-email@gmail.com
+EMAIL_HOST_PASSWORD=your-email-password
+DEFAULT_FROM_EMAIL=noreply@educonnect.africa
+
+# AI APIs
+GEMINI_API_KEY=your-gemini-api-key
+OPENAI_API_KEY=your-openai-api-key
+
+# Logging
+DJANGO_LOG_LEVEL=INFO
+
+# AWS S3 (si utilisé pour les fichiers)
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_STORAGE_BUCKET_NAME=
+AWS_S3_REGION_NAME=
+
+# Sentry (Monitoring - optionnel)
+SENTRY_DSN=
+

.env.production

@@ -0,0 +1,40 @@
+# ==============================================
+# CONFIGURATION PRODUCTION - HUGGING FACE SPACES
+# ==============================================
+
+# Django Settings
+DEBUG=False
+SECRET_KEY=django-insecure-xdNTqmUzzdJbmHZ8fLr6B6v1NfShmDZM
+ALLOWED_HOSTS=localhost,127.0.0.1,.hf.space
+
+# CORS - Autoriser le frontend Hugging Face
+CORS_ALLOWED_ORIGINS=https://rinogeek-edulabfrontend.hf.space
+
+# Database - SQLite par défaut (pas de DB_HOST = utilise SQLite)
+# Pour PostgreSQL, décommentez et configurez :
+# DB_NAME=educonnect_db
+# DB_USER=postgres
+# DB_PASSWORD=your_db_password
+# DB_HOST=your_db_host
+# DB_PORT=5432
+
+# Redis (pour Celery et Channels) - Désactivé sur HF Spaces gratuit
+# REDIS_HOST=localhost
+# CELERY_BROKER_URL=redis://localhost:6379/0
+# CELERY_RESULT_BACKEND=redis://localhost:6379/0
+
+# Email Configuration
+EMAIL_HOST=smtp.gmail.com
+EMAIL_PORT=587
+EMAIL_HOST_USER=
+EMAIL_HOST_PASSWORD=
+DEFAULT_FROM_EMAIL=noreply@edulab.africa
+
+# AI APIs
+GEMINI_API_KEY=AIzaSyD-hnYdbQudiK8nfFtML05Mmlo26nLzxWQ
+
+# Logging
+DJANGO_LOG_LEVEL=INFO
+
+# Security - HF gère SSL au niveau proxy
+SECURE_SSL_REDIRECT=False

.gitignore

@@ -0,0 +1,75 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Django stuff:
+*.log
+*.pot
+*.pyc
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Media files
+media/
+
+# Static files (collectstatic output)
+staticfiles/
+
+# Environment
+.env
+.env.local
+venv/
+ENV/
+env/
+.venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+logs/
+*.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# Coverage
+.coverage
+htmlcov/
+
+# pytest
+.pytest_cache/
+
+# mypy
+.mypy_cache/

Dockerfile

@@ -0,0 +1,42 @@
+FROM python:3.12-slim
+
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+
+WORKDIR /app
+
+# Installer les dépendances système
+RUN apt-get update && apt-get install -y \
+    postgresql-client \
+    gcc \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Créer un utilisateur non-root pour Hugging Face Spaces (UID 1000)
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:${PATH}"
+
+# Définir le répertoire de travail et s'assurer des permissions
+WORKDIR /app
+COPY --chown=user:user requirements.txt /app/
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copier le reste du projet avec les bonnes permissions
+COPY --chown=user:user . /app/
+
+# Créer les dossiers nécessaires et s'assurer des permissions
+RUN mkdir -p /app/logs /app/media /app/staticfiles
+
+# Copier le fichier .env.production comme .env pour la production
+RUN cp /app/.env.production /app/.env || true
+
+# Collecter les fichiers statiques
+RUN python manage.py collectstatic --noinput
+
+# Exposer le port par défaut de Hugging Face Spaces
+EXPOSE 7860
+
+# Démarrer avec gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "4", "educonnect.wsgi:application"]

GUIDE_COMPLET.MD

@@ -0,0 +1,640 @@
+# 📘 GUIDE COMPLET - EduConnect Africa API
+
+## 🎯 Vue d'Ensemble
+
+API REST Django complète pour EduConnect Africa avec traçabilité maximale, soft delete, et versioning des données.
+
+---
+
+## 📁 Architecture du Projet
+
+```
+educonnect-api/
+│
+├── educonnect_api/              # Configuration Django
+│   ├── __init__.py
+│   ├── settings.py             # Configuration complète
+│   ├── urls.py                 # Routes principales
+│   ├── asgi.py                 # Configuration ASGI (WebSockets)
+│   ├── wsgi.py                 # Configuration WSGI
+│   └── celery.py               # Configuration Celery
+│
+├── apps/                        # Applications Django
+│   │
+│   ├── core/                   # Utilitaires & Base
+│   │   ├── models.py          # Mixins (Timestamp, SoftDelete, Versioned)
+│   │   ├── permissions.py     # Permissions personnalisées
+│   │   ├── exceptions.py      # Gestionnaire d'exceptions
+│   │   ├── middleware.py      # Middleware d'activité
+│   │   └── management/
+│   │       └── commands/
+│   │           ├── init_db.py         # Initialisation DB
+│   │           └── create_test_data.py # Données de test
+│   │
+│   ├── users/                  # Authentification & Utilisateurs
+│   │   ├── models.py          # User, UserProfile, UserAvatar, etc.
+│   │   ├── serializers.py     # User, Registration, Login, Update
+│   │   ├── views.py           # AuthViewSet
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── mentors/                # Gestion Mentors
+│   │   ├── models.py          # MentorProfile, Bio, Specialties, etc.
+│   │   ├── serializers.py     # Mentor CRUD
+│   │   ├── views.py           # MentorViewSet
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── bookings/               # Système de Réservation
+│   │   ├── models.py          # Booking, Domains, Expectations, etc.
+│   │   ├── serializers.py     # Booking CRUD
+│   │   ├── views.py           # BookingViewSet
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── forum/                  # Questions & Réponses
+│   │   ├── models.py          # Question, Answer (versionné)
+│   │   ├── serializers.py     # Forum CRUD
+│   │   ├── views.py           # QuestionViewSet, AnswerViewSet
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── gamification/           # Points & Badges
+│   │   ├── models.py          # Badge, UserBadge, PointsHistory
+│   │   ├── serializers.py     # Gamification
+│   │   ├── views.py           # GamificationViewSet
+│   │   ├── services.py        # BadgeService (logique métier)
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── messaging/              # Chat Temps Réel
+│   │   ├── models.py          # Conversation, Message
+│   │   ├── serializers.py     # Messaging
+│   │   ├── views.py           # ConversationViewSet
+│   │   ├── consumers.py       # WebSocket Consumer
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── notifications/          # Système de Notifications
+│   │   ├── models.py          # Notification
+│   │   ├── serializers.py     # Notification
+│   │   ├── views.py           # NotificationViewSet
+│   │   ├── services.py        # NotificationService
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── opportunities/          # Opportunités (Bourses, Stages)
+│   │   ├── models.py          # Opportunity
+│   │   ├── serializers.py     # Opportunity
+│   │   ├── views.py           # OpportunityViewSet
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   ├── ai_tools/               # Tuteur IA
+│   │   ├── models.py          # AITutorSession, CodeSnippet
+│   │   ├── serializers.py     # AI Request/Response
+│   │   ├── views.py           # AIToolsViewSet
+│   │   ├── urls.py
+│   │   └── tests.py
+│   │
+│   └── analytics/              # Analytics (Optionnel)
+│       ├── models.py          # UserActivity, SystemMetric
+│       └── views.py           # AnalyticsViewSet
+│
+├── logs/                       # Logs application
+├── media/                      # Fichiers uploadés
+├── staticfiles/                # Fichiers statiques collectés
+├── templates/                  # Templates Django
+│
+├── requirements.txt            # Dépendances Python
+├── pytest.ini                  # Configuration pytest
+├── conftest.py                 # Fixtures pytest
+├── .env.example                # Variables d'environnement
+├── Dockerfile                  # Docker image
+├── docker-compose.yml          # Docker services
+├── deploy.sh                   # Script de déploiement
+├── manage.py                   # CLI Django
+└── README.md                   # Documentation
+```
+
+---
+
+## 🚀 Installation & Démarrage
+
+### Option 1: Installation Locale
+
+```bash
+# 1. Cloner le projet
+git clone <repo-url>
+cd educonnect-api
+
+# 2. Environnement virtuel
+python3.11 -m venv venv
+source venv/bin/activate  # Linux/Mac
+# venv\Scripts\activate   # Windows
+
+# 3. Installer les dépendances
+pip install -r requirements.txt
+
+# 4. Configuration
+cp .env.example .env
+# Éditer .env avec vos paramètres
+
+# 5. Base de données PostgreSQL
+createdb educonnect_db
+
+# 6. Migrations
+python manage.py makemigrations
+python manage.py migrate
+
+# 7. Initialiser les données
+python manage.py init_db
+
+# 8. Créer un superuser
+python manage.py createsuperuser
+
+# 9. (Optionnel) Données de test
+python manage.py create_test_data --users 50
+
+# 10. Démarrer le serveur
+python manage.py runserver
+
+# 11. Démarrer Celery (dans un autre terminal)
+celery -A educonnect_api worker -l info
+
+# 12. Démarrer Channels/Daphne (dans un autre terminal)
+daphne -b 0.0.0.0 -p 8001 educonnect_api.asgi:application
+```
+
+### Option 2: Avec Docker
+
+```bash
+# Build et démarrer tous les services
+docker-compose up --build
+
+# Migrations
+docker-compose exec web python manage.py migrate
+
+# Initialiser
+docker-compose exec web python manage.py init_db
+
+# Créer superuser
+docker-compose exec web python manage.py createsuperuser
+
+# Voir les logs
+docker-compose logs -f web
+```
+
+---
+
+## 📚 Endpoints API Complets
+
+### 🔐 Authentification `/api/auth/`
+
+| Méthode | Endpoint | Description | Auth |
+|---------|----------|-------------|------|
+| POST | `/register/` | Inscription utilisateur | Non |
+| POST | `/login/` | Connexion | Non |
+| POST | `/token/refresh/` | Rafraîchir token | Non |
+| GET | `/me/` | Profil actuel | Oui |
+| PATCH | `/update_profile/` | Mise à jour profil | Oui |
+
+**Exemple Inscription:**
+```json
+POST /api/auth/register/
+{
+  "email": "student@educonnect.africa",
+  "password": "SecurePass123!",
+  "password_confirm": "SecurePass123!",
+  "name": "Jean Dupont",
+  "role": "STUDENT",
+  "country": "Bénin",
+  "university": "Université d'Abomey-Calavi"
+}
+```
+
+**Réponse:**
+```json
+{
+  "user": {
+    "id": 1,
+    "email": "student@educonnect.africa",
+    "role": "STUDENT",
+    "points": 0,
+    "profile": {
+      "name": "Jean Dupont",
+      "avatar": null,
+      "country": "Bénin",
+      "university": "Université d'Abomey-Calavi"
+    }
+  },
+  "tokens": {
+    "refresh": "eyJ0eXAiOiJKV1QiLCJhbGc...",
+    "access": "eyJ0eXAiOiJKV1QiLCJhbGc..."
+  }
+}
+```
+
+---
+
+### 👨‍🏫 Mentors `/api/mentors/`
+
+| Méthode | Endpoint | Description | Filtres |
+|---------|----------|-------------|---------|
+| GET | `/` | Liste mentors | ?search=, ?country=, ?specialty=, ?ordering= |
+| GET | `/{id}/` | Détail mentor | - |
+| GET | `/my_profile/` | Mon profil mentor | - |
+| PATCH | `/my_profile/` | Mettre à jour | - |
+| GET | `/{id}/reviews/` | Avis mentor | - |
+
+**Exemple Liste:**
+```bash
+GET /api/mentors/?country=Bénin&specialty=Informatique&ordering=-rating
+```
+
+---
+
+### 📅 Réservations `/api/bookings/`
+
+| Méthode | Endpoint | Description |
+|---------|----------|-------------|
+| GET | `/` | Mes réservations |
+| POST | `/` | Créer réservation |
+| GET | `/{id}/` | Détail |
+| PATCH | `/{id}/update_status/` | Accepter/Refuser |
+| GET | `/mentor_requests/` | Demandes reçues (mentor) |
+
+**Exemple Création:**
+```json
+POST /api/bookings/
+{
+  "mentor_id": 5,
+  "date": "2025-12-15",
+  "time": "14:00:00",
+  "domains": ["Informatique", "Programmation"],
+  "expectations": "Je souhaite apprendre les bases de Django",
+  "main_question": "Comment structurer un projet Django professionnel?"
+}
+```
+
+---
+
+### 💬 Forum `/api/forum/`
+
+#### Questions
+
+| Méthode | Endpoint | Description | Filtres |
+|---------|----------|-------------|---------|
+| GET | `/questions/` | Liste | ?search=, ?filter=solved/unsolved, ?tag= |
+| POST | `/questions/` | Créer | - |
+| GET | `/questions/{id}/` | Détail | - |
+| PATCH | `/questions/{id}/` | Modifier | - |
+| DELETE | `/questions/{id}/` | Supprimer (soft) | - |
+| POST | `/questions/{id}/vote/` | Voter | - |
+| GET | `/questions/{id}/answers/` | Réponses | - |
+| POST | `/questions/{id}/answers/` | Répondre | - |
+
+**Exemple Création Question:**
+```json
+POST /api/forum/questions/
+{
+  "title": "Comment calculer une intégrale triple?",
+  "content": "Je bloque sur cet exercice: ∫∫∫ xyz dV...",
+  "tags": ["mathématiques", "intégrales", "calcul"]
+}
+```
+
+#### Réponses
+
+| Méthode | Endpoint | Description |
+|---------|----------|-------------|
+| POST | `/answers/{id}/vote/` | Voter |
+| POST | `/answers/{id}/accept/` | Accepter (auteur question) |
+
+---
+
+### 🎮 Gamification `/api/gamification/`
+
+| Méthode | Endpoint | Description |
+|---------|----------|-------------|
+| GET | `/leaderboard/` | Classement |
+| GET | `/my_badges/` | Mes badges |
+| GET | `/all_badges/` | Tous les badges |
+| GET | `/points_history/` | Historique points |
+| GET | `/stats/` | Statistiques perso |
+
+**Système de Points:**
+- Question postée: **+10 points**
+- Réponse postée: **+15 points**
+- Réponse acceptée: **+50 points**
+- Upvote reçu: **+5 points**
+- Devenir mentor: **+100 points**
+- Session complétée: **+25 points**
+
+**Badges Disponibles:**
+1. 🌱 **Premier Pas** - Première question
+2. 🔍 **Curieux** - 100 points
+3. ⭐ **Engagé** - 500 points
+4. 🏆 **Expert** - 1000 points
+5. 👑 **Maître** - 2500 points
+6. 💎 **Légende** - 5000 points
+
+---
+
+### 💬 Messagerie `/api/messages/`
+
+| Méthode | Endpoint | Description |
+|---------|----------|-------------|
+| GET | `/conversations/` | Mes conversations |
+| POST | `/conversations/` | Créer conversation |
+| GET | `/conversations/{id}/` | Détail |
+| GET | `/conversations/{id}/messages/` | Messages |
+| POST | `/conversations/{id}/send_message/` | Envoyer |
+
+**WebSocket (Temps Réel):**
+```javascript
+ws://localhost:8001/ws/chat/{conversation_id}/
+```
+
+---
+
+### 🔔 Notifications `/api/notifications/`
+
+| Méthode | Endpoint | Description |
+|---------|----------|-------------|
+| GET | `/` | Mes notifications |
+| GET | `/{id}/` | Détail |
+| POST | `/mark_all_read/` | Tout marquer lu |
+| POST | `/{id}/mark_read/` | Marquer lu |
+| DELETE | `/{id}/delete_notification/` | Supprimer |
+| GET | `/unread_count/` | Nombre non lues |
+
+---
+
+### 🎓 Opportunités `/api/opportunities/`
+
+| Méthode | Endpoint | Description | Filtres |
+|---------|----------|-------------|---------|
+| GET | `/` | Liste | ?type=SCHOLARSHIP/CONTEST/INTERNSHIP/TRAINING |
+| GET | `/{id}/` | Détail | - |
+
+---
+
+### 🤖 IA `/api/ai/`
+
+| Méthode | Endpoint | Description |
+|---------|----------|-------------|
+| POST | `/tutor/` | Tuteur IA |
+
+**Exemple:**
+```json
+POST /api/ai/tutor/
+{
+  "question": "Peux-tu m'expliquer le théorème de Pythagore?",
+  "subject": "Mathématiques",
+  "level": "Lycée"
+}
+```
+
+---
+
+## 🧪 Tests
+
+```bash
+# Lancer tous les tests
+pytest
+
+# Tests avec coverage
+pytest --cov=apps --cov-report=html
+
+# Tests spécifiques
+pytest apps/users/tests.py
+pytest apps/forum/tests.py::TestForum::test_create_question
+
+# Tests verbeux
+pytest -v
+
+# Voir la sortie print
+pytest -s
+```
+
+---
+
+## 🔒 Sécurité
+
+### Headers de Sécurité (Production)
+
+```python
+SECURE_SSL_REDIRECT = True
+SESSION_COOKIE_SECURE = True
+CSRF_COOKIE_SECURE = True
+SECURE_HSTS_SECONDS = 31536000
+X_FRAME_OPTIONS = 'DENY'
+```
+
+### Rate Limiting (À implémenter)
+
+```python
+# settings.py
+REST_FRAMEWORK = {
+    'DEFAULT_THROTTLE_CLASSES': [
+        'rest_framework.throttling.AnonRateThrottle',
+        'rest_framework.throttling.UserRateThrottle'
+    ],
+    'DEFAULT_THROTTLE_RATES': {
+        'anon': '100/hour',
+        'user': '1000/hour'
+    }
+}
+```
+
+---
+
+## 📊 Monitoring & Logs
+
+### Logs
+
+```bash
+# Logs Django
+tail -f logs/django.log
+
+# Logs Gunicorn
+tail -f /var/log/gunicorn/error.log
+
+# Logs Nginx
+tail -f /var/log/nginx/educonnect_error.log
+
+# Logs Celery
+tail -f /var/log/celery/worker.log
+```
+
+### Sentry (Monitoring Erreurs)
+
+```python
+# settings.py
+import sentry_sdk
+
+sentry_sdk.init(
+    dsn="your-sentry-dsn",
+    environment="production",
+    traces_sample_rate=0.1
+)
+```
+
+---
+
+## 🚀 Déploiement Production
+
+### 1. Préparer le Serveur
+
+```bash
+# Installer dépendances système
+sudo apt update
+sudo apt install python3.11 python3.11-venv postgresql redis nginx
+
+# Créer utilisateur
+sudo useradd -m -s /bin/bash educonnect
+```
+
+### 2. Déployer l'Application
+
+```bash
+# Cloner
+cd /var/www
+sudo git clone <repo> educonnect-api
+sudo chown -R educonnect:educonnect educonnect-api
+
+# Setup
+cd educonnect-api
+python3.11 -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+# Configuration
+cp .env.example .env
+# Éditer .env avec les vraies valeurs
+
+# Migrations
+python manage.py migrate
+python manage.py collectstatic --noinput
+```
+
+### 3. Configurer Systemd
+
+```bash
+# Copier les fichiers service
+sudo cp systemd/gunicorn.service /etc/systemd/system/
+sudo cp systemd/celery.service /etc/systemd/system/
+
+# Activer et démarrer
+sudo systemctl enable gunicorn celery
+sudo systemctl start gunicorn celery
+```
+
+### 4. Configurer Nginx
+
+```bash
+# Copier la config
+sudo cp nginx/educonnect.conf /etc/nginx/sites-available/
+sudo ln -s /etc/nginx/sites-available/educonnect.conf /etc/nginx/sites-enabled/
+
+# Tester et recharger
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+### 5. SSL avec Let's Encrypt
+
+```bash
+sudo apt install certbot python3-certbot-nginx
+sudo certbot --nginx -d api.educonnect.africa
+```
+
+### 6. Script de Déploiement Automatique
+
+```bash
+chmod +x deploy.sh
+sudo ./deploy.sh
+```
+
+---
+
+## 🔄 Maintenance
+
+### Backup Base de Données
+
+```bash
+# Backup manuel
+pg_dump educonnect_db > backup_$(date +%Y%m%d).sql
+
+# Backup automatique (cron)
+0 2 * * * pg_dump educonnect_db > /var/backups/educonnect/db_$(date +\%Y\%m\%d).sql
+```
+
+### Nettoyage
+
+```bash
+# Supprimer anciennes versions (soft deleted)
+python manage.py shell
+>>> from django.utils import timezone
+>>> from datetime import timedelta
+>>> cutoff = timezone.now() - timedelta(days=90)
+>>> # Archiver les données anciennes...
+```
+
+---
+
+## 📖 Documentation Interactive
+
+Une fois l'API lancée:
+
+- **Swagger UI**: http://localhost:8000/api/docs/
+- **ReDoc**: http://localhost:8000/api/redoc/
+- **Admin Django**: http://localhost:8000/admin/
+
+---
+
+## 🤝 Contribution
+
+1. Fork le projet
+2. Créer une branche feature (`git checkout -b feature/AmazingFeature`)
+3. Commit (`git commit -m 'Add AmazingFeature'`)
+4. Push (`git push origin feature/AmazingFeature`)
+5. Pull Request
+
+---
+
+## 📝 Notes Importantes
+
+### Traçabilité des Données
+
+- **Aucune suppression physique** : Toutes les suppressions sont des soft deletes
+- **Versioning** : Chaque modification crée un nouvel enregistrement
+- **Audit Trail** : Timestamps et historiques complets
+- **Récupération** : Possibilité de restaurer les données
+
+### Performance
+
+- **Indexes** : Sur tous les champs fréquemment filtrés
+- **Pagination** : 20 items par page par défaut
+- **Caching Redis** : Pour sessions et Celery
+- **Connection Pooling** : PostgreSQL avec `CONN_MAX_AGE=600`
+
+### Scalabilité
+
+- **Horizontal** : Ajouter des workers Gunicorn/Celery
+- **Vertical** : Augmenter ressources serveur
+- **Database** : PostgreSQL supporte des millions de rows
+- **CDN** : Pour fichiers statiques/media
+
+---
+
+## 📞 Support
+
+- **Email**: support@educonnect.africa
+- **Documentation**: https://docs.educonnect.africa
+- **Issues**: https://github.com/hypee/educonnect-api/issues
+
+---
+
+**Développé avec ❤️ par Initiative Hypee - Bénin 🇧🇯**

README.md

@@ -0,0 +1,194 @@
+# EduConnect Africa API
+
+API REST Django pour la plateforme EduConnect Africa - Initiative Hypee (Bénin)
+
+## 🚀 Technologies
+
+- **Django 4.2** + **Django REST Framework 3.14**
+- **PostgreSQL 15** (Base de données)
+- **Redis** (Cache & Celery)
+- **Channels** (WebSockets pour le chat)
+- **JWT** (Authentification)
+- **Celery** (Tâches asynchrones)
+- **Docker** (Containerisation)
+
+## 📋 Prérequis
+
+- Python 3.11+
+- PostgreSQL 15+
+- Redis 7+
+- Docker & Docker Compose (optionnel)
+
+## ⚙️ Installation
+
+### Méthode 1: Installation locale
+
+1. **Cloner le projet**
+```bash
+git clone <repo-url>
+cd educonnect-api
+```
+
+2. **Créer un environnement virtuel**
+```bash
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+# ou
+venv\\Scripts\\activate  # Windows
+```
+
+3. **Installer les dépendances**
+```bash
+pip install -r requirements.txt
+```
+
+4. **Configuration**
+```bash
+cp .env.example .env
+# Éditer .env avec vos paramètres
+```
+
+5. **Créer la base de données**
+```bash
+createdb educonnect_db
+```
+
+6. **Migrations**
+```bash
+python manage.py makemigrations
+python manage.py migrate
+```
+
+7. **Initialiser les données**
+```bash
+python manage.py init_db
+python manage.py create_test_data --users 20
+```
+
+8. **Créer un superuser**
+```bash
+python manage.py createsuperuser
+```
+
+9. **Lancer le serveur**
+```bash
+python manage.py runserver
+```
+
+### Méthode 2: Avec Docker
+
+```bash
+docker-compose up --build
+docker-compose exec web python manage.py migrate
+docker-compose exec web python manage.py init_db
+docker-compose exec web python manage.py createsuperuser
+```
+
+## 📚 Documentation API
+
+Une fois le serveur lancé:
+- **Swagger UI**: http://localhost:8000/api/docs/
+- **ReDoc**: http://localhost:8000/api/redoc/
+- **Admin Django**: http://localhost:8000/admin/
+
+## 🔑 Endpoints Principaux
+
+### Authentification
+- `POST /api/auth/register/` - Inscription
+- `POST /api/auth/login/` - Connexion
+- `GET /api/auth/me/` - Profil actuel
+- `PATCH /api/auth/update_profile/` - Mise à jour profil
+
+### Mentors
+- `GET /api/mentors/` - Liste des mentors
+- `GET /api/mentors/{id}/` - Détail mentor
+- `PATCH /api/mentors/my_profile/` - Mise à jour profil mentor
+
+### Forum
+- `GET /api/forum/questions/` - Liste questions
+- `POST /api/forum/questions/` - Créer question
+- `POST /api/forum/questions/{id}/vote/` - Voter
+- `POST /api/forum/questions/{id}/answers/` - Répondre
+
+### Réservations
+- `POST /api/bookings/` - Créer réservation
+- `GET /api/bookings/mentor_requests/` - Demandes reçues
+- `PATCH /api/bookings/{id}/update_status/` - Accepter/Refuser
+
+### Gamification
+- `GET /api/gamification/leaderboard/` - Classement
+- `GET /api/gamification/my_badges/` - Mes badges
+- `GET /api/gamification/stats/` - Statistiques
+
+### Messagerie
+- `GET /api/messages/conversations/` - Conversations
+- `POST /api/messages/conversations/{id}/send_message/` - Envoyer message
+- WebSocket: `ws://localhost:8001/ws/chat/{conversation_id}/`
+
+### Notifications
+- `GET /api/notifications/` - Mes notifications
+- `POST /api/notifications/mark_all_read/` - Tout marquer lu
+
+### Opportunités
+- `GET /api/opportunities/` - Liste opportunités
+
+### IA
+- `POST /api/ai/tutor/` - Tuteur IA
+
+## 🧪 Tests
+
+```bash
+pytest
+pytest --cov=apps
+```
+
+## 🏗️ Structure du Projet
+
+```
+educonnect-api/
+├── apps/
+│   ├── users/          # Authentification & Utilisateurs
+│   ├── mentors/        # Gestion mentors
+│   ├── bookings/       # Système de réservation
+│   ├── forum/          # Questions & Réponses
+│   ├── gamification/   # Points & Badges
+│   ├── messaging/      # Chat en temps réel
+│   ├── notifications/  # Notifications
+│   ├── opportunities/  # Opportunités
+│   ├── ai_tools/       # Tuteur IA
+│   ├── analytics/      # Analytics
+│   └── core/           # Mixins, utilities
+├── educonnect_api/     # Configuration Django
+├── requirements.txt
+├── Dockerfile
+└── docker-compose.yml
+```
+
+## 🔒 Sécurité
+
+- Tokens JWT avec refresh
+- Rate limiting
+- CORS configuré
+- Validation des entrées
+- Soft delete pour traçabilité
+- HTTPS obligatoire en production
+
+## 📊 Monitoring
+
+Intégration Sentry pour le monitoring des erreurs en production.
+
+## 🤝 Contribution
+
+1. Fork le projet
+2. Créer une branche (`git checkout -b feature/AmazingFeature`)
+3. Commit (`git commit -m 'Add AmazingFeature'`)
+4. Push (`git push origin feature/AmazingFeature`)
+5. Pull Request
+
+## 📝 Licence
+
+Propriétaire - Initiative Hypee Bénin
+
+## 👥 Équipe
+
+Initiative Hypee - Bénin

STRUCTURE_FILE.MD

@@ -0,0 +1,508 @@
+# 📂 STRUCTURE COMPLÈTE DES FICHIERS - EduConnect Africa API
+
+## Checklist de Création des Fichiers
+
+### 🔧 Configuration Racine
+
+```
+educonnect-api/
+├── 📄 manage.py
+├── 📄 requirements.txt
+├── 📄 .env.example
+├── 📄 .gitignore
+├── 📄 README.md
+├── 📄 pytest.ini
+├── 📄 conftest.py
+├── 📄 Dockerfile
+├── 📄 docker-compose.yml
+├── 📄 deploy.sh
+└── 📄 .flake8
+```
+
+### 📦 Configuration Django (`educonnect_api/`)
+
+```
+educonnect_api/
+├── 📄 __init__.py
+├── 📄 settings.py          ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 wsgi.py              ✅ Créé
+├── 📄 asgi.py              ✅ Créé
+└── 📄 celery.py            ✅ Créé
+```
+
+### 🎯 App: Core (`apps/core/`)
+
+```
+apps/core/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé (Mixins)
+├── 📄 permissions.py       ✅ Créé
+├── 📄 exceptions.py        ⚠️ À créer
+├── 📄 middleware.py        ✅ Créé
+├── 📄 admin.py
+├── management/
+│   └── commands/
+│       ├── 📄 __init__.py
+│       ├── 📄 init_db.py           ✅ Créé
+│       └── 📄 create_test_data.py  ✅ Créé
+└── tests/
+    └── 📄 test_models.py
+```
+
+### 👤 App: Users (`apps/users/`)
+
+```
+apps/users/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ✅ Créé
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 👨‍🏫 App: Mentors (`apps/mentors/`)
+
+```
+apps/mentors/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ⚠️ À créer
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 📅 App: Bookings (`apps/bookings/`)
+
+```
+apps/bookings/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ⚠️ À créer
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 💬 App: Forum (`apps/forum/`)
+
+```
+apps/forum/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ✅ Créé
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 🎮 App: Gamification (`apps/gamification/`)
+
+```
+apps/gamification/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 services.py          ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ✅ Créé
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 💬 App: Messaging (`apps/messaging/`)
+
+```
+apps/messaging/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 consumers.py         ✅ Créé (WebSocket)
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ⚠️ À créer
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 🔔 App: Notifications (`apps/notifications/`)
+
+```
+apps/notifications/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 services.py          ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ⚠️ À créer
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 🎓 App: Opportunities (`apps/opportunities/`)
+
+```
+apps/opportunities/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ⚠️ À créer
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 🤖 App: AI Tools (`apps/ai_tools/`)
+
+```
+apps/ai_tools/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 serializers.py       ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 urls.py              ✅ Créé
+├── 📄 admin.py             ⚠️ À créer
+├── 📄 tests.py             ⚠️ À créer
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### 📊 App: Analytics (`apps/analytics/`)
+
+```
+apps/analytics/
+├── 📄 __init__.py
+├── 📄 apps.py
+├── 📄 models.py            ✅ Créé
+├── 📄 views.py             ✅ Créé
+├── 📄 urls.py              ⚠️ À créer
+├── 📄 admin.py             ⚠️ À créer
+└── migrations/
+    └── 📄 __init__.py
+```
+
+### ⚙️ Systemd Services (`systemd/`)
+
+```
+systemd/
+├── 📄 gunicorn.service     ✅ Créé
+└── 📄 celery.service       ✅ Créé
+```
+
+### 🌐 Nginx Configuration (`nginx/`)
+
+```
+nginx/
+└── 📄 educonnect.conf      ✅ Créé
+```
+
+### 🧪 GitHub Actions (`.github/workflows/`)
+
+```
+.github/workflows/
+└── 📄 ci.yml               ✅ Créé
+```
+
+---
+
+## 📝 Fichiers Manquants à Créer
+
+### 1. `.gitignore`
+
+```gitignore
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+*.egg-info/
+dist/
+build/
+
+# Django
+*.log
+local_settings.py
+db.sqlite3
+media/
+staticfiles/
+
+# Environment
+.env
+.env.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+```
+
+### 2. `.flake8`
+
+```ini
+[flake8]
+max-line-length = 127
+exclude = 
+    .git,
+    __pycache__,
+    venv,
+    migrations,
+    */migrations/*
+ignore = E203, E266, W503
+```
+
+### 3. Fichiers `apps.py` pour chaque app
+
+**Exemple `apps/users/apps.py`:**
+
+```python
+from django.apps import AppConfig
+
+class UsersConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.users'
+    
+    def ready(self):
+        import apps.core.signals  # Charger les signals
+```
+
+### 4. Fichiers `admin.py` pour chaque app
+
+**Exemple `apps/users/admin.py`:**
+
+```python
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from apps.users.models import User, UserProfile
+
+@admin.register(User)
+class UserAdmin(BaseUserAdmin):
+    list_display = ['email', 'role', 'points', 'is_active', 'created_at']
+    list_filter = ['role', 'is_active', 'created_at']
+    search_fields = ['email']
+    ordering = ['-created_at']
+    
+    fieldsets = (
+        (None, {'fields': ('email', 'password')}),
+        ('Informations', {'fields': ('role', 'points')}),
+        ('Permissions', {'fields': ('is_active', 'is_staff', 'is_superuser')}),
+        ('Dates', {'fields': ('created_at', 'updated_at')}),
+    )
+    
+    readonly_fields = ['created_at', 'updated_at']
+    
+    add_fieldsets = (
+        (None, {
+            'classes': ('wide',),
+            'fields': ('email', 'password1', 'password2', 'role'),
+        }),
+    )
+
+@admin.register(UserProfile)
+class UserProfileAdmin(admin.ModelAdmin):
+    list_display = ['user', 'name', 'is_current', 'created_at']
+    list_filter = ['is_current', 'created_at']
+    search_fields = ['user__email', 'name']
+```
+
+### 5. `apps/core/exceptions.py`
+
+```python
+from rest_framework.views import exception_handler
+from rest_framework.response import Response
+from rest_framework import status
+import logging
+
+logger = logging.getLogger(__name__)
+
+def custom_exception_handler(exc, context):
+    """Gestionnaire d'exceptions personnalisé"""
+    
+    # Appeler le gestionnaire par défaut
+    response = exception_handler(exc, context)
+    
+    # Logger l'erreur
+    logger.error(f"Exception: {exc}", exc_info=True)
+    
+    if response is not None:
+        # Personnaliser le format de la réponse
+        custom_response_data = {
+            'error': True,
+            'message': str(exc),
+            'status_code': response.status_code
+        }
+        
+        if hasattr(exc, 'detail'):
+            custom_response_data['details'] = exc.detail
+        
+        response.data = custom_response_data
+    
+    return response
+```
+
+### 6. `apps/__init__.py`
+
+Créer un fichier `__init__.py` vide dans chaque dossier d'app.
+
+---
+
+## 🚀 Script de Création Automatique
+
+Pour créer tous les fichiers manquants automatiquement:
+
+```bash
+#!/bin/bash
+
+# create_structure.sh
+
+echo "Création de la structure EduConnect Africa API..."
+
+# Apps list
+APPS=("users" "mentors" "bookings" "forum" "gamification" "messaging" "notifications" "opportunities" "ai_tools" "analytics" "core")
+
+# Créer les dossiers principaux
+mkdir -p apps logs media staticfiles templates systemd nginx .github/workflows
+
+# Créer la structure pour chaque app
+for app in "${APPS[@]}"; do
+    echo "Création de apps/$app..."
+    mkdir -p apps/$app/migrations
+    touch apps/$app/__init__.py
+    touch apps/$app/apps.py
+    touch apps/$app/models.py
+    touch apps/$app/serializers.py
+    touch apps/$app/views.py
+    touch apps/$app/urls.py
+    touch apps/$app/admin.py
+    touch apps/$app/tests.py
+    touch apps/$app/migrations/__init__.py
+done
+
+# Créer management commands
+mkdir -p apps/core/management/commands
+touch apps/core/management/__init__.py
+touch apps/core/management/commands/__init__.py
+
+# Configuration Django
+mkdir -p educonnect_api
+touch educonnect_api/__init__.py
+
+# Fichiers racine
+touch manage.py
+touch pytest.ini
+touch conftest.py
+touch .gitignore
+touch .flake8
+touch README.md
+
+echo "✅ Structure créée avec succès!"
+echo "📝 N'oubliez pas de remplir les fichiers avec le code approprié"
+```
+
+Rendre exécutable:
+```bash
+chmod +x create_structure.sh
+./create_structure.sh
+```
+
+---
+
+## ✅ Checklist de Vérification
+
+Avant de lancer l'application, vérifier:
+
+- [ ] Tous les fichiers `__init__.py` sont créés
+- [ ] `.env` est configuré avec les vraies valeurs
+- [ ] PostgreSQL est installé et la DB créée
+- [ ] Redis est installé et lancé
+- [ ] Tous les fichiers de migrations sont présents
+- [ ] Les fichiers `apps.py` sont configurés
+- [ ] Les `admin.py` sont remplis
+- [ ] Les tests passent (`pytest`)
+- [ ] Le serveur démarre (`python manage.py runserver`)
+- [ ] Celery fonctionne
+- [ ] Les WebSockets fonctionnent (Channels/Daphne)
+
+---
+
+## 🔄 Ordre de Création Recommandé
+
+1. **Configuration de base**
+   - `settings.py`
+   - `urls.py`
+   - `.env`
+
+2. **Core & Users**
+   - `apps/core/models.py` (mixins)
+   - `apps/users/models.py`
+   - `apps/users/serializers.py`
+   - `apps/users/views.py`
+
+3. **Autres apps une par une**
+   - Models → Serializers → Views → URLs
+
+4. **Services & Signals**
+   - `apps/gamification/services.py`
+   - `apps/notifications/services.py`
+   - `apps/core/signals.py`
+
+5. **Tests**
+   - Écrire les tests au fur et à mesure
+
+6. **Configuration serveur**
+   - Systemd services
+   - Nginx
+   - SSL
+
+---
+
+**🎯 Objectif: API REST complète, sécurisée, scalable et maintenable!**

apps/ai_tools/admin.py

@@ -0,0 +1,19 @@
+from django.contrib import admin
+from .models import AITutorSession, AITutorQuestion, CodeSnippet
+
+class AITutorQuestionInline(admin.StackedInline):
+    model = AITutorQuestion
+    extra = 0
+
+@admin.register(AITutorSession)
+class AITutorSessionAdmin(admin.ModelAdmin):
+    list_display = ('user', 'subject', 'level', 'total_questions', 'created_at')
+    list_filter = ('subject', 'level', 'created_at')
+    search_fields = ('user__email', 'subject')
+    inlines = [AITutorQuestionInline]
+
+@admin.register(CodeSnippet)
+class CodeSnippetAdmin(admin.ModelAdmin):
+    list_display = ('user', 'title', 'language', 'is_public', 'created_at')
+    list_filter = ('language', 'is_public', 'created_at')
+    search_fields = ('user__email', 'title', 'code')

apps/ai_tools/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AiToolsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.ai_tools'

apps/ai_tools/migrations/0001_initial.py

@@ -0,0 +1,99 @@
+# Generated by Django 4.2.7 on 2025-11-29 13:38
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="AITutorQuestion",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("question", models.TextField()),
+                ("answer", models.TextField()),
+                ("model_used", models.CharField(max_length=50)),
+                ("tokens_used", models.IntegerField(blank=True, null=True)),
+                ("response_time", models.FloatField(blank=True, null=True)),
+            ],
+            options={
+                "db_table": "ai_tutor_questions",
+                "ordering": ["created_at"],
+            },
+        ),
+        migrations.CreateModel(
+            name="AITutorSession",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "deleted_at",
+                    models.DateTimeField(blank=True, db_index=True, null=True),
+                ),
+                ("is_active", models.BooleanField(db_index=True, default=True)),
+                ("subject", models.CharField(blank=True, max_length=100, null=True)),
+                ("level", models.CharField(blank=True, max_length=50, null=True)),
+                ("total_questions", models.IntegerField(default=0)),
+            ],
+            options={
+                "verbose_name": "Session Tuteur IA",
+                "verbose_name_plural": "Sessions Tuteur IA",
+                "db_table": "ai_tutor_sessions",
+                "ordering": ["-created_at"],
+            },
+        ),
+        migrations.CreateModel(
+            name="CodeSnippet",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "deleted_at",
+                    models.DateTimeField(blank=True, db_index=True, null=True),
+                ),
+                ("is_active", models.BooleanField(db_index=True, default=True)),
+                ("title", models.CharField(max_length=255)),
+                ("language", models.CharField(max_length=50)),
+                ("code", models.TextField()),
+                ("description", models.TextField(blank=True, null=True)),
+                ("is_public", models.BooleanField(default=False)),
+            ],
+            options={
+                "verbose_name": "Snippet de Code",
+                "verbose_name_plural": "Snippets de Code",
+                "db_table": "code_snippets",
+                "ordering": ["-created_at"],
+            },
+        ),
+    ]

apps/ai_tools/migrations/0002_initial.py

@@ -0,0 +1,44 @@
+# Generated by Django 4.2.7 on 2025-11-29 13:38
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("ai_tools", "0001_initial"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="codesnippet",
+            name="user",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="code_snippets",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddField(
+            model_name="aitutorsession",
+            name="user",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="ai_sessions",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddField(
+            model_name="aitutorquestion",
+            name="session",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="questions",
+                to="ai_tools.aitutorsession",
+            ),
+        ),
+    ]

apps/ai_tools/models.py

@@ -0,0 +1,47 @@
+# ============================================
+# apps/ai_tools/models.py - Historique IA
+# ============================================
+from django.db import models
+from apps.core.models import TimestampMixin, SoftDeleteMixin
+from apps.users.models import User
+
+class AITutorSession(TimestampMixin, SoftDeleteMixin):
+    """Session de tuteur IA"""
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='ai_sessions')
+    subject = models.CharField(max_length=100, null=True, blank=True)
+    level = models.CharField(max_length=50, null=True, blank=True)
+    total_questions = models.IntegerField(default=0)
+    
+    class Meta:
+        db_table = 'ai_tutor_sessions'
+        verbose_name = 'Session Tuteur IA'
+        verbose_name_plural = 'Sessions Tuteur IA'
+        ordering = ['-created_at']
+
+class AITutorQuestion(TimestampMixin):
+    """Question posée au tuteur IA"""
+    session = models.ForeignKey(AITutorSession, on_delete=models.CASCADE, related_name='questions')
+    question = models.TextField()
+    answer = models.TextField()
+    model_used = models.CharField(max_length=50)  # gemini, gpt-4, etc.
+    tokens_used = models.IntegerField(null=True, blank=True)
+    response_time = models.FloatField(null=True, blank=True)  # en secondes
+    
+    class Meta:
+        db_table = 'ai_tutor_questions'
+        ordering = ['created_at']
+
+class CodeSnippet(TimestampMixin, SoftDeleteMixin):
+    """Sauvegardes du sandbox de code"""
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='code_snippets')
+    title = models.CharField(max_length=255)
+    language = models.CharField(max_length=50)
+    code = models.TextField()
+    description = models.TextField(null=True, blank=True)
+    is_public = models.BooleanField(default=False)
+    
+    class Meta:
+        db_table = 'code_snippets'
+        verbose_name = 'Snippet de Code'
+        verbose_name_plural = 'Snippets de Code'
+        ordering = ['-created_at']

apps/ai_tools/serializers.py

@@ -0,0 +1,21 @@
+# ============================================
+# apps/ai_tools/serializers.py
+# ============================================
+from rest_framework import serializers
+
+class AITutorRequestSerializer(serializers.Serializer):
+    question = serializers.CharField()
+    subject = serializers.CharField(max_length=100, required=False)
+    level = serializers.CharField(max_length=50, required=False)
+    style = serializers.CharField(max_length=100, required=False)
+    conversation_history = serializers.ListField(
+        child=serializers.DictField(),
+        required=False,
+        default=list
+    )
+
+class AITutorResponseSerializer(serializers.Serializer):
+    answer = serializers.CharField()
+    session_id = serializers.IntegerField()
+    tokens_used = serializers.IntegerField(required=False)
+

apps/ai_tools/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

apps/ai_tools/urls.py

@@ -0,0 +1,18 @@
+# ============================================
+# apps/ai_tools/urls.py
+# ============================================
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from apps.ai_tools.views import AIToolsViewSet
+
+router = DefaultRouter()
+router.register(r'', AIToolsViewSet, basename='ai_tools')
+
+urlpatterns = [
+    path('', include(router.urls)),
+]
+
+"""
+Endpoints disponibles:
+- POST /api/ai/tutor/
+"""

apps/ai_tools/views.py

@@ -0,0 +1,200 @@
+# ============================================
+# apps/ai_tools/views.py
+# ============================================
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+from django.conf import settings
+
+from apps.ai_tools.serializers import (
+    AITutorRequestSerializer, AITutorResponseSerializer
+)
+
+class AIToolsViewSet(viewsets.GenericViewSet):
+    """Outils IA"""
+    permission_classes = [IsAuthenticated]
+    
+    @action(detail=False, methods=['post'])
+    def tutor(self, request):
+        """POST /api/ai/tutor/ - Proxy vers l'API Gemini/OpenAI"""
+        serializer = AITutorRequestSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        
+        question = serializer.validated_data['question']
+        subject = serializer.validated_data.get('subject', '')
+        level = serializer.validated_data.get('level', '')
+        style = serializer.validated_data.get('style', '')
+        
+        try:
+            # Utiliser Gemini si disponible, sinon OpenAI
+            if settings.GEMINI_API_KEY:
+                answer, tokens = self._call_gemini(question, subject, level, style)
+            elif settings.OPENAI_API_KEY:
+                answer, tokens = self._call_openai(question, subject, level, style)
+            else:
+                return Response(
+                    {'error': 'Aucune API IA configurée'},
+                    status=status.HTTP_503_SERVICE_UNAVAILABLE
+                )
+            
+            # Sauvegarder dans l'historique
+            from apps.ai_tools.models import AITutorSession, AITutorQuestion
+            from django.utils import timezone
+            import time
+            
+            start_time = time.time()
+            
+            session = AITutorSession.objects.create(
+                user=request.user,
+                subject=subject,
+                level=level
+            )
+            
+            AITutorQuestion.objects.create(
+                session=session,
+                question=question,
+                answer=answer,
+                model_used='gemini' if settings.GEMINI_API_KEY else 'openai',
+                tokens_used=tokens,
+                response_time=time.time() - start_time
+            )
+            
+            session.total_questions += 1
+            session.save()
+            
+            response_serializer = AITutorResponseSerializer({
+                'answer': answer,
+                'session_id': session.id,
+                'tokens_used': tokens
+            })
+            
+            return Response(response_serializer.data)
+            
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"GEMINI ERROR: {error_details}")  # Pour les logs
+            
+            return Response(
+                {
+                    'error': str(e),
+                    'details': 'Vérifiez que votre clé API Gemini est valide et configurée dans GEMINI_API_KEY',
+                    'type': type(e).__name__
+                },
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+    
+    @action(detail=False, methods=['get'])
+    def history(self, request):
+        """GET /api/ai/history/ - Récupérer l'historique des sessions"""
+        from apps.ai_tools.models import AITutorSession
+        
+        sessions = AITutorSession.objects.filter(
+            user=request.user,
+            is_active=True
+        ).prefetch_related('questions')[:20]  # Dernières 20 sessions
+        
+        sessions_data = []
+        for session in sessions:
+            questions_list = list(session.questions.all())
+            sessions_data.append({
+                'id': session.id,
+                'subject': session.subject,
+                'level': session.level,
+                'total_questions': session.total_questions,
+                'created_at': session.created_at.isoformat(),
+                'first_question': questions_list[0].question if questions_list else '',
+                'questions': [
+                    {
+                        'question': q.question,
+                        'answer': q.answer,
+                        'created_at': q.created_at.isoformat()
+                    } for q in questions_list
+                ]
+            })
+        
+        return Response(sessions_data)
+    
+    def _call_gemini(self, question, subject, level, style=''):
+        """Appel à l'API Gemini"""
+        from google import genai
+        from django.conf import settings
+        
+        # Le client récupère la clé API depuis settings ou variable d'environnement
+        # Ici on passe explicitement la clé si elle est dans settings
+        client = genai.Client(api_key=settings.GEMINI_API_KEY)
+        
+        # Construction du prompt avec tous les paramètres
+        style_instruction = ""
+        if style:
+            if "Simple" in style or "Concis" in style:
+                style_instruction = "Sois concis et va droit au but. Utilise un langage simple."
+            elif "Détaillé" in style or "Académique" in style:
+                style_instruction = "Fournis une explication détaillée et académique avec des références théoriques."
+            elif "5 ans" in style or "ELI5" in style:
+                style_instruction = "Explique comme si tu parlais à un enfant de 5 ans. Utilise des analogies simples et amusantes."
+            elif "Pratique" in style or "Exemples" in style:
+                style_instruction = "Concentre-toi sur des exemples pratiques et concrets. Montre comment appliquer les concepts."
+            elif "Socratique" in style:
+                style_instruction = "Utilise la méthode socratique : pose des questions pour guider l'étudiant vers la réponse."
+        
+        prompt = f"""Tu es un tuteur pédagogique bienveillant et patient pour EduLab Africa.
+L'étudiant est basé en Afrique.
+
+Contexte:
+Matière: {subject if subject else 'Général'}
+Niveau: {level if level else 'Adapté'}
+{f'Style: {style_instruction}' if style_instruction else ''}
+
+Question de l'étudiant: {question}
+
+Réponds de manière claire, structurée et pédagogique. Utilise des exemples culturellement pertinents pour un étudiant africain si possible.
+
+IMPORTANT - Formatage des formules :
+- Pour les formules mathématiques inline (dans le texte), utilise la syntaxe : $formule$
+  Exemple: La formule $E = mc^2$ est célèbre
+- Pour les formules mathématiques en bloc (centrées), utilise : $$formule$$
+  Exemple: $$\\int_{{a}}^{{b}} x^2 dx = \\frac{{b^3 - a^3}}{{3}}$$
+- Pour les formules chimiques, utilise aussi $ : $H_2O$, $CO_2$, $C_6H_{{12}}O_6$
+- Pour les équations chimiques : $$CH_4 + 2O_2 \\rightarrow CO_2 + 2H_2O$$
+- Utilise TOUJOURS cette syntaxe LaTeX pour TOUTES les formules mathématiques et chimiques
+"""
+        
+        response = client.models.generate_content(
+            model="gemini-flash-latest", contents=prompt
+        )
+        
+        # Estimation des tokens (approximatif)
+        tokens = len(prompt.split()) + len(response.text.split())
+        
+        return response.text, tokens
+    
+    
+    def _call_openai(self, question, subject, level, style=''):
+        """Appel à l'API OpenAI"""
+        import openai
+        from django.conf import settings
+        
+        openai.api_key = settings.OPENAI_API_KEY
+        
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {
+                    "role": "system",
+                    "content": f"Tu es un tuteur pédagogique pour la matière {subject} au niveau {level}."
+                },
+                {
+                    "role": "user",
+                    "content": question
+                }
+            ]
+        )
+        
+        answer = response.choices[0].message.content
+        tokens = response.usage.total_tokens
+        
+        return answer, tokens
+
+

apps/analytics/__init__.py

@@ -0,0 +1,2 @@
+# apps/analytics/__init__.py
+default_app_config = 'apps.analytics.apps.AnalyticsConfig'

apps/analytics/admin.py

@@ -0,0 +1,35 @@
+from django.contrib import admin
+from apps.analytics.models import SearchLog, PopularSearch
+
+@admin.register(SearchLog)
+class SearchLogAdmin(admin.ModelAdmin):
+    list_display = ['id', 'user', 'category', 'search_query', 'results_count', 'created_at']
+    list_filter = ['category', 'created_at']
+    search_fields = ['search_query', 'user__email']
+    readonly_fields = ['created_at', 'updated_at']
+    date_hierarchy = 'created_at'
+    
+    fieldsets = (
+        ('Recherche', {
+            'fields': ('user', 'category', 'search_query', 'filters_applied', 'results_count')
+        }),
+        ('Interaction', {
+            'fields': ('clicked_result_id', 'clicked_result_position')
+        }),
+        ('Métadonnées', {
+            'fields': ('session_id', 'ip_address', 'user_agent', 'page_url'),
+            'classes': ('collapse',)
+        }),
+        ('Timestamps', {
+            'fields': ('created_at', 'updated_at'),
+            'classes': ('collapse',)
+        }),
+    )
+
+
+@admin.register(PopularSearch)
+class PopularSearchAdmin(admin.ModelAdmin):
+    list_display = ['search_query', 'category', 'search_count', 'last_searched']
+    list_filter = ['category']
+    search_fields = ['search_query']
+    ordering = ['-search_count', '-last_searched']

apps/analytics/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class AnalyticsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.analytics'
+    verbose_name = 'Analytics & Tracking'

apps/analytics/migrations/0001_initial.py

@@ -0,0 +1,185 @@
+# Generated by Django 4.2.7 on 2025-12-04 23:49
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="PopularSearch",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "category",
+                    models.CharField(
+                        choices=[
+                            ("QUESTIONS", "Questions du Forum"),
+                            ("MENTORS", "Recherche de Mentors"),
+                            ("OPPORTUNITIES", "Opportunités"),
+                            ("TOOLS", "Outils Pédagogiques"),
+                            ("USERS", "Utilisateurs"),
+                            ("GENERAL", "Recherche Générale"),
+                        ],
+                        max_length=20,
+                    ),
+                ),
+                ("search_query", models.CharField(max_length=500)),
+                ("search_count", models.IntegerField(default=0)),
+                ("last_searched", models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                "verbose_name": "Recherche Populaire",
+                "verbose_name_plural": "Recherches Populaires",
+                "db_table": "popular_searches",
+                "ordering": ["-search_count", "-last_searched"],
+                "unique_together": {("category", "search_query")},
+            },
+        ),
+        migrations.CreateModel(
+            name="SearchLog",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "category",
+                    models.CharField(
+                        choices=[
+                            ("QUESTIONS", "Questions du Forum"),
+                            ("MENTORS", "Recherche de Mentors"),
+                            ("OPPORTUNITIES", "Opportunités"),
+                            ("TOOLS", "Outils Pédagogiques"),
+                            ("USERS", "Utilisateurs"),
+                            ("GENERAL", "Recherche Générale"),
+                        ],
+                        db_index=True,
+                        help_text="Type de contenu recherché",
+                        max_length=20,
+                    ),
+                ),
+                (
+                    "search_query",
+                    models.CharField(
+                        db_index=True,
+                        help_text="Texte saisi par l'utilisateur",
+                        max_length=500,
+                    ),
+                ),
+                (
+                    "filters_applied",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        help_text='Filtres appliqués lors de la recherche (ex: {"status": "solved", "tags": ["math"]})',
+                    ),
+                ),
+                (
+                    "results_count",
+                    models.IntegerField(
+                        default=0, help_text="Nombre de résultats retournés"
+                    ),
+                ),
+                (
+                    "session_id",
+                    models.CharField(
+                        blank=True,
+                        db_index=True,
+                        help_text="ID de session pour regrouper les recherches d'une même visite",
+                        max_length=100,
+                    ),
+                ),
+                (
+                    "ip_address",
+                    models.GenericIPAddressField(
+                        blank=True, help_text="Adresse IP de l'utilisateur", null=True
+                    ),
+                ),
+                (
+                    "user_agent",
+                    models.TextField(blank=True, help_text="User agent du navigateur"),
+                ),
+                (
+                    "page_url",
+                    models.CharField(
+                        blank=True,
+                        help_text="URL de la page où la recherche a été effectuée",
+                        max_length=500,
+                    ),
+                ),
+                (
+                    "clicked_result_id",
+                    models.CharField(
+                        blank=True,
+                        help_text="ID du résultat cliqué (si applicable)",
+                        max_length=100,
+                        null=True,
+                    ),
+                ),
+                (
+                    "clicked_result_position",
+                    models.IntegerField(
+                        blank=True,
+                        help_text="Position du résultat cliqué dans la liste",
+                        null=True,
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        blank=True,
+                        help_text="Utilisateur qui a effectué la recherche (null si anonyme)",
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="search_logs",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Recherche",
+                "verbose_name_plural": "Recherches",
+                "db_table": "search_logs",
+                "ordering": ["-created_at"],
+                "indexes": [
+                    models.Index(
+                        fields=["category", "-created_at"],
+                        name="search_logs_categor_24bab5_idx",
+                    ),
+                    models.Index(
+                        fields=["user", "-created_at"],
+                        name="search_logs_user_id_30eff5_idx",
+                    ),
+                    models.Index(
+                        fields=["search_query"], name="search_logs_search__18b7a2_idx"
+                    ),
+                    models.Index(
+                        fields=["-created_at"], name="search_logs_created_9a6547_idx"
+                    ),
+                ],
+            },
+        ),
+    ]

apps/analytics/models.py

@@ -0,0 +1,135 @@
+# ============================================
+# apps/analytics/models.py - Analytics & Search Tracking
+# ============================================
+from django.db import models
+from apps.core.models import TimestampMixin
+from apps.users.models import User
+
+class SearchLog(TimestampMixin):
+    """
+    Enregistre chaque recherche effectuée sur la plateforme
+    pour analyser les intérêts et comportements des utilisateurs
+    """
+    CATEGORY_CHOICES = [
+        ('QUESTIONS', 'Questions du Forum'),
+        ('MENTORS', 'Recherche de Mentors'),
+        ('OPPORTUNITIES', 'Opportunités'),
+        ('TOOLS', 'Outils Pédagogiques'),
+        ('USERS', 'Utilisateurs'),
+        ('GENERAL', 'Recherche Générale'),
+    ]
+    
+    # Qui a effectué la recherche
+    user = models.ForeignKey(
+        User, 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        blank=True,
+        related_name='search_logs',
+        help_text="Utilisateur qui a effectué la recherche (null si anonyme)"
+    )
+    
+    # Catégorie de la recherche
+    category = models.CharField(
+        max_length=20, 
+        choices=CATEGORY_CHOICES,
+        db_index=True,
+        help_text="Type de contenu recherché"
+    )
+    
+    # Terme de recherche
+    search_query = models.CharField(
+        max_length=500,
+        db_index=True,
+        help_text="Texte saisi par l'utilisateur"
+    )
+    
+    # Filtres appliqués (JSON pour flexibilité)
+    filters_applied = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Filtres appliqués lors de la recherche (ex: {\"status\": \"solved\", \"tags\": [\"math\"]})"
+    )
+    
+    # Résultats
+    results_count = models.IntegerField(
+        default=0,
+        help_text="Nombre de résultats retournés"
+    )
+    
+    # Métadonnées de session
+    session_id = models.CharField(
+        max_length=100,
+        blank=True,
+        db_index=True,
+        help_text="ID de session pour regrouper les recherches d'une même visite"
+    )
+    
+    ip_address = models.GenericIPAddressField(
+        null=True,
+        blank=True,
+        help_text="Adresse IP de l'utilisateur"
+    )
+    
+    user_agent = models.TextField(
+        blank=True,
+        help_text="User agent du navigateur"
+    )
+    
+    # Page d'origine
+    page_url = models.CharField(
+        max_length=500,
+        blank=True,
+        help_text="URL de la page où la recherche a été effectuée"
+    )
+    
+    # Interaction
+    clicked_result_id = models.CharField(
+        max_length=100,
+        null=True,
+        blank=True,
+        help_text="ID du résultat cliqué (si applicable)"
+    )
+    
+    clicked_result_position = models.IntegerField(
+        null=True,
+        blank=True,
+        help_text="Position du résultat cliqué dans la liste"
+    )
+    
+    class Meta:
+        db_table = 'search_logs'
+        verbose_name = 'Recherche'
+        verbose_name_plural = 'Recherches'
+        indexes = [
+            models.Index(fields=['category', '-created_at']),
+            models.Index(fields=['user', '-created_at']),
+            models.Index(fields=['search_query']),
+            models.Index(fields=['-created_at']),
+        ]
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        user_info = self.user.email if self.user else "Anonyme"
+        return f"{user_info} - {self.category}: '{self.search_query}'"
+
+
+class PopularSearch(models.Model):
+    """
+    Vue matérialisée des recherches les plus populaires
+    Mise à jour périodiquement pour optimiser les performances
+    """
+    category = models.CharField(max_length=20, choices=SearchLog.CATEGORY_CHOICES)
+    search_query = models.CharField(max_length=500)
+    search_count = models.IntegerField(default=0)
+    last_searched = models.DateTimeField(auto_now=True)
+    
+    class Meta:
+        db_table = 'popular_searches'
+        verbose_name = 'Recherche Populaire'
+        verbose_name_plural = 'Recherches Populaires'
+        unique_together = ['category', 'search_query']
+        ordering = ['-search_count', '-last_searched']
+    
+    def __str__(self):
+        return f"{self.category}: '{self.search_query}' ({self.search_count}x)"

apps/analytics/serializers.py

@@ -0,0 +1,24 @@
+# ============================================
+# apps/analytics/serializers.py
+# ============================================
+from rest_framework import serializers
+from apps.analytics.models import SearchLog, PopularSearch
+
+class SearchLogSerializer(serializers.ModelSerializer):
+    """Serializer pour enregistrer une recherche"""
+    
+    class Meta:
+        model = SearchLog
+        fields = [
+            'id', 'category', 'search_query', 'filters_applied',
+            'results_count', 'created_at'
+        ]
+        read_only_fields = ['id', 'created_at']
+
+
+class PopularSearchSerializer(serializers.ModelSerializer):
+    """Serializer pour les recherches populaires"""
+    
+    class Meta:
+        model = PopularSearch
+        fields = ['category', 'search_query', 'search_count', 'last_searched']

apps/analytics/services.py

@@ -0,0 +1,144 @@
+# ============================================
+# apps/analytics/services.py - Search Tracking Service
+# ============================================
+from apps.analytics.models import SearchLog, PopularSearch
+from django.db.models import F
+
+class SearchTrackingService:
+    """Service centralisé pour tracker les recherches"""
+    
+    @staticmethod
+    def log_search(
+        category: str,
+        search_query: str,
+        user=None,
+        filters_applied: dict = None,
+        results_count: int = 0,
+        request=None
+    ):
+        """
+        Enregistre une recherche dans les logs
+        
+        Args:
+            category: Catégorie de recherche (QUESTIONS, MENTORS, etc.)
+            search_query: Terme recherché
+            user: Utilisateur qui effectue la recherche (None si anonyme)
+            filters_applied: Dict des filtres appliqués
+            results_count: Nombre de résultats retournés
+            request: Objet request Django pour extraire métadonnées
+        
+        Returns:
+            SearchLog instance
+        """
+        # Extraire métadonnées de la requête si disponible
+        session_id = ''
+        ip_address = None
+        user_agent = ''
+        page_url = ''
+        
+        if request:
+            session_id = request.session.session_key or ''
+            ip_address = request.META.get('REMOTE_ADDR')
+            user_agent = request.META.get('HTTP_USER_AGENT', '')[:500]
+            page_url = request.META.get('HTTP_REFERER', '')[:500]
+        
+        # Créer le log
+        search_log = SearchLog.objects.create(
+            user=user,
+            category=category,
+            search_query=search_query.strip()[:500],
+            filters_applied=filters_applied or {},
+            results_count=results_count,
+            session_id=session_id,
+            ip_address=ip_address,
+            user_agent=user_agent,
+            page_url=page_url
+        )
+        
+        # Mettre à jour les recherches populaires
+        SearchTrackingService._update_popular_search(category, search_query.strip())
+        
+        return search_log
+    
+    @staticmethod
+    def _update_popular_search(category: str, search_query: str):
+        """Mise à jour incrémentale des recherches populaires"""
+        if not search_query or len(search_query) < 2:
+            return
+        
+        popular, created = PopularSearch.objects.get_or_create(
+            category=category,
+            search_query=search_query[:500],
+            defaults={'search_count': 1}
+        )
+        
+        if not created:
+            popular.search_count = F('search_count') + 1
+            popular.save(update_fields=['search_count', 'last_searched'])
+    
+    @staticmethod
+    def log_result_click(search_log_id: int, result_id: str, position: int):
+        """
+        Enregistre le clic sur un résultat de recherche
+        
+        Args:
+            search_log_id: ID du SearchLog
+            result_id: ID du résultat cliqué
+            position: Position dans la liste (0-indexed)
+        """
+        try:
+            search_log = SearchLog.objects.get(id=search_log_id)
+            search_log.clicked_result_id = str(result_id)
+            search_log.clicked_result_position = position
+            search_log.save(update_fields=['clicked_result_id', 'clicked_result_position'])
+        except SearchLog.DoesNotExist:
+            pass
+    
+    @staticmethod
+    def get_popular_searches(category: str = None, limit: int = 10):
+        """
+        Récupère les recherches les plus populaires
+        
+        Args:
+            category: Filtrer par catégorie (None = toutes)
+            limit: Nombre max de résultats
+        
+        Returns:
+            QuerySet de PopularSearch
+        """
+        qs = PopularSearch.objects.all()
+        
+        if category:
+            qs = qs.filter(category=category)
+        
+        return qs[:limit]
+    
+    @staticmethod
+    def get_trending_searches(category: str = None, days: int = 7, limit: int = 10):
+        """
+        Récupère les recherches tendances (populaires récemment)
+        
+        Args:
+            category: Filtrer par catégorie
+            days: Nombre de jours à considérer
+            limit: Nombre max de résultats
+        
+        Returns:
+            Liste de dicts avec query et count
+        """
+        from django.utils import timezone
+        from datetime import timedelta
+        from django.db.models import Count
+        
+        since = timezone.now() - timedelta(days=days)
+        
+        qs = SearchLog.objects.filter(created_at__gte=since)
+        
+        if category:
+            qs = qs.filter(category=category)
+        
+        trending = qs.values('search_query').annotate(
+            count=Count('id')
+        ).order_by('-count')[:limit]
+        
+        return list(trending)

apps/analytics/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

apps/analytics/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+from apps.analytics import views
+
+urlpatterns = [
+    path('search-log/', views.log_search, name='log-search'),
+    path('result-click/', views.log_result_click, name='log-result-click'),
+    path('popular-searches/', views.popular_searches, name='popular-searches'),
+    path('trending-searches/', views.trending_searches, name='trending-searches'),
+]

apps/analytics/views.py

@@ -0,0 +1,117 @@
+# ============================================
+# apps/analytics/views.py
+# ============================================
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+from apps.analytics.services import SearchTrackingService
+from apps.analytics.serializers import SearchLogSerializer, PopularSearchSerializer
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def log_search(request):
+    """
+    Enregistrer une recherche
+    POST /api/analytics/search-log/
+    
+    Body:
+    {
+        "category": "QUESTIONS",
+        "search_query": "python",
+        "filters_applied": {"status": "unsolved"},
+        "results_count": 15
+    }
+    """
+    serializer = SearchLogSerializer(data=request.data)
+    
+    if serializer.is_valid():
+        user = request.user if request.user.is_authenticated else None
+        
+        search_log = SearchTrackingService.log_search(
+            category=serializer.validated_data['category'],
+            search_query=serializer.validated_data['search_query'],
+            user=user,
+            filters_applied=serializer.validated_data.get('filters_applied', {}),
+            results_count=serializer.validated_data.get('results_count', 0),
+            request=request
+        )
+        
+        return Response(
+            SearchLogSerializer(search_log).data,
+            status=status.HTTP_201_CREATED
+        )
+    
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def log_result_click(request):
+    """
+    Enregistrer le clic sur un résultat
+    POST /api/analytics/result-click/
+    
+    Body:
+    {
+        "search_log_id": 123,
+        "result_id": "456",
+        "position": 2
+    }
+    """
+    search_log_id = request.data.get('search_log_id')
+    result_id = request.data.get('result_id')
+    position = request.data.get('position')
+    
+    if not all([search_log_id, result_id, position is not None]):
+        return Response(
+            {'error': 'Missing required fields'},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+    
+    SearchTrackingService.log_result_click(
+        search_log_id=search_log_id,
+        result_id=result_id,
+        position=position
+    )
+    
+    return Response({'status': 'success'}, status=status.HTTP_200_OK)
+
+
+@api_view(['GET'])
+@permission_classes([AllowAny])
+def popular_searches(request):
+    """
+    Récupérer les recherches populaires
+    GET /api/analytics/popular-searches/?category=QUESTIONS&limit=10
+    """
+    category = request.query_params.get('category')
+    limit = int(request.query_params.get('limit', 10))
+    
+    searches = SearchTrackingService.get_popular_searches(
+        category=category,
+        limit=min(limit, 50)  # Max 50
+    )
+    
+    serializer = PopularSearchSerializer(searches, many=True)
+    return Response(serializer.data)
+
+
+@api_view(['GET'])
+@permission_classes([AllowAny])
+def trending_searches(request):
+    """
+    Récupérer les recherches tendances
+    GET /api/analytics/trending-searches/?category=QUESTIONS&days=7&limit=10
+    """
+    category = request.query_params.get('category')
+    days = int(request.query_params.get('days', 7))
+    limit = int(request.query_params.get('limit', 10))
+    
+    trending = SearchTrackingService.get_trending_searches(
+        category=category,
+        days=min(days, 30),  # Max 30 jours
+        limit=min(limit, 50)
+    )
+    
+    return Response(trending)

apps/bookings/admin.py

@@ -0,0 +1,29 @@
+from django.contrib import admin
+from .models import (
+    Booking, BookingDomain, BookingExpectation, 
+    BookingMainQuestion, BookingStatusHistory
+)
+
+class BookingDomainInline(admin.TabularInline):
+    model = BookingDomain
+    extra = 0
+
+class BookingExpectationInline(admin.StackedInline):
+    model = BookingExpectation
+    extra = 0
+
+class BookingMainQuestionInline(admin.StackedInline):
+    model = BookingMainQuestion
+    extra = 0
+
+@admin.register(Booking)
+class BookingAdmin(admin.ModelAdmin):
+    list_display = ('id', 'student', 'mentor', 'date', 'time', 'status', 'created_at')
+    list_filter = ('status', 'date', 'created_at')
+    search_fields = ('student__email', 'mentor__email')
+    inlines = [BookingDomainInline, BookingExpectationInline, BookingMainQuestionInline]
+
+@admin.register(BookingStatusHistory)
+class BookingStatusHistoryAdmin(admin.ModelAdmin):
+    list_display = ('booking', 'previous_status', 'new_status', 'changed_by', 'created_at')
+    list_filter = ('new_status', 'created_at')

apps/bookings/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class BookingsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.bookings'
+    
+    def ready(self):
+        import apps.bookings.signals  # noqa

apps/bookings/migrations/0001_initial.py

@@ -0,0 +1,150 @@
+# Generated by Django 4.2.7 on 2025-11-29 13:38
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="Booking",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "deleted_at",
+                    models.DateTimeField(blank=True, db_index=True, null=True),
+                ),
+                ("is_active", models.BooleanField(db_index=True, default=True)),
+                ("date", models.DateField(db_index=True)),
+                ("time", models.TimeField()),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("PENDING", "En attente"),
+                            ("CONFIRMED", "Confirmé"),
+                            ("REJECTED", "Refusé"),
+                            ("COMPLETED", "Terminé"),
+                            ("CANCELLED", "Annulé"),
+                        ],
+                        db_index=True,
+                        default="PENDING",
+                        max_length=20,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Réservation",
+                "verbose_name_plural": "Réservations",
+                "db_table": "bookings",
+                "ordering": ["-created_at"],
+            },
+        ),
+        migrations.CreateModel(
+            name="BookingDomain",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("domain", models.CharField(max_length=100)),
+            ],
+            options={
+                "db_table": "booking_domains",
+            },
+        ),
+        migrations.CreateModel(
+            name="BookingExpectation",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("is_current", models.BooleanField(db_index=True, default=True)),
+                ("expectation", models.TextField()),
+            ],
+            options={
+                "db_table": "booking_expectations",
+            },
+        ),
+        migrations.CreateModel(
+            name="BookingMainQuestion",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("is_current", models.BooleanField(db_index=True, default=True)),
+                ("question", models.TextField()),
+            ],
+            options={
+                "db_table": "booking_main_questions",
+            },
+        ),
+        migrations.CreateModel(
+            name="BookingStatusHistory",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("previous_status", models.CharField(max_length=20)),
+                ("new_status", models.CharField(max_length=20)),
+                ("reason", models.TextField(blank=True, null=True)),
+                (
+                    "booking",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="status_history",
+                        to="bookings.booking",
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "booking_status_history",
+                "ordering": ["-created_at"],
+            },
+        ),
+    ]

apps/bookings/migrations/0002_initial.py

@@ -0,0 +1,89 @@
+# Generated by Django 4.2.7 on 2025-11-29 13:38
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("bookings", "0001_initial"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="bookingstatushistory",
+            name="changed_by",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL
+            ),
+        ),
+        migrations.AddField(
+            model_name="bookingmainquestion",
+            name="booking",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="main_questions",
+                to="bookings.booking",
+            ),
+        ),
+        migrations.AddField(
+            model_name="bookingexpectation",
+            name="booking",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="expectations",
+                to="bookings.booking",
+            ),
+        ),
+        migrations.AddField(
+            model_name="bookingdomain",
+            name="booking",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="domains",
+                to="bookings.booking",
+            ),
+        ),
+        migrations.AddField(
+            model_name="booking",
+            name="mentor",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="bookings_as_mentor",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddField(
+            model_name="booking",
+            name="student",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="bookings_as_student",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="booking",
+            index=models.Index(
+                fields=["student", "status", "is_active"],
+                name="bookings_student_84c0c2_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="booking",
+            index=models.Index(
+                fields=["mentor", "status", "is_active"],
+                name="bookings_mentor__d43236_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="booking",
+            index=models.Index(
+                fields=["date", "time"], name="bookings_date_44cf2c_idx"
+            ),
+        ),
+    ]

apps/bookings/models.py

@@ -0,0 +1,69 @@
+# ============================================
+# apps/bookings/models.py - Système Réservation
+# ============================================
+from django.db import models
+from apps.core.models import TimestampMixin, SoftDeleteMixin, VersionedFieldMixin
+from apps.users.models import User
+
+class Booking(TimestampMixin, SoftDeleteMixin):
+    """Réservation de session avec mentor"""
+    STATUS_CHOICES = [
+        ('PENDING', 'En attente'),
+        ('CONFIRMED', 'Confirmé'),
+        ('REJECTED', 'Refusé'),
+        ('COMPLETED', 'Terminé'),
+        ('CANCELLED', 'Annulé'),
+    ]
+    
+    student = models.ForeignKey(User, on_delete=models.CASCADE, related_name='bookings_as_student')
+    mentor = models.ForeignKey(User, on_delete=models.CASCADE, related_name='bookings_as_mentor')
+    date = models.DateField(db_index=True)
+    time = models.TimeField()
+    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='PENDING', db_index=True)
+    
+    class Meta:
+        db_table = 'bookings'
+        verbose_name = 'Réservation'
+        verbose_name_plural = 'Réservations'
+        indexes = [
+            models.Index(fields=['student', 'status', 'is_active']),
+            models.Index(fields=['mentor', 'status', 'is_active']),
+            models.Index(fields=['date', 'time']),
+        ]
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        return f"Booking #{self.id}: {self.student.email} -> {self.mentor.email}"
+
+class BookingDomain(TimestampMixin):
+    booking = models.ForeignKey(Booking, on_delete=models.CASCADE, related_name='domains')
+    domain = models.CharField(max_length=100)
+    
+    class Meta:
+        db_table = 'booking_domains'
+
+class BookingExpectation(TimestampMixin, VersionedFieldMixin):
+    booking = models.ForeignKey(Booking, on_delete=models.CASCADE, related_name='expectations')
+    expectation = models.TextField()
+    
+    class Meta:
+        db_table = 'booking_expectations'
+
+class BookingMainQuestion(TimestampMixin, VersionedFieldMixin):
+    booking = models.ForeignKey(Booking, on_delete=models.CASCADE, related_name='main_questions')
+    question = models.TextField()
+    
+    class Meta:
+        db_table = 'booking_main_questions'
+
+class BookingStatusHistory(TimestampMixin):
+    """Traçabilité des changements de statut"""
+    booking = models.ForeignKey(Booking, on_delete=models.CASCADE, related_name='status_history')
+    previous_status = models.CharField(max_length=20)
+    new_status = models.CharField(max_length=20)
+    changed_by = models.ForeignKey(User, on_delete=models.CASCADE)
+    reason = models.TextField(null=True, blank=True)
+    
+    class Meta:
+        db_table = 'booking_status_history'
+        ordering = ['-created_at']

apps/bookings/serializers.py

@@ -0,0 +1,142 @@
+# ============================================
+# apps/bookings/serializers.py
+# ============================================
+from rest_framework import serializers
+from apps.bookings.models import (
+    Booking, BookingDomain, BookingExpectation, BookingMainQuestion
+)
+from apps.users.serializers import UserSerializer
+from apps.core.serializers import HashIdField
+
+class BookingSerializer(serializers.ModelSerializer):
+    student = UserSerializer(read_only=True)
+    mentor = UserSerializer(read_only=True)
+    domains = serializers.SerializerMethodField()
+    expectation = serializers.SerializerMethodField()
+    main_question = serializers.SerializerMethodField()
+    status_label = serializers.CharField(source='get_status_display', read_only=True)
+    id = HashIdField(read_only=True)
+    
+    class Meta:
+        model = Booking
+        fields = [
+            'id', 'student', 'mentor', 'date', 'time', 'status', 'status_label',
+            'domains', 'expectation', 'main_question', 'created_at', 'updated_at'
+        ]
+        read_only_fields = ['id', 'student', 'created_at', 'updated_at']
+    
+    def get_domains(self, obj):
+        return [d.domain for d in obj.domains.all()]
+    
+    def get_expectation(self, obj):
+        exp = obj.expectations.filter(is_current=True).first()
+        return exp.expectation if exp else None
+    
+    def get_main_question(self, obj):
+        q = obj.main_questions.filter(is_current=True).first()
+        return q.question if q else None
+
+class BookingCreateSerializer(serializers.Serializer):
+    """Création d'une réservation"""
+    mentor_id = HashIdField()
+    date = serializers.DateField()
+    time = serializers.TimeField()
+    domains = serializers.ListField(
+        child=serializers.CharField(max_length=100),
+        min_length=1
+    )
+    expectations = serializers.CharField()
+    main_questions = serializers.CharField()
+    
+    def validate_mentor_id(self, value):
+        from apps.users.models import User
+        try:
+            mentor = User.objects.get(id=value, role='MENTOR', is_active=True)
+            if not hasattr(mentor, 'mentor_profile'):
+                raise serializers.ValidationError("Ce mentor n'a pas de profil actif")
+        except User.DoesNotExist:
+            raise serializers.ValidationError("Mentor introuvable")
+        return value
+    
+    def validate_date(self, value):
+        from datetime import date
+        if value < date.today():
+            raise serializers.ValidationError("La date doit être dans le futur")
+        return value
+    
+    def create(self, validated_data):
+        from django.db import transaction
+        from apps.users.models import User
+        
+        user = self.context['request'].user
+        mentor = User.objects.get(id=validated_data['mentor_id'])
+        domains = validated_data.pop('domains')
+        expectations = validated_data.pop('expectations')
+        main_question = validated_data.pop('main_questions')
+        validated_data.pop('mentor_id')
+        
+        with transaction.atomic():
+            booking = Booking.objects.create(
+                student=user,
+                mentor=mentor,
+                **validated_data
+            )
+            
+            # Ajouter domaines
+            for domain in domains:
+                BookingDomain.objects.create(booking=booking, domain=domain)
+            
+            # Ajouter attentes
+            BookingExpectation.objects.create(
+                booking=booking,
+                expectation=expectations
+            )
+            
+            # Ajouter question principale
+            BookingMainQuestion.objects.create(
+                booking=booking,
+                question=main_question
+            )
+            
+            # Créer notification pour le mentor
+            from apps.notifications.services import NotificationService
+            NotificationService.create_booking_notification(booking)
+        
+        return booking
+
+class BookingStatusUpdateSerializer(serializers.Serializer):
+    """Mise à jour du statut"""
+    status = serializers.ChoiceField(choices=['CONFIRMED', 'REJECTED', 'COMPLETED', 'CANCELLED'])
+    reason = serializers.CharField(required=False, allow_blank=True)
+    
+    def update(self, instance, validated_data):
+        from apps.bookings.models import BookingStatusHistory
+        from django.db import transaction
+        
+        with transaction.atomic():
+            previous_status = instance.status
+            instance.status = validated_data['status']
+            instance.save()
+            
+            # Historiser
+            BookingStatusHistory.objects.create(
+                booking=instance,
+                previous_status=previous_status,
+                new_status=validated_data['status'],
+                changed_by=self.context['request'].user,
+                reason=validated_data.get('reason', '')
+            )
+            
+            # Créer notification pour l'étudiant
+            from apps.notifications.services import NotificationService
+            NotificationService.create_booking_status_notification(instance)
+            
+            # Attribution de points si complété
+            if validated_data['status'] == 'COMPLETED':
+                from django.conf import settings
+                instance.student.add_points(
+                    settings.GAMIFICATION_POINTS['BOOKING_COMPLETED'],
+                    'booking_completed'
+                )
+        
+        return instance

apps/bookings/signals.py

@@ -0,0 +1,58 @@
+# ============================================
+# apps/bookings/signals.py - Signaux pour les réservations
+# ============================================
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(post_save, sender='bookings.Booking')
+def schedule_tasks_on_confirm(sender, instance, created, **kwargs):
+    """
+    Quand un booking passe en CONFIRMED:
+    1. Planifie le déblocage des messages
+    2. Planifie les rappels de rendez-vous
+    """
+    from django.utils import timezone
+    
+    # Ne traiter que les bookings confirmés
+    if instance.status != 'CONFIRMED':
+        return
+    
+    # Calculer l'heure de début
+    booking_start = datetime.datetime.combine(instance.date, instance.time)
+    booking_start = timezone.make_aware(booking_start)
+    now = timezone.now()
+    
+    # === 1. Déblocage des messages ===
+    if booking_start <= now:
+        try:
+            from apps.messaging.tasks import unlock_messages_for_booking
+            # Exécuter immédiatement
+            unlock_messages_for_booking.delay(instance.id)
+            logger.info(f"Déblocage immédiat des messages pour booking {instance.id}")
+        except Exception as e:
+            logger.error(f"Erreur lors du déblocage immédiat: {e}")
+    else:
+        try:
+            from apps.messaging.tasks import unlock_messages_for_booking
+            # Planifier l'exécution à l'heure du booking
+            unlock_messages_for_booking.apply_async(
+                args=[instance.id],
+                eta=booking_start
+            )
+            logger.info(f"Déblocage planifié pour booking {instance.id} à {booking_start}")
+        except Exception as e:
+            logger.error(f"Erreur lors de la planification du déblocage: {e}")
+    
+    # === 2. Planifier les rappels de rendez-vous ===
+    try:
+        from apps.bookings.tasks import schedule_all_reminders
+        # Planifier tous les rappels de manière asynchrone
+        schedule_all_reminders.delay(instance.id)
+        logger.info(f"Planification des rappels pour booking {instance.id}")
+    except Exception as e:
+        logger.error(f"Erreur lors de la planification des rappels: {e}")

apps/bookings/tasks.py

@@ -0,0 +1,206 @@
+# ============================================
+# apps/bookings/tasks.py - Tâches Celery pour les réservations
+# ============================================
+import datetime
+from celery import shared_task
+from django.utils import timezone
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Intervalles de rappel avant le rendez-vous (en minutes)
+REMINDER_INTERVALS = [
+    (1440, "24 heures"),   # 24h avant
+    (60, "1 heure"),       # 1h avant
+    (30, "30 minutes"),    # 30min avant
+    (15, "15 minutes"),    # 15min avant
+    (5, "5 minutes"),      # 5min avant
+]
+
+
+@shared_task(name='bookings.send_booking_reminder')
+def send_booking_reminder(booking_id, time_label):
+    """
+    Envoie une notification de rappel aux participants d'un booking.
+    
+    Args:
+        booking_id: ID du booking
+        time_label: Texte décrivant le temps restant (ex: "30 minutes")
+    """
+    from apps.bookings.models import Booking
+    from apps.notifications.models import Notification, NotificationTitle, NotificationMessage
+    from apps.notifications.services import NotificationService
+    
+    try:
+        booking = Booking.objects.get(id=booking_id)
+        
+        # Vérifier que le booking est toujours confirmé
+        if booking.status != 'CONFIRMED':
+            logger.info(f"Booking {booking_id} n'est plus confirmé, skip reminder.")
+            return
+        
+        # Récupérer les noms des participants
+        student_profile = booking.student.profiles.filter(is_current=True).first()
+        student_name = student_profile.name if student_profile else booking.student.email
+        
+        mentor_profile = booking.mentor.profiles.filter(is_current=True).first()
+        mentor_name = mentor_profile.name if mentor_profile else booking.mentor.email
+        
+        # Notification pour l'étudiant
+        notif_student = Notification.objects.create(
+            user=booking.student,
+            type='BOOKING',
+            link=f'/chat?partner={booking.mentor.id}'
+        )
+        NotificationTitle.objects.create(
+            notification=notif_student,
+            title=f'⏰ Rappel : Rendez-vous dans {time_label}'
+        )
+        NotificationMessage.objects.create(
+            notification=notif_student,
+            message=f'Votre session avec {mentor_name} commence dans {time_label}. Préparez-vous !'
+        )
+        NotificationService._send_ws_notification(notif_student)
+        
+        # Notification pour le mentor
+        notif_mentor = Notification.objects.create(
+            user=booking.mentor,
+            type='BOOKING',
+            link=f'/chat?partner={booking.student.id}'
+        )
+        NotificationTitle.objects.create(
+            notification=notif_mentor,
+            title=f'⏰ Rappel : Rendez-vous dans {time_label}'
+        )
+        NotificationMessage.objects.create(
+            notification=notif_mentor,
+            message=f'Votre session avec {student_name} commence dans {time_label}. L\'étudiant vous attend !'
+        )
+        NotificationService._send_ws_notification(notif_mentor)
+        
+        logger.info(f"Rappel envoyé pour booking {booking_id} ({time_label})")
+        return True
+        
+    except Booking.DoesNotExist:
+        logger.error(f"Booking {booking_id} introuvable")
+        return False
+    except Exception as e:
+        logger.error(f"Erreur lors de l'envoi du rappel: {e}")
+        raise
+
+
+@shared_task(name='bookings.send_booking_starting_now')
+def send_booking_starting_now(booking_id):
+    """
+    Notification spéciale quand le rendez-vous commence.
+    """
+    from apps.bookings.models import Booking
+    from apps.notifications.models import Notification, NotificationTitle, NotificationMessage
+    from apps.notifications.services import NotificationService
+    
+    try:
+        booking = Booking.objects.get(id=booking_id)
+        
+        if booking.status != 'CONFIRMED':
+            return
+        
+        # Récupérer les noms
+        student_profile = booking.student.profiles.filter(is_current=True).first()
+        student_name = student_profile.name if student_profile else booking.student.email
+        
+        mentor_profile = booking.mentor.profiles.filter(is_current=True).first()
+        mentor_name = mentor_profile.name if mentor_profile else booking.mentor.email
+        
+        # Notification pour l'étudiant
+        notif_student = Notification.objects.create(
+            user=booking.student,
+            type='BOOKING',
+            link=f'/chat?partner={booking.mentor.id}'
+        )
+        NotificationTitle.objects.create(
+            notification=notif_student,
+            title='🚀 C\'est l\'heure de votre session !'
+        )
+        NotificationMessage.objects.create(
+            notification=notif_student,
+            message=f'Votre session de mentorat avec {mentor_name} commence maintenant. Cliquez pour rejoindre le chat.'
+        )
+        NotificationService._send_ws_notification(notif_student)
+        
+        # Notification pour le mentor
+        notif_mentor = Notification.objects.create(
+            user=booking.mentor,
+            type='BOOKING',
+            link=f'/chat?partner={booking.student.id}'
+        )
+        NotificationTitle.objects.create(
+            notification=notif_mentor,
+            title='🚀 C\'est l\'heure de votre session !'
+        )
+        NotificationMessage.objects.create(
+            notification=notif_mentor,
+            message=f'Votre session avec {student_name} commence maintenant. L\'étudiant vous attend !'
+        )
+        NotificationService._send_ws_notification(notif_mentor)
+        
+        logger.info(f"Notification de démarrage envoyée pour booking {booking_id}")
+        return True
+        
+    except Booking.DoesNotExist:
+        logger.error(f"Booking {booking_id} introuvable")
+        return False
+    except Exception as e:
+        logger.error(f"Erreur: {e}")
+        raise
+
+
+@shared_task(name='bookings.schedule_all_reminders')
+def schedule_all_reminders(booking_id):
+    """
+    Planifie tous les rappels pour un booking.
+    À appeler quand un booking est confirmé.
+    """
+    from apps.bookings.models import Booking
+    
+    try:
+        booking = Booking.objects.get(id=booking_id)
+        
+        if booking.status != 'CONFIRMED':
+            return
+        
+        # Calculer l'heure de début
+        booking_start = datetime.datetime.combine(booking.date, booking.time)
+        booking_start = timezone.make_aware(booking_start)
+        now = timezone.now()
+        
+        scheduled_count = 0
+        
+        # Planifier chaque rappel
+        for minutes_before, label in REMINDER_INTERVALS:
+            reminder_time = booking_start - datetime.timedelta(minutes=minutes_before)
+            
+            # Ne planifier que les rappels dans le futur
+            if reminder_time > now:
+                send_booking_reminder.apply_async(
+                    args=[booking_id, label],
+                    eta=reminder_time
+                )
+                scheduled_count += 1
+                logger.info(f"Rappel planifié pour booking {booking_id}: {label} (à {reminder_time})")
+        
+        # Planifier la notification de démarrage
+        if booking_start > now:
+            send_booking_starting_now.apply_async(
+                args=[booking_id],
+                eta=booking_start
+            )
+            logger.info(f"Notification de démarrage planifiée pour booking {booking_id}")
+        
+        return f"Planifié {scheduled_count} rappels pour booking {booking_id}"
+        
+    except Booking.DoesNotExist:
+        logger.error(f"Booking {booking_id} introuvable")
+        return None
+    except Exception as e:
+        logger.error(f"Erreur lors de la planification: {e}")
+        raise

apps/bookings/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

apps/bookings/urls.py

@@ -0,0 +1,23 @@
+# ============================================
+# apps/bookings/urls.py
+# ============================================
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from apps.bookings.views import BookingViewSet
+
+router = DefaultRouter()
+router.register(r'', BookingViewSet, basename='booking')
+
+urlpatterns = [
+    path('', include(router.urls)),
+]
+
+"""
+Endpoints disponibles:
+- GET /api/bookings/ (mes réservations)
+- POST /api/bookings/ (créer)
+- GET /api/bookings/{id}/
+- PATCH /api/bookings/{id}/update_status/
+- GET /api/bookings/mentor_requests/
+"""
+

apps/bookings/views.py

@@ -0,0 +1,102 @@
+# ============================================
+# apps/bookings/views.py
+# ============================================
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+
+from apps.bookings.models import Booking
+from apps.bookings.serializers import (
+    BookingSerializer, BookingCreateSerializer, BookingStatusUpdateSerializer
+)
+
+from apps.core.mixins import HashIdMixin
+
+class BookingViewSet(HashIdMixin, viewsets.ModelViewSet):
+    """Gestion des réservations"""
+    permission_classes = [IsAuthenticated]
+    serializer_class = BookingSerializer
+    
+    def get_queryset(self):
+        user = self.request.user
+        queryset = Booking.objects.filter(is_active=True)
+        
+        # Étudiants voient leurs réservations
+        if user.role == 'STUDENT':
+            queryset = queryset.filter(student=user)
+        # Mentors voient les demandes reçues
+        elif user.role == 'MENTOR':
+            queryset = queryset.filter(mentor=user)
+        
+        # Filtre par statut
+        status_filter = self.request.query_params.get('status')
+        if status_filter:
+            queryset = queryset.filter(status=status_filter)
+        
+        return queryset.order_by('-created_at')
+    
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return BookingCreateSerializer
+        elif self.action == 'update_status':
+            return BookingStatusUpdateSerializer
+        return BookingSerializer
+    
+    def create(self, request, *args, **kwargs):
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        booking = serializer.save()
+        
+        # Utiliser le serializer standard pour la réponse
+        response_serializer = BookingSerializer(booking, context=self.get_serializer_context())
+        headers = self.get_success_headers(response_serializer.data)
+        return Response(response_serializer.data, status=status.HTTP_201_CREATED, headers=headers)
+    
+    def perform_create(self, serializer):
+        serializer.save()
+    
+    @action(detail=True, methods=['patch'], permission_classes=[IsAuthenticated])
+    def update_status(self, request, pk=None):
+        """PATCH /api/bookings/{id}/update_status/"""
+        booking = self.get_object()
+        
+        # Vérifier que c'est le mentor
+        if booking.mentor != request.user:
+            return Response(
+                {'error': 'Seul le mentor peut modifier le statut'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+        
+        serializer = BookingStatusUpdateSerializer(
+            booking,
+            data=request.data,
+            context={'request': request}
+        )
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        
+        return Response(BookingSerializer(booking).data)
+    
+    @action(detail=False, methods=['get'], permission_classes=[IsAuthenticated])
+    def mentor_requests(self, request):
+        """GET /api/bookings/mentor_requests/ - Demandes reçues par le mentor"""
+        if request.user.role != 'MENTOR':
+            return Response(
+                {'error': 'Accessible uniquement aux mentors'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+        
+        bookings = Booking.objects.filter(
+            mentor=request.user,
+            is_active=True
+        ).order_by('date', 'time')
+        
+        page = self.paginate_queryset(bookings)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        
+        serializer = self.get_serializer(bookings, many=True)
+        return Response(serializer.data)
+

apps/core/admin.py

@@ -0,0 +1,27 @@
+from django.contrib import admin
+from .models import ImpactStat, LearningTool, Testimonial, SocialLink
+
+@admin.register(ImpactStat)
+class ImpactStatAdmin(admin.ModelAdmin):
+    list_display = ('title', 'value', 'icon', 'order', 'is_visible')
+    list_editable = ('order', 'is_visible')
+    search_fields = ('title', 'description')
+
+@admin.register(LearningTool)
+class LearningToolAdmin(admin.ModelAdmin):
+    list_display = ('title', 'category', 'level', 'status', 'order', 'is_visible')
+    list_editable = ('status', 'order', 'is_visible')
+    list_filter = ('category', 'level', 'status')
+    search_fields = ('title', 'description')
+
+@admin.register(Testimonial)
+class TestimonialAdmin(admin.ModelAdmin):
+    list_display = ('name', 'role', 'country', 'order', 'is_visible')
+    list_editable = ('order', 'is_visible')
+    search_fields = ('name', 'text', 'country')
+
+@admin.register(SocialLink)
+class SocialLinkAdmin(admin.ModelAdmin):
+    list_display = ('name', 'platform', 'url', 'order', 'is_visible')
+    list_editable = ('order', 'is_visible')
+    list_filter = ('platform',)

apps/core/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class CoreConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.core'
+
+    def ready(self):
+        import apps.core.signals

apps/core/exceptions.py

@@ -0,0 +1,60 @@
+"""
+Custom exception handler for Django REST Framework
+Développé par Marino ATOHOUN pour Hypee
+"""
+
+from rest_framework.views import exception_handler
+from rest_framework.response import Response
+from rest_framework import status
+
+
+def custom_exception_handler(exc, context):
+    """
+    Gestionnaire d'exceptions personnalisé pour DRF
+    
+    Ajoute des informations supplémentaires aux réponses d'erreur
+    et standardise le format de retour.
+    """
+    # Appeler le gestionnaire par défaut de DRF
+    response = exception_handler(exc, context)
+    
+    if response is not None:
+        # Standardiser le format de réponse d'erreur
+        custom_response_data = {
+            'error': True,
+            'status_code': response.status_code,
+            'message': None,
+            'details': response.data
+        }
+        
+        # Essayer d'extraire un message clair
+        if isinstance(response.data, dict):
+            if 'detail' in response.data:
+                custom_response_data['message'] = response.data['detail']
+            elif 'non_field_errors' in response.data:
+                custom_response_data['message'] = response.data['non_field_errors'][0]
+            else:
+                # Prendre le premier message d'erreur trouvé
+                for field, errors in response.data.items():
+                    if isinstance(errors, list) and errors:
+                        custom_response_data['message'] = f"{field}: {errors[0]}"
+                        break
+        
+        # Message par défaut selon le code de statut
+        if not custom_response_data['message']:
+            if response.status_code == 400:
+                custom_response_data['message'] = "Données invalides"
+            elif response.status_code == 401:
+                custom_response_data['message'] = "Authentification requise"
+            elif response.status_code == 403:
+                custom_response_data['message'] = "Accès refusé"
+            elif response.status_code == 404:
+                custom_response_data['message'] = "Ressource non trouvée"
+            elif response.status_code == 500:
+                custom_response_data['message'] = "Erreur serveur interne"
+            else:
+                custom_response_data['message'] = "Une erreur est survenue"
+        
+        response.data = custom_response_data
+    
+    return response

apps/core/management/commands/create_test_data.py

@@ -0,0 +1,162 @@
+from django.core.management.base import BaseCommand
+from django.contrib.auth import get_user_model
+from apps.users.models import UserProfile, UserCountry, UserUniversity
+from apps.mentors.models import (
+    MentorProfile, MentorBio, MentorSpecialty, MentorAvailability
+)
+from apps.forum.models import Question, QuestionTitle, QuestionContent, QuestionTag
+from faker import Faker
+import random
+
+User = get_user_model()
+fake = Faker(['fr_FR'])
+
+class Command(BaseCommand):
+    help = 'Créer des données de test'
+    
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--users',
+            type=int,
+            default=20,
+            help='Nombre d\'utilisateurs à créer'
+        )
+    
+    def handle(self, *args, **options):
+        num_users = options['users']
+        
+        self.stdout.write(f'Création de {num_users} utilisateurs de test...')
+        
+        countries = ['Bénin', 'Sénégal', 'Côte d\'Ivoire', 'Togo', 'Burkina Faso', 'Mali']
+        universities = [
+            'Université d\'Abomey-Calavi',
+            'Université Cheikh Anta Diop',
+            'Université Félix Houphouët-Boigny',
+            'Université de Lomé'
+        ]
+        
+        # Créer des étudiants
+        students = []
+        for i in range(num_users):
+            email = fake.email()
+            user = User.objects.create_user(
+                email=email,
+                password='password123',
+                role='STUDENT'
+            )
+            
+            profile = UserProfile.objects.create(
+                user=user,
+                name=fake.name()
+            )
+            
+            UserCountry.objects.create(
+                profile=profile,
+                country=random.choice(countries)
+            )
+            
+            UserUniversity.objects.create(
+                profile=profile,
+                university=random.choice(universities)
+            )
+            
+            students.append(user)
+        
+        self.stdout.write(self.style.SUCCESS(f'{num_users} étudiants créés'))
+        
+        # Créer des mentors
+        specialties_list = [
+            'Mathématiques', 'Physique', 'Chimie', 'Informatique',
+            'Économie', 'Gestion', 'Droit', 'Marketing', 'Finance'
+        ]
+        
+        num_mentors = num_users // 4
+        mentors = []
+        
+        for i in range(num_mentors):
+            email = f'mentor{i}@edulab.test'
+            user = User.objects.create_user(
+                email=email,
+                password='password123',
+                role='MENTOR'
+            )
+            
+            profile = UserProfile.objects.create(
+                user=user,
+                name=fake.name()
+            )
+            
+            UserCountry.objects.create(
+                profile=profile,
+                country=random.choice(countries)
+            )
+            
+            mentor_profile = MentorProfile.objects.create(
+                user=user,
+                rating=round(random.uniform(3.5, 5.0), 1),
+                reviews_count=random.randint(5, 50),
+                is_verified=True
+            )
+            
+            MentorBio.objects.create(
+                mentor_profile=mentor_profile,
+                bio=fake.text(max_nb_chars=200)
+            )
+            
+            # Spécialités
+            for specialty in random.sample(specialties_list, k=random.randint(2, 4)):
+                MentorSpecialty.objects.create(
+                    mentor_profile=mentor_profile,
+                    specialty=specialty
+                )
+            
+            # Disponibilités
+            days = ['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY']
+            for day in random.sample(days, k=3):
+                MentorAvailability.objects.create(
+                    mentor_profile=mentor_profile,
+                    day_of_week=day,
+                    start_time='14:00:00',
+                    end_time='17:00:00'
+                )
+            
+            mentors.append(user)
+        
+        self.stdout.write(self.style.SUCCESS(f'{num_mentors} mentors créés'))
+        
+        # Créer des questions
+        num_questions = num_users * 2
+        tags_list = ['aide', 'urgent', 'exercice', 'cours', 'examen', 'projet']
+        
+        for i in range(num_questions):
+            author = random.choice(students)
+            profile = author.profiles.filter(is_current=True).first()
+            
+            question = Question.objects.create(
+                author=author,
+                profile=profile,
+                votes=random.randint(0, 50)
+            )
+            
+            QuestionTitle.objects.create(
+                question=question,
+                title=fake.sentence()
+            )
+            
+            QuestionContent.objects.create(
+                question=question,
+                content=fake.text(max_nb_chars=500)
+            )
+            
+            for tag in random.sample(tags_list, k=random.randint(1, 3)):
+                QuestionTag.objects.create(
+                    question=question,
+                    tag=tag
+                )
+        
+        self.stdout.write(self.style.SUCCESS(f'{num_questions} questions créées'))
+        
+        self.stdout.write(self.style.SUCCESS('Données de test créées avec succès!'))
+        self.stdout.write('\\nComptes de test:')
+        self.stdout.write(f'  Étudiant: student@test.com / password123')
+        self.stdout.write(f'  Mentor: mentor0@edulab.test / password123')

apps/core/management/commands/init_data.py

@@ -0,0 +1,327 @@
+from django.core.management.base import BaseCommand
+from apps.core.models import ImpactStat, LearningTool, Testimonial, SocialLink
+from apps.opportunities.models import Opportunity
+from apps.gamification.models import Badge
+
+class Command(BaseCommand):
+    help = 'Initialize essential database data for the application startup'
+
+    def handle(self, *args, **options):
+        self.stdout.write(self.style.SUCCESS('Starting data initialization...'))
+
+        self.init_social_links()
+        self.init_impact_stats()
+        self.init_learning_tools()
+        self.init_testimonials()
+        self.init_opportunities()
+        self.init_badges()
+
+        self.stdout.write(self.style.SUCCESS('Data initialization completed successfully.'))
+
+    def init_social_links(self):
+        links = [
+            {
+                'platform': 'facebook',
+                'defaults': {
+                    'name': 'Facebook',
+                    'url': 'https://facebook.com/edulabafrica',
+                    'icon': 'Facebook',
+                    'order': 1
+                }
+            },
+            {
+                'platform': 'twitter',
+                'defaults': {
+                    'name': 'Twitter',
+                    'url': 'https://twitter.com/edulabafrica',
+                    'icon': 'Twitter',
+                    'order': 2
+                }
+            },
+            {
+                'platform': 'linkedin',
+                'defaults': {
+                    'name': 'LinkedIn',
+                    'url': 'https://linkedin.com/company/edulabafrica',
+                    'icon': 'Linkedin',
+                    'order': 3
+                }
+            },
+            {
+                'platform': 'instagram',
+                'defaults': {
+                    'name': 'Instagram',
+                    'url': 'https://instagram.com/edulabafrica',
+                    'icon': 'Instagram',
+                    'order': 4
+                }
+            },
+            {
+                'platform': 'youtube',
+                'defaults': {
+                    'name': 'YouTube',
+                    'url': 'https://youtube.com/c/edulabafrica',
+                    'icon': 'Youtube',
+                    'order': 5
+                }
+            }
+        ]
+
+        count = 0
+        for item in links:
+            obj, created = SocialLink.objects.get_or_create(
+                platform=item['platform'],
+                defaults=item['defaults']
+            )
+            if created:
+                count += 1
+        
+        if count > 0:
+            self.stdout.write(self.style.SUCCESS(f'Created {count} new social links.'))
+        else:
+            self.stdout.write('Social links up to date.')
+
+    def init_impact_stats(self):
+        stats = [
+            {
+                'title': 'Étudiants formés',
+                'defaults': {
+                    'value': '5000+',
+                    'icon': 'Users',
+                    'description': 'Étudiants accompagnés à travers l\'Afrique',
+                    'order': 1
+                }
+            },
+            {
+                'title': 'Taux de réussite',
+                'defaults': {
+                    'value': '98%',
+                    'icon': 'CheckCircle',
+                    'description': 'Réussite aux examens nationaux',
+                    'order': 2
+                }
+            },
+            {
+                'title': 'Mentors Experts',
+                'defaults': {
+                    'value': '200+',
+                    'icon': 'Award',
+                    'description': 'Professionnels engagés',
+                    'order': 3
+                }
+            },
+            {
+                'title': 'Outils Pratiques',
+                'defaults': {
+                    'value': '50+',
+                    'icon': 'Wrench',
+                    'description': 'Simulateurs et laboratoires virtuels',
+                    'order': 4
+                }
+            }
+        ]
+
+        count = 0
+        for item in stats:
+            obj, created = ImpactStat.objects.get_or_create(
+                title=item['title'],
+                defaults=item['defaults']
+            )
+            if created:
+                count += 1
+        
+        if count > 0:
+            self.stdout.write(self.style.SUCCESS(f'Created {count} new impact stats.'))
+        else:
+            self.stdout.write('Impact stats up to date.')
+
+    def init_learning_tools(self):
+        tools = [
+            {
+                'tool_id': 'code',
+                'defaults': {
+                    'title': 'Code Sandbox',
+                    'description': 'Environnement de développement intégré pour apprendre HTML, CSS et JS en temps réel.',
+                    'icon': 'Code',
+                    'category': 'Informatique',
+                    'level': 'Tous niveaux',
+                    'link': '/tools/code-sandbox',
+                    'color': 'bg-blue-100',
+                    'text_color': 'text-blue-600',
+                    'bg_gradient': 'from-blue-500 to-cyan-400',
+                    'order': 1
+                }
+            },
+            {
+                'tool_id': 'geo',
+                'defaults': {
+                    'title': 'Atlas Interactif',
+                    'description': 'Exploration géographique 3D avec données économiques et climatiques en temps réel.',
+                    'icon': 'Globe',
+                    'category': 'Sciences',
+                    'level': 'Collège',
+                    'link': '/tools/atlas',
+                    'color': 'bg-green-100',
+                    'text_color': 'text-green-600',
+                    'bg_gradient': 'from-green-500 to-emerald-400',
+                    'order': 2
+                }
+            },
+            {
+                'tool_id': 'calc',
+                'defaults': {
+                    'title': 'Calculatrice Scientifique',
+                    'description': 'Outil avancé pour les mathématiques, la physique et l\'ingénierie avec graphiques.',
+                    'icon': 'Calculator',
+                    'category': 'Sciences',
+                    'level': 'Lycée',
+                    'link': '/tools/calculator',
+                    'color': 'bg-purple-100',
+                    'text_color': 'text-purple-600',
+                    'bg_gradient': 'from-purple-500 to-indigo-400',
+                    'order': 3
+                }
+            },
+            {
+                'tool_id': 'write',
+                'defaults': {
+                    'title': 'Atelier d\'Écriture',
+                    'description': 'Assistant intelligent pour améliorer vos rédactions et votre style littéraire.',
+                    'icon': 'PenTool',
+                    'category': 'Langues',
+                    'level': 'Primaire',
+                    'link': '/tools/writing',
+                    'color': 'bg-orange-100',
+                    'text_color': 'text-orange-600',
+                    'bg_gradient': 'from-orange-500 to-amber-400',
+                    'order': 4
+                }
+            },
+            {
+                'tool_id': 'art',
+                'defaults': {
+                    'title': 'Atelier Créatif',
+                    'description': 'Espace de dessin et de coloriage numérique pour développer la créativité.',
+                    'icon': 'Palette',
+                    'category': 'Créativité',
+                    'level': 'Primaire',
+                    'link': '/tools/coloring',
+                    'color': 'bg-pink-100',
+                    'text_color': 'text-pink-600',
+                    'bg_gradient': 'from-pink-500 to-rose-400',
+                    'order': 5
+                }
+            }
+        ]
+
+        count = 0
+        for item in tools:
+            obj, created = LearningTool.objects.get_or_create(
+                tool_id=item['tool_id'],
+                defaults=item['defaults']
+            )
+            if created:
+                count += 1
+        
+        if count > 0:
+            self.stdout.write(self.style.SUCCESS(f'Created {count} new learning tools.'))
+        else:
+            self.stdout.write('Learning tools up to date.')
+
+    def init_testimonials(self):
+        testimonials = [
+            {
+                'name': 'Awa Ndiaye',
+                'defaults': {
+                    'role': 'Étudiante en Médecine',
+                    'country': 'Sénégal',
+                    'text': 'EduLab m\'a permis de visualiser l\'anatomie en 3D, ce qui était impossible avec mes livres seulement. Une révolution !',
+                    'order': 1
+                }
+            },
+            {
+                'name': 'Kofi Mensah',
+                'defaults': {
+                    'role': 'Lycéen',
+                    'country': 'Ghana',
+                    'text': 'Grâce au tuteur IA, j\'ai enfin compris les intégrales. C\'est comme avoir un prof particulier disponible 24h/24.',
+                    'order': 2
+                }
+            },
+            {
+                'name': 'Sarah Benali',
+                'defaults': {
+                    'role': 'Développeuse Web',
+                    'country': 'Maroc',
+                    'text': 'Le Code Sandbox est incroyable pour tester des idées rapidement sans rien installer. J\'ai appris React grâce à ça.',
+                    'order': 3
+                }
+            }
+        ]
+
+        count = 0
+        for item in testimonials:
+            obj, created = Testimonial.objects.get_or_create(
+                name=item['name'],
+                defaults=item['defaults']
+            )
+            if created:
+                count += 1
+        
+        if count > 0:
+            self.stdout.write(self.style.SUCCESS(f'Created {count} new testimonials.'))
+        else:
+            self.stdout.write('Testimonials up to date.')
+
+    def init_opportunities(self):
+        # For opportunities, we'll just check if the table is empty to avoid duplicates of the sample
+        # as they don't have unique keys like tool_id
+        if Opportunity.objects.exists():
+            self.stdout.write('Opportunities already exist. Skipping.')
+            return
+
+        from django.utils import timezone
+        from datetime import timedelta
+
+        # Create one sample opportunity
+        opp = Opportunity.objects.create(
+            type='SCHOLARSHIP',
+            deadline=timezone.now().date() + timedelta(days=30),
+            external_link='https://au.int/en/scholarship',
+            is_featured=True
+        )
+        
+        # Add related data
+        opp.titles.create(title="Bourse d'Excellence Africaine 2025")
+        opp.providers.create(provider="Union Africaine")
+        opp.descriptions.create(description="Une opportunité unique pour les étudiants africains brillants de poursuivre leurs études supérieures avec une couverture financière complète.")
+        opp.locations.create(location="Addis Ababa, Éthiopie")
+        
+        self.stdout.write(self.style.SUCCESS('Created 1 sample opportunity.'))
+
+    def init_badges(self):
+        badges = [
+            {'code': 'b1', 'name': 'Premier Pas', 'description': 'Première question posée', 'icon': '👣', 'color': 'bg-blue-100 text-blue-600'},
+            {'code': 'b2', 'name': 'Savant', 'description': '10 meilleures réponses', 'icon': '🦉', 'color': 'bg-yellow-100 text-yellow-600'},
+            {'code': 'b3', 'name': 'Mentor Star', 'description': 'Note moyenne de 5.0', 'icon': '⭐', 'color': 'bg-purple-100 text-purple-600'},
+            {'code': 'b4', 'name': 'Globe Trotter', 'description': 'Aidé des étudiants de 5 pays', 'icon': '🌍', 'color': 'bg-green-100 text-green-600'},
+            {'code': 'b5', 'name': 'Curieux', 'description': 'Avoir visité 50 questions', 'icon': '🔍', 'color': 'bg-indigo-100 text-indigo-600'},
+            {'code': 'b6', 'name': 'Tech Guru', 'description': 'Répondre à 20 questions Tech', 'icon': '💻', 'color': 'bg-pink-100 text-pink-600'},
+            {'code': 'b7', 'name': 'Philanthrope', 'description': 'Donner 5 sessions de mentorat', 'icon': '🤝', 'color': 'bg-orange-100 text-orange-600'},
+            {'code': 'b8', 'name': 'Légende', 'description': 'Atteindre 5000 points', 'icon': '👑', 'color': 'bg-red-100 text-red-600'},
+        ]
+
+        count = 0
+        for b in badges:
+            badge, created = Badge.objects.get_or_create(code=b['code'])
+            if created:
+                badge.names.create(name=b['name'])
+                badge.descriptions.create(description=b['description'])
+                badge.icons.create(icon=b['icon'])
+                badge.colors.create(color=b['color'])
+                count += 1
+        
+        if count > 0:
+            self.stdout.write(self.style.SUCCESS(f'Created {count} new badges.'))
+        else:
+            self.stdout.write('Badges up to date.')

apps/core/management/commands/init_db.py

@@ -0,0 +1,14 @@
+from django.core.management.base import BaseCommand
+from apps.gamification.services import BadgeService
+
+class Command(BaseCommand):
+    help = 'Initialiser la base de données avec les données par défaut'
+    
+    def handle(self, *args, **options):
+        self.stdout.write('Initialisation de la base de données...')
+        
+        # Créer les badges par défaut
+        self.stdout.write('Création des badges par défaut...')
+        BadgeService.initialize_default_badges()
+        
+        self.stdout.write(self.style.SUCCESS('Base de données initialisée avec succès!'))

apps/core/middleware.py

@@ -0,0 +1,38 @@
+# ============================================
+# apps/core/middleware.py (Optionnel)
+# ============================================
+import logging
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
+
+class ActivityTrackingMiddleware:
+    """Middleware pour tracker l'activité utilisateur"""
+    
+    def __init__(self, get_response):
+        self.get_response = get_response
+    
+    def __call__(self, request):
+        response = self.get_response(request)
+        
+        # Logger l'activité si utilisateur authentifié
+        if request.user.is_authenticated and request.method in ['POST', 'PUT', 'PATCH', 'DELETE']:
+            from apps.analytics.models import UserActivity
+            
+            try:
+                UserActivity.objects.create(
+                    user=request.user,
+                    activity_type=f"{request.method}_{request.path}",
+                    activity_data={
+                        'path': request.path,
+                        'method': request.method,
+                        'status_code': response.status_code
+                    },
+                    ip_address=request.META.get('REMOTE_ADDR'),
+                    user_agent=request.META.get('HTTP_USER_AGENT', '')[:500]
+                )
+            except Exception as e:
+                logger.error(f"Error tracking activity: {e}")
+        
+        return response
+