Implement private direct messaging between users

backend/src/main/java/com/accord/config/WebSocketConfig.java

@@ -22,8 +22,9 @@ public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
 
     @Override
     public void configureMessageBroker(MessageBrokerRegistry config) {
-        config.enableSimpleBroker("/topic");
+        config.enableSimpleBroker("/topic", "/user");
         config.setApplicationDestinationPrefixes("/app");
+        config.setUserDestinationPrefix("/user");
     }
 
     @Override

backend/src/main/java/com/accord/controller/DirectMessageController.java

@@ -0,0 +1,162 @@
+package com.accord.controller;
+
+import com.accord.model.DirectMessage;
+import com.accord.model.User;
+import com.accord.service.DirectMessageService;
+import com.accord.service.UserService;
+import com.accord.util.ValidationUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api/dm")
+@CrossOrigin(origins = "${app.cors.allowed-origins}")
+public class DirectMessageController {
+
+    private static final int MAX_LIMIT = 500;
+
+    @Value("${app.message.max-length}")
+    private int maxMessageLength;
+
+    @Autowired
+    private DirectMessageService directMessageService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private SimpMessagingTemplate messagingTemplate;
+
+    @PostMapping("/send")
+    public ResponseEntity<?> sendDirectMessage(@RequestBody Map<String, Object> payload) {
+        String senderUsername = (String) payload.get("senderUsername");
+        String recipientUsername = (String) payload.get("recipientUsername");
+        String content = (String) payload.get("content");
+
+        if (senderUsername == null || senderUsername.trim().isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Sender username is required"));
+        }
+        if (recipientUsername == null || recipientUsername.trim().isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Recipient username is required"));
+        }
+        if (!ValidationUtils.isValidContent(content, maxMessageLength)) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Invalid message content"));
+        }
+        if (senderUsername.trim().equals(recipientUsername.trim())) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Cannot send a message to yourself"));
+        }
+
+        Optional<User> sender = userService.findByUsername(senderUsername.trim());
+        Optional<User> recipient = userService.findByUsername(recipientUsername.trim());
+
+        if (sender.isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Sender not found"));
+        }
+        if (recipient.isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Recipient not found"));
+        }
+
+        DirectMessage message = directMessageService.sendMessage(
+                sender.get().getId(), recipient.get().getId(), content.trim());
+
+        // Send real-time notification to recipient via WebSocket
+        messagingTemplate.convertAndSend(
+                "/user/" + recipient.get().getId() + "/queue/messages", message);
+
+        return ResponseEntity.ok(message);
+    }
+
+    @GetMapping("/conversation")
+    public ResponseEntity<?> getConversation(
+            @RequestParam String user1,
+            @RequestParam String user2,
+            @RequestParam(defaultValue = "50") int limit) {
+
+        if (user1 == null || user1.trim().isEmpty() || user2 == null || user2.trim().isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Both usernames are required"));
+        }
+
+        Optional<User> userOne = userService.findByUsername(user1.trim());
+        Optional<User> userTwo = userService.findByUsername(user2.trim());
+
+        if (userOne.isEmpty() || userTwo.isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "User not found"));
+        }
+
+        if (limit < 1) {
+            limit = 1;
+        } else if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT;
+        }
+
+        List<DirectMessage> messages = directMessageService.getConversation(
+                userOne.get().getId(), userTwo.get().getId(), limit);
+        return ResponseEntity.ok(messages);
+    }
+
+    @PostMapping("/read/{messageId}")
+    public ResponseEntity<?> markAsRead(@PathVariable Long messageId,
+                                        @RequestParam String username) {
+        Optional<User> user = userService.findByUsername(username.trim());
+        if (user.isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "User not found"));
+        }
+
+        directMessageService.markAsRead(messageId, user.get().getId());
+        return ResponseEntity.ok(Map.of("status", "marked as read"));
+    }
+
+    @PostMapping("/read/conversation")
+    public ResponseEntity<?> markConversationAsRead(@RequestBody Map<String, String> payload) {
+        String recipientUsername = payload.get("recipientUsername");
+        String senderUsername = payload.get("senderUsername");
+
+        if (recipientUsername == null || senderUsername == null) {
+            return ResponseEntity.badRequest().body(Map.of("error", "Both usernames are required"));
+        }
+
+        Optional<User> recipient = userService.findByUsername(recipientUsername.trim());
+        Optional<User> sender = userService.findByUsername(senderUsername.trim());
+
+        if (recipient.isEmpty() || sender.isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "User not found"));
+        }
+
+        directMessageService.markConversationAsRead(recipient.get().getId(), sender.get().getId());
+        return ResponseEntity.ok(Map.of("status", "conversation marked as read"));
+    }
+
+    @GetMapping("/unread")
+    public ResponseEntity<?> getUnreadCount(@RequestParam String username) {
+        Optional<User> user = userService.findByUsername(username.trim());
+        if (user.isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "User not found"));
+        }
+
+        long count = directMessageService.getUnreadCount(user.get().getId());
+        return ResponseEntity.ok(Map.of("unreadCount", count));
+    }
+
+    @GetMapping("/unread/from")
+    public ResponseEntity<?> getUnreadCountFromSender(
+            @RequestParam String username,
+            @RequestParam String senderUsername) {
+        Optional<User> user = userService.findByUsername(username.trim());
+        Optional<User> sender = userService.findByUsername(senderUsername.trim());
+
+        if (user.isEmpty() || sender.isEmpty()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "User not found"));
+        }
+
+        long count = directMessageService.getUnreadCountFromSender(
+                user.get().getId(), sender.get().getId());
+        return ResponseEntity.ok(Map.of("unreadCount", count));
+    }
+}

