n3wt-school/Back-End/GestionMessagerie/views.py

from django.http.response import JsonResponse
from rest_framework.views import APIView
from rest_framework.parsers import JSONParser
from django.core.mail import send_mail
from django.utils.html import strip_tags
from django.conf import settings
from rest_framework.response import Response
from rest_framework import status
from django.db.models import Q
from Auth.models import Profile  # Assurez-vous que le modèle Profile contient les informations nécessaires

from .models import *
from School.models import Teacher, ProfileRole
from Settings.models import SMTPSettings  # Assurez-vous que le chemin est correct

from GestionMessagerie.serializers import MessageSerializer
from School.serializers import TeacherSerializer

from N3wtSchool import bdd
import N3wtSchool.mailManager as mailer

class MessagerieView(APIView):
    def get(self, request, profile_id):
        messagesList = bdd.getObjects(_objectName=Messagerie, _columnName='destinataire__id', _value=profile_id)
        messages_serializer = MessageSerializer(messagesList, many=True)
        return JsonResponse(messages_serializer.data, safe=False)

class MessageView(APIView):
    def post(self, request):
        message_data=JSONParser().parse(request)
        message_serializer = MessageSerializer(data=message_data)

        if message_serializer.is_valid():
            message_serializer.save()

            return JsonResponse('Nouveau Message ajouté', safe=False)

        return JsonResponse(message_serializer.errors, safe=False)

class MessageSimpleView(APIView):
    def get(self, request, id):
        message=bdd.getObject(Messagerie, "id", id)
        message_serializer=MessageSerializer(message)
        return JsonResponse(message_serializer.data, safe=False)

class SendEmailView(APIView):
    """
    API pour envoyer des emails aux parents et professeurs.
    """
    def post(self, request):
        data = request.data
        recipients = data.get('recipients', [])
        cc = data.get('cc', [])
        bcc = data.get('bcc', [])
        subject = data.get('subject', 'Notification')
        message = data.get('message', '')
        establishment_id = data.get('establishment_id', '')

        if not recipients or not message:
            return Response({'error': 'Les destinataires et le message sont requis.'}, status=status.HTTP_400_BAD_REQUEST)

        try:
            # Récupérer la connexion SMTP
            connection = mailer.getConnection(establishment_id)

            # Envoyer l'email
            return mailer.sendMail(
                subject=subject,
                message=message,
                recipients=recipients,
                cc=cc,
                bcc=bcc,
                attachments=[],
                connection=connection
            )
        except NotFound as e:
            return Response({'error': str(e)}, status=status.HTTP_404_NOT_FOUND)
        except Exception as e:
            return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class ContactsView(APIView):
    """
    API pour récupérer les contacts associés à un établissement.
    """
    def get(self, request, establishment_id):
        try:
            # Récupérer les enseignants associés à l'établissement
            teachers = Teacher.objects.filter(profile_role__establishment_id=establishment_id)
            teachers_serializer = TeacherSerializer(teachers, many=True)

            # Ajouter un contact pour l'administration
            admin_contact = {
                "id": "admin",
                "name": "Administration",
                "email": "admin@etablissement.com",
                "profilePic": "https://www.gravatar.com/avatar/admin"
            }

            contacts = [admin_contact] + teachers_serializer.data
            return Response(contacts, status=status.HTTP_200_OK)
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

def search_recipients(request):
    """
    API pour rechercher des destinataires en fonction d'un terme de recherche et d'un établissement.
    """
    query = request.GET.get('q', '').strip()  # Récupérer le terme de recherche depuis les paramètres GET
    establishment_id = request.GET.get('establishment_id', None)  # Récupérer l'ID de l'établissement

    if not query:
        return JsonResponse([], safe=False)  # Retourner une liste vide si aucun terme n'est fourni

    if not establishment_id:
        return JsonResponse({'error': 'establishment_id est requis'}, safe=False, status=status.HTTP_400_BAD_REQUEST)

    # Rechercher dans les champs pertinents (nom, prénom, email) et filtrer par establishment_id
    profiles = Profile.objects.filter(
        Q(first_name__icontains=query) |
        Q(last_name__icontains=query) |
        Q(email__icontains=query),
        roles__establishment_id=establishment_id,  # Utiliser 'roles' au lieu de 'profilerole'
        roles__is_active=True  # Filtrer uniquement les ProfileRole actifs
    ).distinct()

    # Construire la réponse avec les rôles associés
    results = []
    for profile in profiles:
        profile_roles = ProfileRole.objects.filter(
            profile=profile,
            establishment_id=establishment_id,
            is_active=True  # Inclure uniquement les ProfileRole actifs
        ).values(
            'id', 'role_type', 'establishment__name', 'is_active'
        )
        results.append({
            'id': profile.id,
            'first_name': profile.first_name,
            'last_name': profile.last_name,
            'email': profile.email,
            'roles': list(profile_roles)  # Inclure tous les rôles actifs associés pour cet établissement
        })

    return JsonResponse(results, safe=False)