feat: mise en place de la messagerie [#17]

2026-04-04 03:11:27 +00:00 · 2025-05-26 13:24:42 +02:00
parent e2df29d851
commit d37145b73e
64 changed files with 13113 additions and 853 deletions
--- a/Front-End/src/app/actions/messagerieAction.js
+++ b/Front-End/src/app/actions/messagerieAction.js
@ -1,67 +1,251 @@
 import {
  BE_GESTIONMESSAGERIE_CONVERSATIONS_URL,
-  BE_GESTIONMESSAGERIE_CONVERSATION_MESSAGES_URL,
-  BE_GESTIONMESSAGERIE_MARK_AS_READ_URL,
-  BE_GESTIONMESSAGERIE_MESSAGES_URL,
+  BE_GESTIONMESSAGERIE_SEND_MESSAGE_URL,
+  BE_GESTIONMESSAGERIE_CREATE_CONVERSATION_URL,
  BE_GESTIONMESSAGERIE_SEARCH_RECIPIENTS_URL,
+  BE_GESTIONMESSAGERIE_MARK_AS_READ_URL,
+  BE_GESTIONMESSAGERIE_UPLOAD_FILE_URL,
+  BE_GESTIONMESSAGERIE_DELETE_CONVERSATION_URL,
 } from '@/utils/Url';
 import { errorHandler, requestResponseHandler } from './actionsHandlers';
+import logger from '@/utils/logger';

-export const fetchConversations = (profileId) => {
-  return fetch(`${BE_GESTIONMESSAGERIE_CONVERSATIONS_URL}/${profileId}/`, {
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  })
-    .then(requestResponseHandler)
-    .catch(errorHandler);
+// Helper pour construire les en-têtes avec CSRF
+const buildHeaders = (csrfToken) => {
+  const headers = {
+    'Content-Type': 'application/json',
+  };
+
+  // Ajouter le token CSRF
+  if (csrfToken) {
+    headers['X-CSRFToken'] = csrfToken;
+  }
+
+  return headers;
 };

-export const fetchMessages = (conversationId) => {
-  return fetch(
-    `${BE_GESTIONMESSAGERIE_CONVERSATION_MESSAGES_URL}/${conversationId}/`,
-    {
-      headers: {
-        'Content-Type': 'application/json',
-      },
+/**
+ * Récupère les conversations d'un utilisateur
+ */
+export const fetchConversations = async (userId, csrfToken) => {
+  try {
+    // Utiliser la nouvelle route avec user_id en paramètre d'URL
+    const url = `${BE_GESTIONMESSAGERIE_CONVERSATIONS_URL}/user/${userId}/`;
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: buildHeaders(csrfToken),
+      credentials: 'include',
+    });
+    return await requestResponseHandler(response);
+  } catch (error) {
+    logger.error('Erreur lors de la récupération des conversations:', error);
+    return errorHandler(error);
+  }
+};
+
+/**
+ * Récupère les messages d'une conversation
+ */
+export const fetchMessages = async (
+  conversationId,
+  page = 1,
+  limit = 50,
+  csrfToken,
+  userId = null
+) => {
+  try {
+    // Utiliser la nouvelle URL avec conversation_id en paramètre d'URL
+    let url = `${BE_GESTIONMESSAGERIE_CONVERSATIONS_URL}/${conversationId}/messages/?page=${page}&limit=${limit}`;
+
+    // Ajouter user_id si fourni pour calculer correctement is_read
+    if (userId) {
+      url += `&user_id=${userId}`;
    }
-  )
-    .then(requestResponseHandler)
-    .catch(errorHandler);
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: buildHeaders(csrfToken),
+      credentials: 'include',
+    });
+    return await requestResponseHandler(response);
+  } catch (error) {
+    logger.error('Erreur lors de la récupération des messages:', error);
+    return errorHandler(error);
+  }
 };

-export const sendMessage = (data) => {
-  return fetch(`${BE_GESTIONMESSAGERIE_MESSAGES_URL}`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(data),
-  })
-    .then(requestResponseHandler)
-    .catch(errorHandler);
+/**
+ * Envoie un message dans une conversation
+ */
+export const sendMessage = async (messageData, csrfToken) => {
+  try {
+    const response = await fetch(BE_GESTIONMESSAGERIE_SEND_MESSAGE_URL, {
+      method: 'POST',
+      headers: buildHeaders(csrfToken),
+      credentials: 'include',
+      body: JSON.stringify(messageData),
+    });
+    return await requestResponseHandler(response);
+  } catch (error) {
+    logger.error("Erreur lors de l'envoi du message:", error);
+    return errorHandler(error);
+  }
 };

