feat(backend): implémentation complète du système de messagerie

Ajoute l'infrastructure backend complète pour les conversations et messages : ## Entités - Conversation : conversations individuelles, groupes, broadcast, annonces - Message : messages avec statut, priorité, pièces jointes, soft delete ## Repositories - ConversationRepository : findByParticipant, findByIdAndParticipant (sécurité) - MessageRepository : findByConversation, countUnread, markAsRead ## Services - ConversationService : CRUD conversations, archive, mute, pin - MessageService : send, edit, delete, getMessages ## REST Endpoints (12 total) - GET /api/conversations - Lister mes conversations - GET /api/conversations/{id} - Récupérer une conversation - POST /api/conversations - Créer conversation - PUT /api/conversations/{id}/archive - Archiver - PUT /api/conversations/{id}/mark-read - Marquer comme lu - PUT /api/conversations/{id}/toggle-mute - Activer/désactiver son - PUT /api/conversations/{id}/toggle-pin - Épingler - GET /api/messages?conversationId=X - Lister messages - POST /api/messages - Envoyer message - PUT /api/messages/{id} - Éditer message - DELETE /api/messages/{id} - Supprimer message ## Database - Migration V6 : tables conversations, messages, conversation_participants - Indexes sur organisation, type, archived, deleted pour performance ## Sécurité - SecuriteHelper.resolveMembreId() : résolution membre depuis JWT - Vérification accès conversation avant toute opération - @RolesAllowed sur tous les endpoints Débloquer la fonctionnalité Communication mobile (actuellement 100% stubs). Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-03-16 06:39:39 +00:00
parent f5271cc29e
commit 3be01e28a7
10 changed files with 1226 additions and 0 deletions
--- a/src/main/java/dev/lions/unionflow/server/service/ConversationService.java
+++ b/src/main/java/dev/lions/unionflow/server/service/ConversationService.java
@@ -0,0 +1,208 @@
+package dev.lions.unionflow.server.service;
+
+import dev.lions.unionflow.server.api.dto.communication.request.CreateConversationRequest;
+import dev.lions.unionflow.server.api.dto.communication.response.ConversationResponse;
+import dev.lions.unionflow.server.api.dto.communication.response.MessageResponse;
+import dev.lions.unionflow.server.entity.Conversation;
+import dev.lions.unionflow.server.entity.Membre;
+import dev.lions.unionflow.server.entity.Message;
+import dev.lions.unionflow.server.entity.Organisation;
+import dev.lions.unionflow.server.repository.ConversationRepository;
+import dev.lions.unionflow.server.repository.MembreRepository;
+import dev.lions.unionflow.server.repository.MessageRepository;
+import dev.lions.unionflow.server.repository.OrganisationRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.transaction.Transactional;
+import jakarta.ws.rs.NotFoundException;
+import org.jboss.logging.Logger;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * Service de gestion des conversations
+ *
+ * @author UnionFlow Team
+ * @version 1.0
+ * @since 2026-03-16
+ */
+@ApplicationScoped
+public class ConversationService {
+
+    private static final Logger LOG = Logger.getLogger(ConversationService.class);
+
+    @Inject
+    ConversationRepository conversationRepository;
+
+    @Inject
+    MessageRepository messageRepository;
+
+    @Inject
+    MembreRepository membreRepository;
+
+    @Inject
+    OrganisationRepository organisationRepository;
+
+    /**
+     * Liste les conversations d'un membre
+     */
+    public List<ConversationResponse> getConversations(UUID membreId, UUID organisationId, boolean includeArchived) {
+        LOG.infof("Récupération conversations pour membre %s", membreId);
+
+        List<Conversation> conversations;
+        if (organisationId != null) {
+            conversations = conversationRepository.findByOrganisation(organisationId);
+        } else {
+            conversations = conversationRepository.findByParticipant(membreId, includeArchived);
+        }
+
+        return conversations.stream()
+            .map(c -> convertToResponse(c, membreId))
+            .collect(Collectors.toList());
+    }
+
+    /**
+     * Récupère une conversation par ID
+     */
+    public ConversationResponse getConversationById(UUID conversationId, UUID membreId) {
+        Conversation conversation = conversationRepository.findByIdAndParticipant(conversationId, membreId)
+            .orElseThrow(() -> new NotFoundException("Conversation non trouvée ou accès refusé"));
+
+        return convertToResponse(conversation, membreId);
+    }
+
+    /**
+     * Crée une nouvelle conversation
+     */
+    @Transactional
+    public ConversationResponse createConversation(CreateConversationRequest request, UUID creatorId) {
+        LOG.infof("Création conversation: %s (type: %s)", request.name(), request.type());
+
+        Conversation conversation = new Conversation();
+        conversation.setName(request.name());
+        conversation.setDescription(request.description());
+        conversation.setType(request.type());
+
+        // Ajouter les participants
+        List<Membre> participants = request.participantIds().stream()
+            .map(id -> membreRepository.findById(id))
+            .filter(membre -> membre != null)
+            .collect(Collectors.toList());
+
+        // Ajouter le créateur s'il n'est pas dans la liste
+        Membre creator = membreRepository.findById(creatorId);
+        if (creator != null && !participants.contains(creator)) {
+            participants.add(creator);
+        }
+
+        conversation.setParticipants(participants);
+
+        // Organisation
+        if (request.organisationId() != null) {
+            Organisation org = organisationRepository.findById(request.organisationId());
+            conversation.setOrganisation(org);
+        }
+
+        conversation.setUpdatedAt(LocalDateTime.now());
+        conversationRepository.persist(conversation);
+
+        return convertToResponse(conversation, creatorId);
+    }
+
+    /**
+     * Archive/désarchive une conversation
+     */
+    @Transactional
+    public void archiveConversation(UUID conversationId, UUID membreId, boolean archive) {
+        Conversation conversation = conversationRepository.findByIdAndParticipant(conversationId, membreId)
+            .orElseThrow(() -> new NotFoundException("Conversation non trouvée"));
+
+        conversation.setIsArchived(archive);
+        conversation.setUpdatedAt(LocalDateTime.now());
+        conversationRepository.persist(conversation);
+    }
+
+    /**
+     * Marque une conversation comme lue
+     */
+    @Transactional
+    public void markAsRead(UUID conversationId, UUID membreId) {
+        // Vérifier accès
+        conversationRepository.findByIdAndParticipant(conversationId, membreId)
+            .orElseThrow(() -> new NotFoundException("Conversation non trouvée"));
+
+        messageRepository.markAllAsReadByConversationAndMember(conversationId, membreId);
+    }
+
+    /**
+     * Toggle mute
+     */
+    @Transactional
+    public void toggleMute(UUID conversationId, UUID membreId) {
+        Conversation conversation = conversationRepository.findByIdAndParticipant(conversationId, membreId)
+            .orElseThrow(() -> new NotFoundException("Conversation non trouvée"));
+
+        conversation.setIsMuted(!conversation.getIsMuted());
+        conversation.setUpdatedAt(LocalDateTime.now());
+    }
+
+    /**
+     * Toggle pin
+     */
+    @Transactional
+    public void togglePin(UUID conversationId, UUID membreId) {
+        Conversation conversation = conversationRepository.findByIdAndParticipant(conversationId, membreId)
+            .orElseThrow(() -> new NotFoundException("Conversation non trouvée"));
+
+        conversation.setIsPinned(!conversation.getIsPinned());
+        conversation.setUpdatedAt(LocalDateTime.now());
+    }
+
+    /**
+     * Convertit Conversation en DTO
+     */
+    private ConversationResponse convertToResponse(Conversation c, UUID currentUserId) {
+        Message lastMsg = messageRepository.findLastByConversation(c.getId());
+        long unreadCount = messageRepository.countUnreadByConversationAndMember(c.getId(), currentUserId);
+
+        return ConversationResponse.builder()
+            .id(c.getId())
+            .name(c.getName())
+            .description(c.getDescription())
+            .type(c.getType())
+            .participantIds(c.getParticipants().stream().map(Membre::getId).collect(Collectors.toList()))
+            .organisationId(c.getOrganisation() != null ? c.getOrganisation().getId() : null)
+            .lastMessage(lastMsg != null ? convertMessageToResponse(lastMsg) : null)
+            .unreadCount((int) unreadCount)
+            .isMuted(c.getIsMuted())
+            .isPinned(c.getIsPinned())
+            .isArchived(c.getIsArchived())
+            .createdAt(c.getDateCreation())
+            .updatedAt(c.getUpdatedAt())
+            .avatarUrl(c.getAvatarUrl())
+            .build();
+    }
+
+    /**
+     * Convertit Message en DTO simple
+     */
+    private MessageResponse convertMessageToResponse(Message m) {
+        return MessageResponse.builder()
+            .id(m.getId())
+            .conversationId(m.getConversation().getId())
+            .senderId(m.getSender().getId())
+            .senderName(m.getSenderName())
+            .senderAvatar(m.getSenderAvatar())
+            .content(m.getContent())
+            .type(m.getType())
+            .status(m.getStatus())
+            .priority(m.getPriority())
+            .createdAt(m.getDateCreation())
+            .isEdited(m.getIsEdited())
+            .isDeleted(m.getIsDeleted())
+            .build();
+    }
+}
--- a/src/main/java/dev/lions/unionflow/server/service/MessageService.java
+++ b/src/main/java/dev/lions/unionflow/server/service/MessageService.java
@@ -0,0 +1,203 @@
+package dev.lions.unionflow.server.service;
+
+import dev.lions.unionflow.server.api.dto.communication.request.SendMessageRequest;
+import dev.lions.unionflow.server.api.dto.communication.response.MessageResponse;
+import dev.lions.unionflow.server.api.enums.communication.MessagePriority;
+import dev.lions.unionflow.server.api.enums.communication.MessageStatus;
+import dev.lions.unionflow.server.api.enums.communication.MessageType;
+import dev.lions.unionflow.server.entity.Conversation;
+import dev.lions.unionflow.server.entity.Membre;
+import dev.lions.unionflow.server.entity.Message;
+import dev.lions.unionflow.server.repository.ConversationRepository;
+import dev.lions.unionflow.server.repository.MembreRepository;
+import dev.lions.unionflow.server.repository.MessageRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.transaction.Transactional;
+import jakarta.ws.rs.NotFoundException;
+import org.jboss.logging.Logger;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * Service de gestion des messages
+ *
+ * @author UnionFlow Team
+ * @version 1.0
+ * @since 2026-03-16
+ */
+@ApplicationScoped
+public class MessageService {
+
+    private static final Logger LOG = Logger.getLogger(MessageService.class);
+
+    @Inject
+    MessageRepository messageRepository;
+
+    @Inject
+    ConversationRepository conversationRepository;
+
+    @Inject
+    MembreRepository membreRepository;
+
+    /**
+     * Récupère les messages d'une conversation
+     */
+    public List<MessageResponse> getMessages(UUID conversationId, UUID membreId, int limit) {
+        LOG.infof("Récupération messages pour conversation %s (limit: %d)", conversationId, limit);
+
+        // Vérifier accès
+        conversationRepository.findByIdAndParticipant(conversationId, membreId)
+            .orElseThrow(() -> new NotFoundException("Conversation non trouvée ou accès refusé"));
+
+        List<Message> messages = messageRepository.findByConversation(conversationId, limit);
+
+        return messages.stream()
+            .map(this::convertToResponse)
+            .collect(Collectors.toList());
+    }
+
+    /**
+     * Envoie un message
+     */
+    @Transactional
+    public MessageResponse sendMessage(SendMessageRequest request, UUID senderId) {
+        LOG.infof("Envoi message dans conversation %s", request.conversationId());
+
+        // Vérifier accès conversation
+        Conversation conversation = conversationRepository.findByIdAndParticipant(request.conversationId(), senderId)
+            .orElseThrow(() -> new NotFoundException("Conversation non trouvée ou accès refusé"));
+
+        Membre sender = membreRepository.findById(senderId);
+        if (sender == null) {
+            throw new NotFoundException("Expéditeur non trouvé");
+        }
+
+        Message message = new Message();
+        message.setConversation(conversation);
+        message.setSender(sender);
+        message.setSenderName(sender.getPrenom() + " " + sender.getNom());
+        message.setSenderAvatar(sender.getPhotoUrl());
+        message.setContent(request.content());
+        message.setType(request.type() != null ? request.type() : MessageType.INDIVIDUAL);
+        message.setStatus(MessageStatus.SENT);
+        message.setPriority(request.priority() != null ? request.priority() : MessagePriority.NORMAL);
+
+        // Destinataires (pour targeted messages)
+        if (request.recipientIds() != null && !request.recipientIds().isEmpty()) {
+            message.setRecipientIds(request.recipientIds().stream()
+                .map(UUID::toString)
+                .collect(Collectors.joining(",")));
+        }
+
+        // Rôles destinataires
+        if (request.recipientRoles() != null && !request.recipientRoles().isEmpty()) {
+            message.setRecipientRoles(String.join(",", request.recipientRoles()));
+        }
+
+        // Pièces jointes
+        if (request.attachments() != null && !request.attachments().isEmpty()) {
+            message.setAttachments(String.join(",", request.attachments()));
+        }
+
+        message.setOrganisation(conversation.getOrganisation());
+
+        messageRepository.persist(message);
+
+        // Mettre à jour la conversation
+        conversation.setUpdatedAt(LocalDateTime.now());
+        conversationRepository.persist(conversation);
+
+        LOG.infof("Message %s créé avec succès", message.getId());
+        return convertToResponse(message);
+    }
+
+    /**
+     * Édite un message
+     */
+    @Transactional
+    public MessageResponse editMessage(UUID messageId, UUID senderId, String newContent) {
+        Message message = messageRepository.findById(messageId);
+        if (message == null) {
+            throw new NotFoundException("Message non trouvé");
+        }
+
+        if (!message.getSender().getId().equals(senderId)) {
+            throw new IllegalStateException("Vous ne pouvez éditer que vos propres messages");
+        }
+
+        message.setContent(newContent);
+        message.markAsEdited();
+        messageRepository.persist(message);
+
+        return convertToResponse(message);
+    }
+
+    /**
+     * Supprime un message (soft delete)
+     */
+    @Transactional
+    public void deleteMessage(UUID messageId, UUID senderId) {
+        Message message = messageRepository.findById(messageId);
+        if (message == null) {
+            throw new NotFoundException("Message non trouvé");
+        }
+
+        if (!message.getSender().getId().equals(senderId)) {
+            throw new IllegalStateException("Vous ne pouvez supprimer que vos propres messages");
+        }
+
+        message.setIsDeleted(true);
+        message.setContent("[Message supprimé]");
+        messageRepository.persist(message);
+    }
+
+    /**
+     * Convertit Message en DTO
+     */
+    private MessageResponse convertToResponse(Message m) {
+        // Parser recipient IDs
+        List<UUID> recipientIds = null;
+        if (m.getRecipientIds() != null && !m.getRecipientIds().isEmpty()) {
+            recipientIds = List.of(m.getRecipientIds().split(",")).stream()
+                .map(UUID::fromString)
+                .collect(Collectors.toList());
+        }
+
+        // Parser roles
+        List<String> roles = null;
+        if (m.getRecipientRoles() != null && !m.getRecipientRoles().isEmpty()) {
+            roles = List.of(m.getRecipientRoles().split(","));
+        }
+
+        // Parser attachments
+        List<String> attachments = null;
+        if (m.getAttachments() != null && !m.getAttachments().isEmpty()) {
+            attachments = List.of(m.getAttachments().split(","));
+        }
+
+        return MessageResponse.builder()
+            .id(m.getId())
+            .conversationId(m.getConversation().getId())
+            .senderId(m.getSender().getId())
+            .senderName(m.getSenderName())
+            .senderAvatar(m.getSenderAvatar())
+            .content(m.getContent())
+            .type(m.getType())
+            .status(m.getStatus())
+            .priority(m.getPriority())
+            .recipientIds(recipientIds)
+            .recipientRoles(roles)
+            .organisationId(m.getOrganisation() != null ? m.getOrganisation().getId() : null)
+            .createdAt(m.getDateCreation())
+            .readAt(m.getReadAt())
+            .attachments(attachments)
+            .isEdited(m.getIsEdited())
+            .editedAt(m.getEditedAt())
+            .isDeleted(m.getIsDeleted())
+            .build();
+    }
+}
--- a/src/main/java/dev/lions/unionflow/server/service/support/SecuriteHelper.java
+++ b/src/main/java/dev/lions/unionflow/server/service/support/SecuriteHelper.java
@@ -1,11 +1,16 @@
 package dev.lions.unionflow.server.service.support;

