Initial deploy to Hugging Face

Dockerfile

@@ -0,0 +1,52 @@
+# --- Étape 1 : Build du Frontend ---
+FROM node:20-slim AS frontend-builder
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+# On s'assure que l'API pointe vers le même domaine en prod
+ENV VITE_API_URL=/api
+RUN npm run build
+
+# --- Étape 2 : Image finale ---
+FROM python:3.12-slim
+
+# Installation des dépendances système
+RUN apt-get update && apt-get install -y \
+    nginx \
+    redis-server \
+    gcc \
+    libpq-dev \
+    curl \
+    supervisor \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Installation des dépendances Python
+COPY backend/requirements.txt ./backend/
+RUN pip install --upgrade pip && pip install -r backend/requirements.txt
+RUN pip install gunicorn daphne
+
+# Copie du code Backend
+COPY backend/ ./backend/
+
+# Copie du build Frontend depuis l'étape 1
+COPY --from=frontend-builder /app/frontend/dist ./frontend_dist
+
+# Copie des configurations
+COPY nginx.conf /etc/nginx/sites-available/default
+COPY supervisord.conf ./supervisord.conf
+COPY start.sh ./start.sh
+RUN chmod +x ./start.sh
+
+# Configuration Django pour Hugging Face
+ENV PYTHONUNBUFFERED=1
+ENV DJANGO_SETTINGS_MODULE=educonnect.settings
+# On force SQLite pour Hugging Face si aucune DB n'est fournie
+ENV DB_HOST="" 
+
+# Hugging Face écoute sur le port 7860
+EXPOSE 7860
+
+CMD ["./start.sh"]

backend/Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.11-slim
+FROM python:3.12-slim
 
 ENV PYTHONUNBUFFERED=1
 ENV PYTHONDONTWRITEBYTECODE=1
@@ -6,9 +6,10 @@ ENV PYTHONDONTWRITEBYTECODE=1
 WORKDIR /app
 
 # Installer les dépendances système