-export const markAsRead = (conversationId, profileId) => {
-  return fetch(`${BE_GESTIONMESSAGERIE_MARK_AS_READ_URL}/${conversationId}/`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ profile_id: profileId }),
-  })
-    .then(requestResponseHandler)
-    .catch(errorHandler);
+/**
+ * Crée une nouvelle conversation
+ */
+export const createConversation = async (participantIds, csrfToken) => {
+  try {
+    const requestBody = {
+      participant_ids: participantIds, // Le backend attend "participant_ids"
+      conversation_type: 'private', // Spécifier le type de conversation
+      name: '', // Le nom sera généré côté backend
+    };
+
+    const response = await fetch(BE_GESTIONMESSAGERIE_CREATE_CONVERSATION_URL, {
+      method: 'POST',
+      headers: buildHeaders(csrfToken),
+      credentials: 'include',
+      body: JSON.stringify(requestBody),
+    });
+
+    return await requestResponseHandler(response);
+  } catch (error) {
+    logger.error('Erreur lors de la création de la conversation:', error);
+    return errorHandler(error);
+  }
 };

-export const searchRecipients = (establishmentId, query) => {
-  const url = `${BE_GESTIONMESSAGERIE_SEARCH_RECIPIENTS_URL}/?establishment_id=${establishmentId}&q=${encodeURIComponent(query)}`;
-  return fetch(url, {
-    method: 'GET',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  })
-    .then(requestResponseHandler)
-    .catch(errorHandler);
+/**
+ * Recherche des destinataires pour la messagerie
+ */
+export const searchMessagerieRecipients = async (
+  establishmentId,
+  query,
+  csrfToken
+) => {
+  try {
+    const baseUrl = BE_GESTIONMESSAGERIE_SEARCH_RECIPIENTS_URL.endsWith('/')
+      ? BE_GESTIONMESSAGERIE_SEARCH_RECIPIENTS_URL
+      : BE_GESTIONMESSAGERIE_SEARCH_RECIPIENTS_URL + '/';
+
+    const url = `${baseUrl}?establishment_id=${establishmentId}&q=${encodeURIComponent(query)}`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: buildHeaders(csrfToken),
+      credentials: 'include',
+    });
+
+    return await requestResponseHandler(response);
+  } catch (error) {
+    logger.error('Erreur lors de la recherche des destinataires:', error);
+    return errorHandler(error);
+  }
+};
+
+/**
+ * Marque des messages comme lus
+ */
+export const markAsRead = async (conversationId, userId, csrfToken) => {
+  try {
+    const response = await fetch(BE_GESTIONMESSAGERIE_MARK_AS_READ_URL, {
+      method: 'POST',
+      headers: buildHeaders(csrfToken),
+      credentials: 'include',
+      body: JSON.stringify({
+        conversation_id: conversationId,
+        user_id: userId,
+      }),
+    });
+    return await requestResponseHandler(response);
+  } catch (error) {
+    logger.error('Erreur lors du marquage des messages comme lus:', error);
+    return errorHandler(error);
+  }
+};
+
+/**
+ * Upload un fichier pour la messagerie
+ */
+export const uploadFile = async (
+  file,
+  conversationId,
+  senderId,
+  csrfToken,
+  onProgress = null
+) => {
+  const formData = new FormData();
+  formData.append('file', file);
+  formData.append('conversation_id', conversationId);
+  formData.append('sender_id', senderId);
+
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+
+    if (onProgress) {
+      xhr.upload.addEventListener('progress', (event) => {
+        if (event.lengthComputable) {
+          const percentComplete = (event.loaded / event.total) * 100;
+          onProgress(percentComplete);
+        }
+      });
+    }
+
+    xhr.addEventListener('load', () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try {
+          const response = JSON.parse(xhr.responseText);
+          resolve(response);
+        } catch (error) {
+          reject(new Error('Réponse invalide du serveur'));
+        }
+      } else {
+        try {
+          const errorResponse = JSON.parse(xhr.responseText);
+          reject(new Error(errorResponse.message || "Erreur lors de l'upload"));
+        } catch {
+          reject(new Error(`Erreur HTTP: ${xhr.status}`));
+        }
+      }
+    });
+
+    xhr.addEventListener('error', () => {
+      reject(new Error("Erreur réseau lors de l'upload"));
+    });
+
+    xhr.addEventListener('timeout', () => {
+      reject(new Error("Timeout lors de l'upload"));
+    });
+
+    xhr.open('POST', BE_GESTIONMESSAGERIE_UPLOAD_FILE_URL);
+    xhr.withCredentials = true;
+    xhr.timeout = 30000;
+
+    // Ajouter le header CSRF pour XMLHttpRequest
+    if (csrfToken) {
+      xhr.setRequestHeader('X-CSRFToken', csrfToken);
+    }
+
+    xhr.send(formData);
+  });
+};
+
+/**
+ * Supprime une conversation
+ */
+export const deleteConversation = async (conversationId, csrfToken) => {
+  try {
+    const url = `${BE_GESTIONMESSAGERIE_DELETE_CONVERSATION_URL}/${conversationId}/`;
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: buildHeaders(csrfToken),
+      credentials: 'include',
+    });
+    return await requestResponseHandler(response);
+  } catch (error) {
+    logger.error('Erreur lors de la suppression de la conversation:', error);
+    return errorHandler(error);
+  }
 };