+import dev.lions.unionflow.server.entity.Membre;
+import dev.lions.unionflow.server.repository.MembreRepository;
 import io.quarkus.security.identity.SecurityIdentity;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
+import jakarta.ws.rs.NotFoundException;
 import org.eclipse.microprofile.jwt.JsonWebToken;
 import org.jboss.logging.Logger;

+import java.util.UUID;
+
 /**
 * Helper CDI partagé pour les services sécurisés.
 *
@@ -21,6 +26,9 @@ public class SecuriteHelper {
    @Inject
    SecurityIdentity securityIdentity;

+    @Inject
+    MembreRepository membreRepository;
+
    /**
     * Résout l'email du principal connecté depuis le JWT.
     *
@@ -52,6 +60,26 @@ public class SecuriteHelper {
        return (name != null && !name.isBlank()) ? name : null;
    }

+    /**
+     * Résout l'ID du membre connecté depuis le JWT.
+     *
+     * @return UUID du membre
+     * @throws NotFoundException si le membre n'existe pas
+     */
+    public UUID resolveMembreId() {
+        String email = resolveEmail();
+        if (email == null || email.isBlank()) {
+            throw new NotFoundException("Identité non disponible");
+        }
+
+        Membre membre = membreRepository.findByEmail(email.trim())
+            .or(() -> membreRepository.findByEmail(email.trim().toLowerCase()))
+            .filter(m -> m.getActif() == null || m.getActif())
+            .orElseThrow(() -> new NotFoundException("Membre non trouvé pour l'email: " + email));
+
+        return membre.getId();
+    }
+
    /**
     * Délègue la récupération des rôles à l'identité Quarkus.
     */