-RUN apt-get update && apt-get install -y \\
-    postgresql-client \\
-    gcc \\
+RUN apt-get update && apt-get install -y \
+    postgresql-client \
+    gcc \
+    libpq-dev \
     && rm -rf /var/lib/apt/lists/*
 
 # Copier requirements
@@ -27,4 +28,4 @@ RUN python manage.py collectstatic --noinput
 
 EXPOSE 8000
 
-CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "educonnect_api.wsgi:application"]
+CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "educonnect.wsgi:application"]

backend/apps/ai_tools/views.py

@@ -162,7 +162,7 @@ IMPORTANT - Formatage des formules :
 """
         
         response = client.models.generate_content(
-            model="gemini-2.5-flash", contents=prompt
+            model="gemini-flash-latest", contents=prompt
         )
         
         # Estimation des tokens (approximatif)

backend/apps/bookings/apps.py

@@ -4,3 +4,6 @@ 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

backend/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}")

backend/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

backend/apps/bookings/views.py

@@ -89,7 +89,6 @@ class BookingViewSet(HashIdMixin, viewsets.ModelViewSet):
         
         bookings = Booking.objects.filter(
             mentor=request.user,
-            status='PENDING',
             is_active=True
         ).order_by('date', 'time')
         

backend/apps/mentors/admin.py

@@ -43,11 +43,30 @@ from .models import MentorApplication
 
 @admin.register(MentorApplication)
 class MentorApplicationAdmin(admin.ModelAdmin):
-    list_display = ('user', 'status_badge', 'university', 'created_at', 'cv_link')
-    list_filter = ('status', 'created_at')
+    list_display = ('user', 'status_badge', 'ai_status_badge', 'ai_validated', 'ai_score', 'university', 'created_at', 'cv_link', 'id_card_link')
+    list_filter = ('status', 'ai_status', 'ai_validated', 'created_at')
     search_fields = ('user__email', 'user__first_name', 'user__last_name', 'university')
-    readonly_fields = ('created_at', 'updated_at')
+    readonly_fields = ('created_at', 'updated_at', 'ai_status', 'ai_recommendation', 'ai_score', 'ai_validated')
     
+    fieldsets = (
+        ('Informations Utilisateur', {
+            'fields': ('user', 'university', 'bio', 'specialties', 'availability')
+        }),
+        ('Documents', {
+            'fields': ('cv_file', 'id_card_photo')
+        }),
+        ('Réseaux Sociaux', {
+            'fields': ('linkedin', 'twitter', 'website')
+        }),
+        ('Analyse IA (Automatique)', {
+            'fields': ('ai_status', 'ai_validated', 'ai_score', 'ai_recommendation'),
+            'description': 'Ces champs sont remplis automatiquement par l\'IA Gemini après la soumission.'
+        }),
+        ('Décision Admin', {
+            'fields': ('status', 'created_at', 'updated_at')
+        }),
+    )
+
     def status_badge(self, obj):
         colors = {
             'PENDING': 'orange',
@@ -61,13 +80,33 @@ class MentorApplicationAdmin(admin.ModelAdmin):
         )
     status_badge.short_description = 'Statut'
 
+    def ai_status_badge(self, obj):
+        colors = {
+            'PENDING': '#6b7280',    # gray-500
+            'PROCESSING': '#3b82f6', # blue-500
+            'COMPLETED': '#10b981',  # emerald-500
+            'FAILED': '#ef4444',     # red-500
+        }
+        return format_html(
+            '<span style="color: white; background-color: {}; padding: 2px 8px; border-radius: 8px; font-size: 11px; font-weight: 500;">{}</span>',
+            colors.get(obj.ai_status, 'gray'),
+            obj.get_ai_status_display()
+        )
+    ai_status_badge.short_description = 'Analyse IA'
+
     def cv_link(self, obj):
         if obj.cv_file:
-            return format_html('<a href="{}" target="_blank" style="background-color: #3b82f6; color: white; padding: 3px 8px; border-radius: 4px; text-decoration: none;">Voir le CV</a>', obj.cv_file.url)
+            return format_html('<a href="{}" target="_blank" style="background-color: #3b82f6; color: white; padding: 3px 8px; border-radius: 4px; text-decoration: none; font-size: 11px;">Voir CV</a>', obj.cv_file.url)
         return "-"
     cv_link.short_description = 'CV'
 
-    actions = ['approve_applications', 'reject_applications']
+    def id_card_link(self, obj):
+        if obj.id_card_photo:
+            return format_html('<a href="{}" target="_blank" style="background-color: #8b5cf6; color: white; padding: 3px 8px; border-radius: 4px; text-decoration: none; font-size: 11px;">Voir ID</a>', obj.id_card_photo.url)
+        return "-"
+    id_card_link.short_description = 'Photo ID'
+
+    actions = ['approve_applications', 'reject_applications', 'retry_ai_review']
 
     @admin.action(description='Approuver les candidatures sélectionnées')
     def approve_applications(self, request, queryset):
@@ -79,3 +118,15 @@ class MentorApplicationAdmin(admin.ModelAdmin):
         updated = queryset.update(status='REJECTED')
         self.message_user(request, f"{updated} candidature(s) rejetée(s).")
 
+    @admin.action(description='Relancer l\'analyse IA')
+    def retry_ai_review(self, request, queryset):
+        from .services import MentorAIRewiewService
+        import threading
+        for instance in queryset:
+            thread = threading.Thread(
+                target=MentorAIRewiewService.review_application,
+                args=(instance.id,)
+            )
+            thread.start()
+        self.message_user(request, f"Analyse IA relancée pour {queryset.count()} candidature(s).")
+

backend/apps/mentors/apps.py

@@ -4,3 +4,6 @@ from django.apps import AppConfig
 class MentorsConfig(AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'
     name = 'apps.mentors'
+
+    def ready(self):
+        import apps.mentors.signals

backend/apps/mentors/migrations/0005_mentorapplication_ai_recommendation_and_more.py

@@ -0,0 +1,38 @@
+# Generated by Django 4.2.7 on 2025-12-22 12:34
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mentors', '0004_mentorspecificdateavailability'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='mentorapplication',
+            name='ai_recommendation',
+            field=models.TextField(blank=True, verbose_name='Recommandation IA'),
+        ),
+        migrations.AddField(
+            model_name='mentorapplication',
+            name='ai_score',
+            field=models.IntegerField(blank=True, null=True, verbose_name='Score de confiance IA'),
+        ),
+        migrations.AddField(
+            model_name='mentorapplication',
+            name='ai_status',
+            field=models.CharField(choices=[('PENDING', 'En attente'), ('PROCESSING', "En cours d'analyse"), ('COMPLETED', 'Analyse terminée'), ('FAILED', "Échec de l'analyse")], default='PENDING', max_length=20),
+        ),
+        migrations.AddField(
+            model_name='mentorapplication',
+            name='ai_validated',
+            field=models.BooleanField(default=False, verbose_name="Validé par l'IA"),
+        ),
+        migrations.AddField(
+            model_name='mentorapplication',
+            name='id_card_photo',
+            field=models.ImageField(blank=True, null=True, upload_to='mentors/ids/'),
+        ),
+    ]

backend/apps/mentors/models.py

@@ -136,6 +136,21 @@ class MentorApplication(TimestampMixin, SoftDeleteMixin):
     twitter = models.URLField(max_length=500, blank=True)
     website = models.URLField(max_length=500, blank=True)
     
+    # Nouveau champ : Photo d'Identité
+    id_card_photo = models.ImageField(upload_to='mentors/ids/', null=True, blank=True)
+    
+    # Champs pour l'analyse IA
+    AI_STATUS_CHOICES = [
+        ('PENDING', 'En attente'),
+        ('PROCESSING', 'En cours d\'analyse'),
+        ('COMPLETED', 'Analyse terminée'),
+        ('FAILED', 'Échec de l\'analyse'),
+    ]
+    ai_status = models.CharField(max_length=20, choices=AI_STATUS_CHOICES, default='PENDING')
+    ai_recommendation = models.TextField(blank=True, verbose_name="Recommandation IA")
+    ai_score = models.IntegerField(null=True, blank=True, verbose_name="Score de confiance IA")
+    ai_validated = models.BooleanField(default=False, verbose_name="Validé par l'IA")
+    
     class Meta:
         db_table = 'mentor_applications'
         ordering = ['-created_at']

backend/apps/mentors/serializers.py

@@ -287,11 +287,15 @@ class MentorApplicationSerializer(serializers.ModelSerializer):
     class Meta:
         model = MentorApplication
         fields = [
-            'id', 'user', 'cv_file', 'status', 'bio', 'university',
+            'id', 'user', 'cv_file', 'id_card_photo', 'status', 'bio', 'university',
             'specialties', 'availability', 'linkedin', 'twitter', 'website',
+            'ai_status', 'ai_recommendation', 'ai_score', 'ai_validated',
             'created_at'
         ]
-        read_only_fields = ['id', 'user', 'status', 'created_at']
+        read_only_fields = [
+            'id', 'user', 'status', 'ai_status', 'ai_recommendation', 
+            'ai_score', 'ai_validated', 'created_at'
+        ]
         
     def validate_cv_file(self, value):
         if not value.name.endswith('.pdf'):

backend/apps/mentors/services.py

@@ -0,0 +1,122 @@
+# ============================================
+# apps/mentors/services.py - Services Mentors
+# ============================================
+import os
+import logging
+import json
+import re
+from pypdf import PdfReader
+from google import genai
+from django.conf import settings
+from .models import MentorApplication
+
+logger = logging.getLogger(__name__)
+
+class MentorAIRewiewService:
+    @staticmethod
+    def extract_text_from_pdf(pdf_path):
+        """Extrait le texte d'un fichier PDF"""
+        try:
+            if not os.path.exists(pdf_path):
+                logger.error(f"Fichier PDF non trouvé: {pdf_path}")
+                return ""
+                
+            reader = PdfReader(pdf_path)
+            text = ""
+            for page in reader.pages:
+                text += page.extract_text() + "\n"
+            return text
+        except Exception as e:
+            logger.error(f"Erreur lors de l'extraction du PDF: {str(e)}")
+            return ""
+
+    @staticmethod
+    def review_application(application_id):
+        """Analyse une candidature avec l'IA"""
+        try:
+            application = MentorApplication.objects.get(id=application_id)
+            application.ai_status = 'PROCESSING'
+            application.save(update_fields=['ai_status'])
+
+            # Extraction du texte du CV
+            cv_text = ""
+            if application.cv_file:
+                cv_text = MentorAIRewiewService.extract_text_from_pdf(application.cv_file.path)
+
+            # Récupérer le nom de l'utilisateur
+            user_name = "Inconnu"
+            profile = application.user.profiles.filter(is_current=True).first()
+            if profile:
+                user_name = profile.name
+
+            # Préparation du prompt
+            prompt = f"""
+            Tu es un expert en recrutement académique pour EduLab Africa. 
+            Ta mission est d'analyser la candidature d'un utilisateur qui souhaite devenir Mentor sur notre plateforme.
+            
+            Voici les informations de la candidature :
+            - Nom : {user_name}
+            - Université : {application.university}
+            - Spécialités : {', '.join(application.specialties)}
+            - Biographie : {application.bio}
+            - LinkedIn : {application.linkedin}
+            
+            Texte extrait du CV (PDF) :
+            ---
+            {cv_text[:4000]}
+            ---
+            
+            Analyse cette candidature selon les critères suivants :
+            1. Expertise technique dans les spécialités mentionnées.
+            2. Expérience académique ou professionnelle pertinente.
+            3. Capacité à transmettre des connaissances (pédagogie).
+            4. Cohérence globale du profil.
+            
+            Réponds UNIQUEMENT au format JSON suivant (sans texte avant ou après) :
+            {{
+                "score": (un entier entre 0 et 100),
+                "recommendation": "Un résumé détaillé de ton analyse en français et pourquoi tu valides ou non le profil.",
+                "validated": (true ou false)
+            }}
+            """
+
+            # Appel à Gemini via le nouveau SDK (comme dans Tutor AI)
+            if not settings.GEMINI_API_KEY:
+                raise ValueError("GEMINI_API_KEY non configurée dans les settings.")
+                
+            client = genai.Client(api_key=settings.GEMINI_API_KEY)
+            
+            response = client.models.generate_content(
+                model='gemini-flash-latest', 
+                contents=prompt
+            )
+            
+            # Parser la réponse
+            text_response = response.text
+            json_match = re.search(r'\{.*\}', text_response, re.DOTALL)
+            
+            if json_match:
+                result = json.loads(json_match.group())
+                
+                application.ai_score = result.get('score', 0)
+                application.ai_recommendation = result.get('recommendation', '')
+                application.ai_validated = result.get('validated', False)
+                application.ai_status = 'COMPLETED'
+            else:
+                application.ai_status = 'FAILED'
+                application.ai_recommendation = "L'IA n'a pas renvoyé un format JSON valide."
+            
+            application.save()
+            return True
+
+        except Exception as e:
+            logger.error(f"Erreur lors de l'analyse IA: {str(e)}")
+            try:
+                # Re-fetch application to avoid stale data if needed
+                app = MentorApplication.objects.get(id=application_id)
+                app.ai_status = 'FAILED'
+                app.ai_recommendation = f"Erreur technique: {str(e)}"
+                app.save()
+            except:
+                pass
+            return False

backend/apps/mentors/signals.py

@@ -0,0 +1,17 @@
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from .models import MentorApplication
+from .services import MentorAIRewiewService
+import threading
+
+@receiver(post_save, sender=MentorApplication)
+def trigger_ai_review(sender, instance, created, **kwargs):
+    """Déclenche l'analyse IA dès qu'une candidature est soumise"""
+    if created:
+        # On lance l'analyse dans un thread séparé pour ne pas bloquer la réponse HTTP
+        # En production, on utiliserait Celery
+        thread = threading.Thread(
+            target=MentorAIRewiewService.review_application,
+            args=(instance.id,)
+        )
+        thread.start()

backend/apps/messaging/consumers.py

@@ -2,6 +2,7 @@
 # apps/messaging/consumers.py - WebSocket Consumer
 # ============================================
 import json
+import datetime
 from channels.generic.websocket import AsyncWebsocketConsumer
 from channels.db import database_sync_to_async
 from apps.messaging.models import Message, MessageContent, Conversation
@@ -26,6 +27,9 @@ class ChatConsumer(AsyncWebsocketConsumer):
             await self.close()
             return
         
+        # Stocker l'user_id pour filtrage ultérieur
+        self.user_id = user.id
+        
         # Rejoindre le groupe
         await self.channel_layer.group_add(
             self.room_group_name,
@@ -36,10 +40,11 @@ class ChatConsumer(AsyncWebsocketConsumer):
     
     async def disconnect(self, close_code):
         # Quitter le groupe
-        await self.channel_layer.group_discard(
-            self.room_group_name,
-            self.channel_name
-        )
+        if hasattr(self, 'room_group_name'):
+            await self.channel_layer.group_discard(
+                self.room_group_name,
+                self.channel_name
+            )
     
     async def receive(self, text_data):
         """Recevoir un message du WebSocket"""
@@ -47,31 +52,71 @@ class ChatConsumer(AsyncWebsocketConsumer):
         message_content = data.get('message')
         user = self.scope['user']
         
-        # Sauvegarder en base de données
-        message = await self.save_message(user, self.conversation_id, message_content)
+        # Sauvegarder en base de données avec vérification du booking
+        message, is_visible, other_user_id = await self.save_message_with_visibility(
+            user, self.conversation_id, message_content
+        )
+        
+        # Préparer les données du message
+        msg_data = {
+            'id': message.id,
+            'content': message_content,
+            'sender': {
+                'id': user.id,
+                'email': user.email
+            },
+            'timestamp': message.created_at.isoformat(),
+            'is_visible_to_recipient': is_visible
+        }
         
-        # Envoyer au groupe
+        # Envoyer au groupe avec les infos de visibilité
         await self.channel_layer.group_send(
             self.room_group_name,
             {
                 'type': 'chat_message',
-                'message': {
-                    'id': message.id,
-                    'content': message_content,
-                    'sender': {
-                        'id': user.id,
-                        'email': user.email
-                    },
-                    'timestamp': message.created_at.isoformat()
-                }
+                'message': msg_data,
+                'sender_id': user.id,
+                'is_visible': is_visible
             }
         )
+        
+        # Si le message n'est pas visible, notifier l'expéditeur directement
+        if not is_visible:
+            await self.send(text_data=json.dumps({
+                'type': 'message_queued',
+                'message': "Votre message sera délivré au destinataire lors de votre prochain rendez-vous.",
+                'message_id': message.id
+            }))
     
     async def chat_message(self, event):
-        """Envoyer le message au WebSocket"""
+        """Envoyer le message au WebSocket - avec filtrage"""
+        message = event['message']
+        sender_id = event.get('sender_id')
+        is_visible = event.get('is_visible', True)
+        
+        # Si je suis l'expéditeur, je vois toujours mon message
+        if sender_id == self.user_id:
+            await self.send(text_data=json.dumps({
+                'message': message
+            }))
+        # Si le message est visible pour le destinataire, l'envoyer
+        elif is_visible:
+            await self.send(text_data=json.dumps({
+                'message': message
+            }))
+        # Sinon, ne pas envoyer au destinataire (message en attente)
+    
+    async def messages_unlocked(self, event):
+        """
+        Notifie le client que des messages ont été débloqués.
+        Le frontend doit recharger la conversation pour voir les nouveaux messages.
+        """
+        count = event.get('count', 0)
         await self.send(text_data=json.dumps({
-            'message': event['message']
+            'type': 'messages_unlocked',
+            'count': count
         }))
+
     
     @database_sync_to_async
     def is_participant(self, user, conversation_id):
@@ -86,15 +131,45 @@ class ChatConsumer(AsyncWebsocketConsumer):
             return False
     
     @database_sync_to_async
-    def save_message(self, user, conversation_id, content):
-        """Sauvegarder le message en base de données"""
+    def save_message_with_visibility(self, user, conversation_id, content):
+        """Sauvegarder le message avec vérification du booking actif"""
         from django.utils import timezone
+        from apps.bookings.models import Booking
+        from django.db.models import Q
         
         conversation = Conversation.objects.get(id=conversation_id)
         
+        # Trouver l'autre participant
+        other_participant = conversation.participants.exclude(user=user).filter(is_active=True).first()
+        other_user = other_participant.user if other_participant else None
+        other_user_id = other_user.id if other_user else None
+        
+        # Vérifier s'il y a un booking actif
+        is_visible = False
+        if other_user:
+            now = timezone.now()
+            
+            # Chercher un booking CONFIRMED en cours
+            active_booking = Booking.objects.filter(
+                Q(student=user, mentor=other_user) | Q(student=other_user, mentor=user),
+                status='CONFIRMED',
+                date=now.date(),
+                time__lte=now.time()
+            ).first()
+            
+            if active_booking:
+                # Vérifier si on est encore dans le créneau (2h max)
+                booking_start = datetime.datetime.combine(now.date(), active_booking.time)
+                booking_start = timezone.make_aware(booking_start)
+                
+                if now <= booking_start + datetime.timedelta(hours=2):
+                    is_visible = True
+        
+        # Créer le message avec la visibilité appropriée
         message = Message.objects.create(
             conversation=conversation,
-            sender=user
+            sender=user,
+            is_visible_to_recipient=is_visible
         )
         
         MessageContent.objects.create(
@@ -106,4 +181,4 @@ class ChatConsumer(AsyncWebsocketConsumer):
         conversation.last_message_at = timezone.now()
         conversation.save()
         
-        return message
+        return message, is_visible, other_user_id

backend/apps/messaging/serializers.py

@@ -50,7 +50,30 @@ class ConversationSerializer(serializers.ModelSerializer):
         return UserSerializer([p.user for p in parts], many=True).data
     
     def get_last_message(self, obj):
-        last_msg = obj.messages.filter(is_active=True).last()
+        """
+        Retourne le dernier message VISIBLE pour l'utilisateur actuel.
+        - Si l'utilisateur est l'expéditeur, il voit son message
+        - Sinon, le message doit avoir is_visible_to_recipient=True
+        """
+        request = self.context.get('request')
+        if not request or not request.user.is_authenticated:
+            # Sans contexte, on affiche le dernier message visible
+            last_msg = obj.messages.filter(
+                is_active=True,
+                is_visible_to_recipient=True
+            ).last()
+            return MessageSerializer(last_msg).data if last_msg else None
+        
+        from django.db.models import Q
+        
+        # Messages que l'utilisateur peut voir:
+        # 1. Messages qu'il a envoyés (sender=me)
+        # 2. Messages visibles (is_visible_to_recipient=True)
+        visible_messages = obj.messages.filter(is_active=True).filter(
+            Q(sender=request.user) | Q(is_visible_to_recipient=True)
+        )
+        
+        last_msg = visible_messages.order_by('-created_at').first()
         return MessageSerializer(last_msg).data if last_msg else None
     
     def get_unread_count(self, obj):
@@ -61,9 +84,21 @@ class ConversationSerializer(serializers.ModelSerializer):
                 is_active=True
             ).first()
             if participant:
-                return participant.get_unread_count()
+                # Compter uniquement les messages non lus ET visibles
+                from django.db.models import Q
+                if not participant.last_read_at:
+                    return obj.messages.filter(
+                        is_active=True,
+                        is_visible_to_recipient=True
+                    ).exclude(sender=request.user).count()
+                return obj.messages.filter(
+                    is_active=True,
+                    is_visible_to_recipient=True,
+                    created_at__gt=participant.last_read_at
+                ).exclude(sender=request.user).count()
         return 0
 
+
 class MessageCreateSerializer(serializers.Serializer):
     content = serializers.CharField(required=False, allow_blank=True)
     attachments = serializers.ListField(

backend/apps/messaging/tasks.py

@@ -0,0 +1,192 @@
+# ============================================
+# apps/messaging/tasks.py - Tâches Celery pour la messagerie
+# ============================================
+import datetime
+from celery import shared_task
+from django.utils import timezone
+from django.db.models import Q
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@shared_task(name='messaging.unlock_messages_for_booking')
+def unlock_messages_for_booking(booking_id):
+    """
+    Débloque tous les messages en attente entre deux utilisateurs
+    quand leur rendez-vous commence.
+    
+    Cette tâche est planifiée pour s'exécuter à l'heure de début du booking.
+    """
+    from apps.bookings.models import Booking
+    from apps.messaging.models import Conversation, Message
+    
+    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.")
+            return
+        
+        student = booking.student
+        mentor = booking.mentor
+        
+        # Trouver la conversation entre ces deux users
+        conversation = Conversation.objects.filter(
+            participants__user=student,
+            participants__is_active=True,
+            is_active=True
+        ).filter(
+            participants__user=mentor,
+            participants__is_active=True
+        ).first()
+        
+        if not conversation:
+            logger.info(f"Pas de conversation entre {student.id} et {mentor.id}")
+            return
+        
+        # Débloquer tous les messages en attente dans cette conversation
+        updated_count = Message.objects.filter(
+            conversation=conversation,
+            is_visible_to_recipient=False,
+            is_active=True
+        ).update(is_visible_to_recipient=True)
+        
+        logger.info(f"Débloqué {updated_count} messages pour booking {booking_id}")
+        
+        # Notifier les utilisateurs via WebSocket que des messages sont disponibles
+        try:
+            from channels.layers import get_channel_layer
+            from asgiref.sync import async_to_sync
+            
+            channel_layer = get_channel_layer()
+            
+            async_to_sync(channel_layer.group_send)(
+                f'chat_{conversation.id}',
+                {
+                    'type': 'messages_unlocked',
+                    'count': updated_count
+                }
+            )
+        except Exception as e:
+            logger.warning(f"Impossible de notifier via WebSocket: {e}")
+        
+        return updated_count
+        
+    except Booking.DoesNotExist:
+        logger.error(f"Booking {booking_id} introuvable")
+        return 0
+    except Exception as e:
+        logger.error(f"Erreur lors du déblocage des messages: {e}")
+        raise
+
+
+@shared_task(name='messaging.schedule_unlock_for_upcoming_bookings')
+def schedule_unlock_for_upcoming_bookings():
+    """
+    Tâche périodique qui vérifie les bookings confirmés à venir
+    et planifie le déblocage des messages pour chacun.
+    
+    À exécuter toutes les 5-10 minutes via Celery Beat.
+    """
+    from apps.bookings.models import Booking
+    from django_celery_beat.models import PeriodicTask, ClockedSchedule
+    import json
+    
+    now = timezone.now()
+    
+    # Trouver les bookings confirmés qui commencent dans les 15 prochaines minutes
+    # et pour lesquels on n'a pas encore planifié de tâche
+    upcoming_bookings = Booking.objects.filter(
+        status='CONFIRMED',
+        date=now.date(),
+        time__gte=now.time(),
+        is_active=True
+    )
+    
+    for booking in upcoming_bookings:
+        # Calculer l'heure de début
+        booking_start = datetime.datetime.combine(booking.date, booking.time)
+        booking_start = timezone.make_aware(booking_start)
+        
+        # Si le booking commence dans moins de 15 minutes
+        if booking_start <= now + datetime.timedelta(minutes=15):
+            task_name = f'unlock_msgs_booking_{booking.id}'
+            
+            # Vérifier si la tâche existe déjà
+            if not PeriodicTask.objects.filter(name=task_name).exists():
+                try:
+                    # Créer un schedule pour l'heure exacte
+                    clocked, _ = ClockedSchedule.objects.get_or_create(
+                        clocked_time=booking_start
+                    )
+                    
+                    PeriodicTask.objects.create(
+                        clocked=clocked,
+                        name=task_name,
+                        task='messaging.unlock_messages_for_booking',
+                        args=json.dumps([booking.id]),
+                        one_off=True,  # Ne s'exécute qu'une fois
+                        enabled=True
+                    )
+                    
+                    logger.info(f"Tâche planifiée pour booking {booking.id} à {booking_start}")
+                except Exception as e:
+                    logger.error(f"Erreur lors de la planification pour booking {booking.id}: {e}")
+    
+    return f"Vérifié {upcoming_bookings.count()} bookings"
+
+
+@shared_task(name='messaging.check_pending_messages')
+def check_pending_messages():
+    """
+    Tâche périodique de sécurité qui vérifie s'il y a des messages
+    qui auraient dû être débloqués mais ne l'ont pas été.
+    
+    Utile en cas de redémarrage du serveur ou de tâche ratée.
+    """
+    from apps.messaging.models import Message
+    from apps.bookings.models import Booking
+    
+    now = timezone.now()
+    
+    # Trouver les messages en attente dont l'expéditeur et le destinataire
+    # ont eu un booking qui a déjà commencé
+    pending_messages = Message.objects.filter(
+        is_visible_to_recipient=False,
+        is_active=True
+    ).select_related('conversation', 'sender')
+    
+    unlocked_total = 0
+    
+    for message in pending_messages:
+        conversation = message.conversation
+        sender = message.sender
+        
+        # Trouver le destinataire
+        recipient_part = conversation.participants.exclude(user=sender).filter(is_active=True).first()
+        if not recipient_part:
+            continue
+            
+        recipient = recipient_part.user
+        
+        # Vérifier s'il y a un booking passé ou en cours entre eux
+        booking = Booking.objects.filter(
+            Q(student=sender, mentor=recipient) | Q(student=recipient, mentor=sender),
+            status='CONFIRMED',
+            is_active=True
+        ).filter(
+            Q(date__lt=now.date()) | 
+            Q(date=now.date(), time__lte=now.time())
+        ).first()
+        
+        if booking:
+            message.is_visible_to_recipient = True
+            message.save(update_fields=['is_visible_to_recipient'])
+            unlocked_total += 1
+    
+    if unlocked_total > 0:
+        logger.info(f"Check périodique: débloqué {unlocked_total} messages")
+    
+    return unlocked_total

backend/apps/messaging/views.py

@@ -201,27 +201,13 @@ class ConversationViewSet(HashIdMixin, viewsets.ModelViewSet):
         )
         serializer.is_valid(raise_exception=True)
         
-        # On surcharge la méthode create du serializer pour gérer ce champ ? 
-        # Non, MessageCreateSerializer.create fait le create.
-        # On va modifier MessageCreateSerializer pour accepter un argument extra ou on update après.
-        # Update après est moins performant (2 DB calls) mais plus simple sans toucher au serializer complexe.
-        
         message = serializer.save()
         
         if is_visible:
             message.is_visible_to_recipient = True
             message.save(update_fields=['is_visible_to_recipient'])
         
-        # Broadcast to WebSocket
-        # IMPORTANT: Si le message est caché, faut-il l'envoyer par WS ?
-        # OUI, mais le frontend du destinataire doit savoir qu'il est caché (ou ne pas l'afficher).
-        # MAIS si on l'envoie, le destinataire reçoit la data. C'est "envoyé mais pas vu".
-        # Le user a dit "le destinataire ne le voit pas".
-        # Si on l'envoie par WS, le JS le reçoit.
-        # On devrait peut-être NE PAS l'envoyer au destinataire via WS si caché.
-        # Ou l'envoyer avec un flag "hidden" et le front ne l'affiche pas ?
-        # Sécurité: Mieux vaut ne pas l'envoyer au destinataire.
-        
+        # Broadcast to WebSocket avec les infos de visibilité
         try:
             from channels.layers import get_channel_layer
             from asgiref.sync import async_to_sync
@@ -230,26 +216,28 @@ class ConversationViewSet(HashIdMixin, viewsets.ModelViewSet):
             
             msg_data = MessageSerializer(message).data
             
-            # Envoyer au groupe du chat
-            # Problème: le groupe inclut les deux users.
-            # Si on envoie, les deux reçoivent.
-            # On ne peut pas filtrer par destinataire facilement ici sauf si on a des groupes par user.
-            # Solution: Envoyer le message avec le champ 'is_visible_to_recipient'.
-            # Le frontend devra filtrer. C'est acceptable car ce n'est pas une donnée ultra sensible, juste une règle métier.
-            # Et le serializer inclut déjà 'is_visible_to_recipient' ? Non, il faut l'ajouter au serializer.
-            
             async_to_sync(channel_layer.group_send)(
                 f'chat_{conversation.id}',
                 {
                     'type': 'chat_message',
-                    'message': msg_data
+                    'message': msg_data,
+                    'sender_id': request.user.id,
+                    'is_visible': is_visible
                 }
             )
         except Exception as e:
             pass
         
+        # Préparer la réponse
+        response_data = MessageSerializer(message).data
+        
+        # Ajouter un avertissement si le message est en attente
+        if not is_visible:
+            response_data['queued'] = True
+            response_data['queued_message'] = "Votre message sera délivré au destinataire lors de votre prochain rendez-vous."
+        
         return Response(
-            MessageSerializer(message).data,
+            response_data,
             status=status.HTTP_201_CREATED
         )
 

backend/apps/opportunities/views.py

@@ -5,14 +5,14 @@ from rest_framework import viewsets, filters
 from django_filters.rest_framework import DjangoFilterBackend
 from rest_framework.decorators import action
 from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated
+from rest_framework.permissions import IsAuthenticated, AllowAny
 
 from apps.opportunities.models import Opportunity, OpportunityView
 from apps.opportunities.serializers import OpportunitySerializer
 
 class OpportunityViewSet(viewsets.ReadOnlyModelViewSet):
     """Liste des opportunités"""
-    permission_classes = [IsAuthenticated]
+    permission_classes = [AllowAny]
     queryset = Opportunity.objects.filter(is_active=True)
     serializer_class = OpportunitySerializer
     filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]

backend/apps/users/apps.py

@@ -4,3 +4,6 @@ from django.apps import AppConfig
 class UsersConfig(AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'
     name = 'apps.users'
+    
+    def ready(self):
+        import apps.users.signals  # noqa

backend/apps/users/encryption.py

@@ -0,0 +1,78 @@
+# ============================================
+# apps/users/encryption.py - Service de chiffrement
+# ============================================
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.backends import default_backend
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def generate_rsa_keypair():
+    """
+    Génère une paire de clés RSA 2048 bits.
+    Retourne un tuple (public_key_pem, private_key_pem)
+    """
+    try:
+        # Générer la clé privée
+        private_key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=2048,
+            backend=default_backend()
+        )
+        
+        # Convertir la clé privée en PEM
+        private_key_pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption()
+        ).decode('utf-8')
+        
+        # Extraire la clé publique et la convertir en PEM
+        public_key = private_key.public_key()
+        public_key_pem = public_key.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo
+        ).decode('utf-8')
+        
+        return public_key_pem, private_key_pem
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la génération des clés RSA: {e}")
+        return None, None
+
+
+def ensure_user_has_keys(user_profile):
+    """
+    S'assure qu'un profil utilisateur a des clés de chiffrement.
+    Si non, les génère et les sauvegarde.
+    
+    Args:
+        user_profile: Instance de UserProfile
+        
+    Returns:
+        bool: True si les clés existent ou ont été générées avec succès
+    """
+    if user_profile.public_key and user_profile.encrypted_private_key:
+        return True
+    
+    try:
+        public_key, private_key = generate_rsa_keypair()
+        
+        if public_key and private_key:
+            user_profile.public_key = public_key
+            # Note: En production, la clé privée devrait être chiffrée
+            # avec le mot de passe de l'utilisateur ou un secret dérivé.
+            # Pour l'instant, on la stocke en clair (le frontend la chiffre lui-même).
+            user_profile.encrypted_private_key = private_key
+            user_profile.save(update_fields=['public_key', 'encrypted_private_key'])
+            
+            logger.info(f"Clés générées pour le profil {user_profile.id}")
+            return True
+        
+        return False
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la génération des clés pour profil {user_profile.id}: {e}")
+        return False

backend/apps/users/management/__init__.py

@@ -0,0 +1 @@
+# Empty file to make this a Python package

backend/apps/users/management/commands/__init__.py

@@ -0,0 +1 @@
+# Empty file to make this a Python package

backend/apps/users/management/commands/fix_profile_flags.py

@@ -0,0 +1,47 @@
+# ============================================
+# apps/users/management/commands/fix_profile_flags.py
+# ============================================
+from django.core.management.base import BaseCommand
+from apps.users.models import UserProfile
+
+
+class Command(BaseCommand):
+    help = 'Corrige les flags is_current des profils utilisateurs'
+
+    def handle(self, *args, **options):
+        # Trouver tous les profils sans is_current=True
+        profiles_to_fix = UserProfile.objects.filter(is_current=False)
+        
+        total = profiles_to_fix.count()
+        self.stdout.write(f"Profils à corriger: {total}")
+        
+        if total == 0:
+            self.stdout.write(self.style.SUCCESS("Tous les profils sont déjà corrects!"))
+            return
+        
+        # Mettre à jour tous les profils
+        updated = profiles_to_fix.update(is_current=True)
+        
+        self.stdout.write(
+            self.style.SUCCESS(f"✓ {updated} profils mis à jour avec is_current=True")
+        )
+        
+        # Vérifier que tous ont des clés
+        profiles_without_keys = UserProfile.objects.filter(
+            is_current=True
+        ).filter(
+            public_key__isnull=True
+        ) | UserProfile.objects.filter(
+            is_current=True,
+            public_key=''
+        )
+        
+        if profiles_without_keys.exists():
+            self.stdout.write(
+                self.style.WARNING(
+                    f"\n⚠ {profiles_without_keys.count()} profils n'ont pas de clés de chiffrement."
+                )
+            )
+            self.stdout.write(
+                "Exécutez: python manage.py generate_encryption_keys"
+            )

backend/apps/users/management/commands/generate_encryption_keys.py

@@ -0,0 +1,56 @@
+# ============================================
+# apps/users/management/commands/generate_encryption_keys.py
+# ============================================
+from django.core.management.base import BaseCommand
+from apps.users.models import UserProfile
+from apps.users.encryption import ensure_user_has_keys
+
+
+class Command(BaseCommand):
+    help = 'Génère les clés de chiffrement pour tous les profils qui n\'en ont pas'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            help='Régénère les clés même si elles existent déjà',
+        )
+
+    def handle(self, *args, **options):
+        force = options['force']
+        
+        # Récupérer tous les profils courants
+        profiles = UserProfile.objects.filter(is_current=True)
+        
+        if not force:
+            # Filtrer ceux qui n'ont pas de clés
+            profiles = profiles.filter(
+                public_key__isnull=True
+            ) | profiles.filter(
+                public_key=''
+            ) | profiles.filter(
+                encrypted_private_key__isnull=True
+            ) | profiles.filter(
+                encrypted_private_key=''
+            )
+        
+        total = profiles.count()
+        self.stdout.write(f"Profils à traiter: {total}")
+        
+        success = 0
+        failed = 0
+        
+        for profile in profiles:
+            if ensure_user_has_keys(profile):
+                success += 1
+                self.stdout.write(
+                    self.style.SUCCESS(f"✓ Clés générées pour {profile.user.email}")
+                )
+            else:
+                failed += 1
+                self.stdout.write(
+                    self.style.ERROR(f"✗ Échec pour {profile.user.email}")
+                )
+        
+        self.stdout.write('')
+        self.stdout.write(self.style.SUCCESS(f"Terminé: {success} succès, {failed} échecs"))

backend/apps/users/serializers.py

@@ -93,17 +93,24 @@ class UserRegistrationSerializer(serializers.Serializer):
         country = validated_data.pop('country', None)
         university = validated_data.pop('university', None)
         
-        # Créer l'utilisateur
+        # Créer l'utilisateur (déclenche le signal post_save qui crée un profil de base)
         user = User.objects.create_user(**validated_data)
         
-        # Créer le profil
-        profile = UserProfile.objects.create(user=user, name=name)
+        # Récupérer le profil créé par le signal et le mettre à jour avec les vraies infos
+        profile = UserProfile.objects.filter(user=user).first()
+        if not profile:
+            # Au cas où le signal n'aurait pas fonctionné
+            profile = UserProfile.objects.create(user=user, name=name, is_current=True)
+        else:
+            profile.name = name
+            profile.is_current = True  # S'assurer que le profil est actif
+            profile.save()
         
         if country:
-            UserCountry.objects.create(profile=profile, country=country)
+            UserCountry.objects.update_or_create(profile=profile, defaults={'country': country, 'is_current': True})
         
         if university:
-            UserUniversity.objects.create(profile=profile, university=university)
+            UserUniversity.objects.update_or_create(profile=profile, defaults={'university': university, 'is_current': True})
         
         return user
 

backend/apps/users/signals.py

@@ -0,0 +1,49 @@
+# ============================================
+# apps/users/signals.py - Signaux pour les utilisateurs
+# ============================================
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(post_save, sender='users.UserProfile')
+def generate_encryption_keys_on_profile_create(sender, instance, created, **kwargs):
+    """
+    Génère automatiquement les clés de chiffrement quand un profil est créé
+    ou si le profil n'a pas de clés.
+    """
+    # Vérifier si le profil n'a pas déjà de clés
+    if not instance.public_key or not instance.encrypted_private_key:
+        try:
+            from apps.users.encryption import generate_rsa_keypair
+            
+            public_key, private_key = generate_rsa_keypair()
+            
+            if public_key and private_key:
+                # Utiliser update() pour éviter de déclencher à nouveau le signal
+                from apps.users.models import UserProfile
+                UserProfile.objects.filter(pk=instance.pk).update(
+                    public_key=public_key,
+                    encrypted_private_key=private_key,
+                    is_current=True  # S'assurer que le profil est actif
+                )
+                logger.info(f"Clés de chiffrement générées pour le profil {instance.pk}")
+        except Exception as e:
+            logger.error(f"Erreur lors de la génération des clés: {e}")
+
+
+@receiver(post_save, sender='users.User')
+def ensure_user_profile_has_keys(sender, instance, created, **kwargs):
+    """
+    S'assure que le profil courant de l'utilisateur a des clés de chiffrement.
+    """
+    try:
+        profile = instance.profiles.filter(is_current=True).first()
+        
+        if profile and (not profile.public_key or not profile.encrypted_private_key):
+            from apps.users.encryption import ensure_user_has_keys
+            ensure_user_has_keys(profile)
+    except Exception as e:
+        logger.error(f"Erreur lors de la vérification des clés utilisateur: {e}")

backend/celery.py

@@ -1,12 +0,0 @@
-import os
-from celery import Celery
-
-os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'educonnect_api.settings')
-
-app = Celery('educonnect_api')
-app.config_from_object('django.conf:settings', namespace='CELERY')
-app.autodiscover_tasks()
-
-@app.task(bind=True)
-def debug_task(self):
-    print(f'Request: {self.request!r}')

backend/educonnect/__init__.py

@@ -0,0 +1,8 @@
+# ============================================
+# educonnect/__init__.py
+# ============================================
+# This will make sure the app is always imported when
+# Django starts so that shared_task will use this app.
+from .celery import app as celery_app
+
+__all__ = ('celery_app',)

backend/educonnect/asgi.py

@@ -1,29 +1,25 @@
-# ============================================
-# educonnect_api/asgi.py
-# ============================================
-
 import os
+import django
 from django.core.asgi import get_asgi_application
-from channels.routing import ProtocolTypeRouter, URLRouter
-from channels.auth import AuthMiddlewareStack
-from apps.messaging.consumers import ChatConsumer
-from django.urls import path
 
-os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'educonnect_api.settings')
+# Définir les paramètres Django avant tout import d'application
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'educonnect.settings')
 
+# Initialiser Django
 django_asgi_app = get_asgi_application()
 
+# Maintenant on peut importer le reste
 from channels.routing import ProtocolTypeRouter, URLRouter
-
+from django.urls import path
+from apps.messaging.consumers import ChatConsumer
 from apps.notifications.consumers import NotificationConsumer
+from educonnect.middleware import JwtAuthMiddleware
 
 websocket_urlpatterns = [
     path('ws/chat/<str:conversation_id>/', ChatConsumer.as_asgi()),
     path('ws/notifications/', NotificationConsumer.as_asgi()),
 ]
 
-from educonnect.middleware import JwtAuthMiddleware
-
 application = ProtocolTypeRouter({
     "http": django_asgi_app,
     "websocket": JwtAuthMiddleware(

backend/educonnect/celery.py

@@ -0,0 +1,22 @@
+# ============================================
+# educonnect/celery.py - Configuration Celery
+# ============================================
+import os
+from celery import Celery
+
+# set the default Django settings module for the 'celery' program.
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'educonnect.settings')
+
+app = Celery('educonnect')
+
+# Using a string here means the worker doesn't have to serialize
+# the configuration object to child processes.
+app.config_from_object('django.conf:settings', namespace='CELERY')
+
+# Load task modules from all registered Django app configs.
+app.autodiscover_tasks()
+
+
+@app.task(bind=True, ignore_result=True)
+def debug_task(self):
+    print(f'Request: {self.request!r}')

backend/educonnect/settings.py

@@ -30,6 +30,7 @@ INSTALLED_APPS = [
     'django_filters',
     'drf_spectacular',
     'channels',
+    'django_celery_beat',
     
     # Local apps
     'apps.users',
@@ -79,31 +80,31 @@ WSGI_APPLICATION = 'educonnect.wsgi.application'
 ASGI_APPLICATION = 'educonnect.asgi.application'
 
 # Database
-DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': BASE_DIR / 'db.sqlite3',
-        'OPTIONS': {
-            'timeout': 20,  # Augmente le timeout pour éviter "database is locked"
+if config('DB_HOST', default=None):
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.postgresql',
+            'NAME': config('DB_NAME', default='educonnect_db'),
+            'USER': config('DB_USER', default='postgres'),
+            'PASSWORD': config('DB_PASSWORD', default='postgres'),
+            'HOST': config('DB_HOST'),
+            'PORT': config('DB_PORT', default='5432'),
+            'CONN_MAX_AGE': 600,
+            'OPTIONS': {
+                'connect_timeout': 10,
+            }
+        }
+    }
+else:
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.sqlite3',
+            'NAME': BASE_DIR / 'db.sqlite3',
+            'OPTIONS': {
+                'timeout': 20,
+            }
         }
     }
-}
-
-# Uncomment below for PostgreSQL
-# DATABASES = {
-#     'default': {
-#         'ENGINE': 'django.db.backends.postgresql',
-#         'NAME': config('DB_NAME', default='educonnect_db'),
-#         'USER': config('DB_USER', default='postgres'),
-#         'PASSWORD': config('DB_PASSWORD', default='postgres'),
-#         'HOST': config('DB_HOST', default='localhost'),
-#         'PORT': config('DB_PORT', default='5432'),
-#         'CONN_MAX_AGE': 600,
-#         'OPTIONS': {
-#             'connect_timeout': 10,
-#         }
-#     }
-# }
 
 # Custom User Model
 AUTH_USER_MODEL = 'users.User'
@@ -297,3 +298,27 @@ BADGE_THRESHOLDS = {
     'MASTER': {'points': 2500},
     'LEGEND': {'points': 5000},
 }
+
+# Celery Configuration
+CELERY_BROKER_URL = config('CELERY_BROKER_URL', default='redis://localhost:6379/0')
+CELERY_RESULT_BACKEND = config('CELERY_RESULT_BACKEND', default='redis://localhost:6379/0')
+CELERY_ACCEPT_CONTENT = ['json']
+CELERY_TASK_SERIALIZER = 'json'
+CELERY_RESULT_SERIALIZER = 'json'
+CELERY_TIMEZONE = TIME_ZONE
+CELERY_TASK_TRACK_STARTED = True
+CELERY_TASK_TIME_LIMIT = 30 * 60  # 30 minutes max
+
+# Celery Beat - Tâches périodiques
+CELERY_BEAT_SCHEDULER = 'django_celery_beat.schedulers:DatabaseScheduler'
+CELERY_BEAT_SCHEDULE = {
+    'check-pending-messages-every-5-minutes': {
+        'task': 'messaging.check_pending_messages',
+        'schedule': 300.0,  # 5 minutes
+    },
+    'schedule-unlock-upcoming-bookings': {
+        'task': 'messaging.schedule_unlock_for_upcoming_bookings',
+        'schedule': 600.0,  # 10 minutes
+    },
+}
+

backend/list_models.py

@@ -0,0 +1,21 @@
+from google import genai
+import os
+from decouple import config
+
+def list_models():
+    api_key = config('GEMINI_API_KEY', default='')
+    if not api_key:
+        print("GEMINI_API_KEY not found")
+        return
+    
+    client = genai.Client(api_key=api_key)
+    try:
+        print("Listing models...")
+        for model in client.models.list():
+            if 'generateContent' in model.supported_actions:
+                print(f"Model: {model.name}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    list_models()

backend/requirements.txt

@@ -1,6 +1,6 @@
 amqp==5.3.1
 annotated-types==0.7.0
-anyio==4.12.0
+anyio>=3.5.0
 asgiref==3.11.0
 attrs==25.4.0
 autobahn==25.11.1
@@ -32,9 +32,11 @@ django-allauth==0.57.0
 django-cors-headers==4.3.0
 django-filter==23.3
 django-ses==3.5.0
+django-celery-beat==2.5.0
+django-celery-results==2.5.1
 django-storages==1.14.2
 djangorestframework==3.14.0
-djangorestframework-simplejwt==5.3.0
+djangorestframework-simplejwt==5.5.1
 drf-spectacular==0.26.5
 factory-boy==3.3.0
 Faker==20.1.0
@@ -42,7 +44,7 @@ flake8==6.1.0
 google-ai-generativelanguage==0.4.0
 google-api-core==2.28.1
 google-auth==2.43.0
-google-genai==1.52.0
+google-genai>=0.1.0
 google-generativeai==0.3.1
 googleapis-common-protos==1.72.0
 grpcio==1.76.0
@@ -66,7 +68,7 @@ mccabe==0.7.0
 msgpack==1.1.2
 mypy_extensions==1.1.0
 oauthlib==3.3.1
-openai==1.3.7
+openai>=1.3.7
 packaging==25.0
 pathspec==0.12.1
 Pillow==10.1.0
@@ -122,3 +124,4 @@ wcwidth==0.2.14
 websockets==15.0.1
 whitenoise==6.6.0
 zope.interface==8.1.1
+pypdf==5.1.0

docker-compose.yml

@@ -0,0 +1,101 @@
+
+services:
+  db:
+    image: postgres:15
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    environment:
+      POSTGRES_DB: educonnect_db
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    ports:
+      - "5433:5432"
+  
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6380:6379"
+  
+  backend:
+    build: ./backend
+    command: python manage.py runserver 0.0.0.0:8000
+    volumes:
+      - ./backend:/app
+      - media_volume:/app/media
+      - static_volume:/app/staticfiles
+    ports:
+      - "8000:8000"
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=True
+      - DB_HOST=db
+      - DB_PORT=5432
+      - DB_NAME=educonnect_db
+      - DB_USER=postgres
+      - DB_PASSWORD=postgres
+      - REDIS_HOST=redis
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    depends_on:
+      - db
+      - redis
+  
+  celery:
+    build: ./backend
+    command: celery -A educonnect worker -l info
+    volumes:
+      - ./backend:/app
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=True
+      - DB_HOST=db
+      - DB_PORT=5432
+      - DB_NAME=educonnect_db
+      - DB_USER=postgres
+      - DB_PASSWORD=postgres
+      - REDIS_HOST=redis
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    depends_on:
+      - db
+      - redis
+  
+  channels:
+    build: ./backend
+    command: daphne -b 0.0.0.0 -p 8001 educonnect.asgi:application
+    volumes:
+      - ./backend:/app
+    ports:
+      - "8001:8001"
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=True
+      - DB_HOST=db
+      - DB_PORT=5432
+      - DB_NAME=educonnect_db
+      - DB_USER=postgres
+      - DB_PASSWORD=postgres
+      - REDIS_HOST=redis
+    depends_on:
+      - db
+      - redis
+
+  frontend:
+    build: ./frontend
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+    ports:
+      - "5173:3000"
+    environment:
+      - VITE_API_URL=http://localhost:8000/api
+    depends_on:
+      - backend
+
+volumes:
+  postgres_data:
+  media_volume:
+  static_volume:

documentation/ENCRYPTION.md

@@ -0,0 +1,143 @@
+# Système de Chiffrement End-to-End - EduConnect
+
+## Vue d'ensemble
+
+Le système de chiffrement garantit que tous les messages entre utilisateurs sont chiffrés de bout en bout (E2E) en utilisant RSA-2048 et AES-256.
+
+## Architecture
+
+### Backend (Django)
+
+1. **Génération automatique des clés** (`apps/users/encryption.py`)
+   - Génère une paire de clés RSA 2048 bits pour chaque utilisateur
+   - Clé publique : stockée en clair (partagée avec les autres)
+   - Clé privée : stockée (à chiffrer avec le mot de passe utilisateur en production)
+
+2. **Signaux automatiques** (`apps/users/signals.py`)
+   - `generate_encryption_keys_on_profile_create` : Génère les clés à la création du profil
+   - `ensure_user_profile_has_keys` : Vérifie que chaque utilisateur a des clés
+   - Définit automatiquement `is_current=True` sur les profils
+
+3. **Serializers** (`apps/users/serializers.py`)
+   - `UserProfileDetailSerializer` : Inclut `public_key` et `encrypted_private_key`
+   - `UserRegistrationSerializer` : S'assure que `is_current=True` lors de l'inscription
+
+### Frontend (React/TypeScript)
+
+1. **Service de chiffrement** (`services/encryption.ts`)
+   - Récupère les clés depuis le backend en priorité
+   - Génère localement uniquement en fallback
+   - Synchronise automatiquement avec le backend
+
+2. **Initialisation automatique** (`context/AuthContext.tsx`)
+   - Les clés sont initialisées dès la connexion
+   - Pas besoin d'attendre l'ouverture du chat
+
+3. **Chiffrement des messages** (`pages/Chat.tsx`)
+   - Vérifie que tous les participants ont des clés publiques
+   - Génère une clé AES unique par message
+   - Chiffre le contenu avec AES
+   - Chiffre la clé AES avec la clé publique RSA de chaque participant
+
+## Commandes de maintenance
+
+### Générer les clés pour tous les utilisateurs
+```bash
+python manage.py generate_encryption_keys
+```
+
+Options :
+- `--force` : Régénère les clés même si elles existent
+
+### Corriger les flags is_current
+```bash
+python manage.py fix_profile_flags
+```
+
+## Vérifications
+
+### Vérifier que tous les profils ont des clés
+```bash
+python manage.py shell -c "
+from apps.users.models import UserProfile
+profiles = UserProfile.objects.filter(is_current=True)
+print(f'Total: {profiles.count()}')
+for p in profiles:
+    has_keys = bool(p.public_key and p.encrypted_private_key)
+    print(f'{p.user.email}: {\"✓\" if has_keys else \"✗\"} Clés')
+"
+```
+
+### Vérifier is_current
+```bash
+python manage.py shell -c "
+from apps.users.models import UserProfile
+total = UserProfile.objects.count()
+current = UserProfile.objects.filter(is_current=True).count()
+print(f'Profils actifs: {current}/{total}')
+"
+```
+
+## Flux de chiffrement
+
+1. **Envoi d'un message**
+   ```
+   User A → Génère clé AES → Chiffre message avec AES
+         → Chiffre clé AES avec public_key de User B
+         → Envoie {contenu_chiffré, clés_chiffrées}
+   ```
+
+2. **Réception d'un message**
+   ```
+   User B → Reçoit message chiffré
+         → Déchiffre la clé AES avec sa private_key
+         → Déchiffre le contenu avec la clé AES
+         → Affiche le message
+   ```
+
+## Sécurité
+
+### Points forts
+✅ Chiffrement RSA-2048 (clés asymétriques)
+✅ Chiffrement AES-256-CBC (contenu des messages)
+✅ Clé AES unique par message
+✅ Génération automatique des clés
+✅ Clés stockées côté serveur (backup)
+
+### Améliorations futures
+⚠️ Chiffrer la clé privée avec le mot de passe utilisateur
+⚠️ Implémenter la rotation des clés
+⚠️ Ajouter un système de récupération de clés
+⚠️ Perfect Forward Secrecy (PFS)
+
+## Dépannage
+
+### "Message non chiffré (Destinataire sans clés)"
+
+**Causes possibles :**
+1. Le profil n'a pas `is_current=True`
+   - Solution : `python manage.py fix_profile_flags`
+
+2. Les clés n'ont pas été générées
+   - Solution : `python manage.py generate_encryption_keys`
+
+3. Les clés ne sont pas renvoyées par l'API
+   - Vérifier que `UserProfileDetailSerializer` inclut les clés
+   - Vérifier le mapping dans `services/messaging.ts`
+
+### Logs de débogage
+
+Dans la console du navigateur, lors de l'envoi d'un message :
+```
+🔐 Vérification du chiffrement:
+  - Mes clés: Présentes
+  - Autres participants: 1
+  - Participant 1: [Nom]
+    - public_key: Présente ✓
+  - Chiffrement possible: OUI ✓
+```
+
+Si "NON ✗" apparaît, vérifier que le backend renvoie bien les clés.
+
+## Développé par
+Marino ATOHOUN pour Hypee - EduConnect Africa

documentation/EXTERNAL_TOOLS.md

@@ -0,0 +1,47 @@
+# Outils Externes - EduConnect
+
+## Laboratoire Chimique Virtuel
+
+Le Laboratoire Chimique est déployé séparément sur Vercel et accessible via un lien externe.
+
+### Accès
+- **URL** : https://virtual-labo-chimique.vercel.app/
+- **Depuis EduConnect** : Outils → Laboratoire Chimique → S'ouvre dans un nouvel onglet
+
+### Configuration
+
+Le lien est configuré dans `frontend/pages/LearningTools.tsx` :
+
+```typescript
+else if (toolId === 'chem') {
+  window.open('https://virtual-labo-chimique.vercel.app/', '_blank');
+}
+```
+
+### Modification du lien
+
+Pour changer l'URL du laboratoire :
+
+1. Ouvrir `frontend/pages/LearningTools.tsx`
+2. Chercher `toolId === 'chem'`
+3. Modifier l'URL dans `window.open()`
+
+### Base de données
+
+L'outil est enregistré dans la table `learning_tools` avec :
+- `tool_id` : `'chem'`
+- `title` : `'Laboratoire Chimique'`
+- `status` : `'available'`
+
+## Autres outils externes
+
+Pour ajouter d'autres outils externes, suivre le même pattern :
+
+```typescript
+else if (toolId === 'mon_outil') {
+  window.open('https://mon-outil.com/', '_blank');
+}
+```
+
+---
+Développé par Marino ATOHOUN pour Hypee - EduConnect Africa