backend/src/main/java/com/accord/controller/UserController.java

@@ -15,7 +15,10 @@
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * User authentication controller handling registration and login.
@@ -125,4 +128,17 @@ public ResponseEntity<Boolean> checkUsername(@PathVariable String username) {
         boolean exists = userService.userExists(username.trim());
         return ResponseEntity.ok(exists);
     }
+
+    @GetMapping
+    public ResponseEntity<?> listUsers() {
+        List<Map<String, Object>> users = userService.findAllUsers().stream()
+                .map(user -> {
+                    Map<String, Object> userMap = new HashMap<>();
+                    userMap.put("id", user.getId());
+                    userMap.put("username", user.getUsername());
+                    return userMap;
+                })
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(users);
+    }
 }

backend/src/main/java/com/accord/model/DirectMessage.java

@@ -0,0 +1,90 @@
+package com.accord.model;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "direct_messages")
+public class DirectMessage {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long senderId;
+
+    @Column(nullable = false)
+    private Long recipientId;
+
+    @Column(nullable = false, length = 1000)
+    private String content;
+
+    @Column(nullable = false)
+    private LocalDateTime timestamp;
+
+    @Column(nullable = false)
+    private boolean read;
+
+    public DirectMessage() {
+        this.timestamp = LocalDateTime.now();
+        this.read = false;
+    }
+
+    public DirectMessage(Long senderId, Long recipientId, String content) {
+        this.senderId = senderId;
+        this.recipientId = recipientId;
+        this.content = content;
+        this.timestamp = LocalDateTime.now();
+        this.read = false;
+    }
+
+    // Getters and Setters
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getSenderId() {
+        return senderId;
+    }
+
+    public void setSenderId(Long senderId) {
+        this.senderId = senderId;
+    }
+
+    public Long getRecipientId() {
+        return recipientId;
+    }
+
+    public void setRecipientId(Long recipientId) {
+        this.recipientId = recipientId;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public LocalDateTime getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(LocalDateTime timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public boolean isRead() {
+        return read;
+    }
+
+    public void setRead(boolean read) {
+        this.read = read;
+    }
+}

backend/src/main/java/com/accord/repository/DirectMessageRepository.java

@@ -0,0 +1,37 @@
+package com.accord.repository;
+
+import com.accord.model.DirectMessage;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface DirectMessageRepository extends JpaRepository<DirectMessage, Long> {
+
+    @Query("SELECT dm FROM DirectMessage dm WHERE " +
+           "(dm.senderId = :userId1 AND dm.recipientId = :userId2) OR " +
+           "(dm.senderId = :userId2 AND dm.recipientId = :userId1) " +
+           "ORDER BY dm.timestamp DESC")
+    List<DirectMessage> findConversation(@Param("userId1") Long userId1,
+                                         @Param("userId2") Long userId2,
+                                         Pageable pageable);
+
+    @Modifying
+    @Query("UPDATE DirectMessage dm SET dm.read = true WHERE dm.recipientId = :recipientId AND dm.senderId = :senderId AND dm.read = false")
+    int markConversationAsRead(@Param("recipientId") Long recipientId, @Param("senderId") Long senderId);
+
+    @Query("SELECT COUNT(dm) FROM DirectMessage dm WHERE dm.recipientId = :recipientId AND dm.senderId = :senderId AND dm.read = false")
+    long countUnreadFromSender(@Param("recipientId") Long recipientId, @Param("senderId") Long senderId);
+
+    @Query("SELECT COUNT(dm) FROM DirectMessage dm WHERE dm.recipientId = :recipientId AND dm.read = false")
+    long countUnreadForUser(@Param("recipientId") Long recipientId);
+
+    @Query("SELECT DISTINCT CASE WHEN dm.senderId = :userId THEN dm.recipientId ELSE dm.senderId END " +
+           "FROM DirectMessage dm WHERE dm.senderId = :userId OR dm.recipientId = :userId")
+    List<Long> findConversationPartnerIds(@Param("userId") Long userId);
+}

backend/src/main/java/com/accord/service/DirectMessageService.java

@@ -0,0 +1,57 @@
+package com.accord.service;
+
+import com.accord.model.DirectMessage;
+import com.accord.repository.DirectMessageRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collections;
+import java.util.List;
+
+@Service
+public class DirectMessageService {
+
+    @Autowired
+    private DirectMessageRepository directMessageRepository;
+
+    public DirectMessage sendMessage(Long senderId, Long recipientId, String content) {
+        DirectMessage message = new DirectMessage(senderId, recipientId, content);
+        return directMessageRepository.save(message);
+    }
+
+    public List<DirectMessage> getConversation(Long userId1, Long userId2, int limit) {
+        Pageable pageable = PageRequest.of(0, limit);
+        List<DirectMessage> messages = directMessageRepository.findConversation(userId1, userId2, pageable);
+        Collections.reverse(messages); // Show oldest first
+        return messages;
+    }
+
+    public void markAsRead(Long messageId, Long recipientId) {
+        directMessageRepository.findById(messageId).ifPresent(message -> {
+            if (message.getRecipientId().equals(recipientId)) {
+                message.setRead(true);
+                directMessageRepository.save(message);
+            }
+        });
+    }
+
+    @Transactional
+    public void markConversationAsRead(Long recipientId, Long senderId) {
+        directMessageRepository.markConversationAsRead(recipientId, senderId);
+    }
+
+    public long getUnreadCount(Long recipientId) {
+        return directMessageRepository.countUnreadForUser(recipientId);
+    }
+
+    public long getUnreadCountFromSender(Long recipientId, Long senderId) {
+        return directMessageRepository.countUnreadFromSender(recipientId, senderId);
+    }
+
+    public List<Long> getConversationPartnerIds(Long userId) {
+        return directMessageRepository.findConversationPartnerIds(userId);
+    }
+}

backend/src/main/java/com/accord/service/UserService.java

@@ -48,4 +48,8 @@ public Optional<User> findByUsername(String username) {
     public boolean verifyPassword(String rawPassword, String encodedPassword) {
         return passwordEncoder.matches(rawPassword, encodedPassword);
     }
+
+    public java.util.List<User> findAllUsers() {
+        return userRepository.findAll();
+    }
 }