[FEAT] 채팅 관련 REST API 구현

build.gradle

@@ -74,6 +74,13 @@ dependencies {
     // HTML -> PDF (OpenHTMLToPDF)
     implementation 'com.openhtmltopdf:openhtmltopdf-pdfbox:1.0.10'
     implementation 'com.openhtmltopdf:openhtmltopdf-slf4j:1.0.10'
+
+	// MongoDB
+	implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
+
+	// STOMP
+	implementation 'org.springframework.boot:spring-boot-starter-websocket'
+//	implementation 'org.springframework.boot:spring-boot-starter-messaging'
 }
 
 tasks.named('test') {

src/main/java/konkuk/chacall/domain/chat/application/ChatService.java

@@ -1,4 +1,71 @@
 package konkuk.chacall.domain.chat.application;
 
+import konkuk.chacall.domain.chat.application.message.ChatMessageService;
+import konkuk.chacall.domain.chat.application.room.ChatRoomService;
+import konkuk.chacall.domain.chat.presentation.dto.request.GetChatRoomRequest;
+import konkuk.chacall.domain.chat.presentation.dto.request.SendChatMessageRequest;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatMessageResponse;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatRoomMetaDataResponse;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatRoomIdResponse;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatRoomResponse;
+import konkuk.chacall.domain.member.application.validator.MemberValidator;
+import konkuk.chacall.domain.user.domain.model.User;
+import konkuk.chacall.global.common.dto.CursorPagingRequest;
+import konkuk.chacall.global.common.dto.CursorPagingResponse;
+import konkuk.chacall.global.common.dto.SortType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
 public class ChatService {
+
+    private final ChatRoomService chatRoomService;
+    private final ChatMessageService chatMessageService;
+
+    private final MemberValidator memberValidator;
+
+    @Transactional
+    public ChatRoomIdResponse createChatRoom(Long memberId, Long foodTruckId) {
+        User member = memberValidator.validateAndGetMember(memberId);
+
+        return chatRoomService.createChatRoom(member, foodTruckId);
+    }
+
+    public ChatRoomMetaDataResponse getChatRoomMetaData(Long memberId, Long roomId, boolean isOwner) {
+        User user = memberValidator.validateAndGetMember(memberId);
+
+        return chatRoomService.getChatRoomMetaData(user, roomId, isOwner);
+    }
+
+    @Transactional
+    public ChatMessageResponse sendMessage(Long roomId, Long userId, SendChatMessageRequest request) {
+        User senderUser = memberValidator.validateAndGetMember(userId);
+
+        return chatMessageService.sendMessage(roomId, senderUser, request);
+    }
+
+    public List<ChatMessageResponse> getChatMessages(Long memberId, Long roomId, int page, int size) {
+        User user = memberValidator.validateAndGetMember(memberId);
+
+        return chatMessageService.getChatMessages(roomId, user, page, size);
+    }
+
+    public CursorPagingResponse<ChatRoomResponse> getChatRooms(Long memberId, GetChatRoomRequest request) {
+        User member = memberValidator.validateAndGetMember(memberId);
+
+        CursorPagingRequest cursorPagingRequest = request.pagingOrDefault(SortType.NEWEST);
+        return chatRoomService.getChatRooms(member, request.isOwner(), cursorPagingRequest.cursor(), cursorPagingRequest.size());
+    }
+
+    @Transactional
+    public void markMessagesAsRead(Long userId, Long roomId) {
+        User user = memberValidator.validateAndGetMember(userId);
+
+        chatMessageService.markMessagesAsRead(user, roomId);
+    }
 }

src/main/java/konkuk/chacall/domain/chat/application/message/ChatMessageService.java

@@ -0,0 +1,70 @@
+package konkuk.chacall.domain.chat.application.message;
+
+import konkuk.chacall.domain.chat.domain.ChatMessage;
+import konkuk.chacall.domain.chat.domain.ChatRoomMetaData;
+import konkuk.chacall.domain.chat.domain.repository.ChatMessageRepository;
+import konkuk.chacall.domain.chat.domain.repository.ChatRoomMetaDataRepository;
+import konkuk.chacall.domain.chat.presentation.dto.request.SendChatMessageRequest;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatMessageResponse;
+import konkuk.chacall.domain.user.domain.model.User;
+import konkuk.chacall.global.common.exception.EntityNotFoundException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+import static konkuk.chacall.global.common.exception.code.ErrorCode.*;
+
+@Service
+@RequiredArgsConstructor
+public class ChatMessageService {
+
+    private final ChatMessageRepository chatMessageRepository;
+    private final ChatRoomMetaDataRepository chatRoomMetaDataRepository;
+
+    public ChatMessageResponse sendMessage(Long roomId, User senderUser, SendChatMessageRequest request) {
+
+        ChatRoomMetaData chatRoomMetaData = chatRoomMetaDataRepository.findByRoomId(roomId)
+                .orElseThrow(() -> new EntityNotFoundException(CHAT_ROOM_NOT_FOUND));
+
+        chatRoomMetaData.validateParticipant(senderUser);
+
+        ChatMessage chatMessage = ChatMessage.createChatMessage(
+                chatRoomMetaData.getRoomId(),
+                senderUser,
+                request.content(),
+                request.contentType()
+        );
+
+        ChatMessage savedMessage = chatMessageRepository.save(chatMessage);
+        chatRoomMetaData.updateLastMessage(savedMessage.getContent(), savedMessage.getSendTime());
+        chatRoomMetaDataRepository.save(chatRoomMetaData);
+
+        return ChatMessageResponse.from(savedMessage);
+    }
+
+    public List<ChatMessageResponse> getChatMessages(Long roomId, User user, int page, int size) {
+        ChatRoomMetaData chatRoomMetaData = chatRoomMetaDataRepository.findByRoomId(roomId)
+                .orElseThrow(() -> new EntityNotFoundException(CHAT_ROOM_NOT_FOUND));
+
+        chatRoomMetaData.validateParticipant(user);
+
+        var pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "sendTime"));
+
+        return chatMessageRepository.findByRoomId(chatRoomMetaData.getRoomId(), pageable)
+                .stream()
+                .map(ChatMessageResponse::from)
+                .toList();
+    }
+
+    public void markMessagesAsRead(User user, Long roomId) {
+        ChatRoomMetaData chatRoomMetaData = chatRoomMetaDataRepository.findByRoomId(roomId)
+                .orElseThrow(() -> new EntityNotFoundException(CHAT_ROOM_NOT_FOUND));
+
+        chatRoomMetaData.validateParticipant(user);
+
+        chatMessageRepository.markMessagesAsReadByUserInRoom(user.getUserId(), roomId);
+    }
+}

src/main/java/konkuk/chacall/domain/chat/application/room/ChatRoomService.java

@@ -0,0 +1,133 @@
+package konkuk.chacall.domain.chat.application.room;
+
+import konkuk.chacall.domain.chat.domain.ChatRoom;
+import konkuk.chacall.domain.chat.domain.ChatRoomMetaData;
+import konkuk.chacall.domain.chat.domain.repository.ChatRoomMetaDataRepository;
+import konkuk.chacall.domain.chat.domain.repository.ChatRoomRepository;
+import konkuk.chacall.domain.chat.domain.repository.dto.ChatRoomMetaDataProjection;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatRoomMetaDataResponse;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatRoomIdResponse;
+import konkuk.chacall.domain.chat.presentation.dto.response.ChatRoomResponse;
+import konkuk.chacall.domain.foodtruck.domain.model.FoodTruck;
+import konkuk.chacall.domain.foodtruck.domain.repository.FoodTruckRepository;
+import konkuk.chacall.domain.reservation.domain.model.Reservation;
+import konkuk.chacall.domain.reservation.domain.repository.ReservationRepository;
+import konkuk.chacall.domain.reservation.domain.repository.dto.ReservationConfirmedProjection;
+import konkuk.chacall.domain.user.domain.model.Role;
+import konkuk.chacall.domain.user.domain.model.User;
+import konkuk.chacall.global.common.dto.CursorPagingResponse;
+import konkuk.chacall.global.common.exception.BusinessException;
+import konkuk.chacall.global.common.exception.EntityNotFoundException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static konkuk.chacall.global.common.exception.code.ErrorCode.*;
+
+@Service
+@RequiredArgsConstructor
+public class ChatRoomService {
+
+    private final ChatRoomRepository chatRoomRepository;
+    private final FoodTruckRepository foodTruckRepository;
+    private final ChatRoomMetaDataRepository chatRoomMetaDataRepository;
+    private final ReservationRepository reservationRepository;
+
+    public ChatRoomIdResponse createChatRoom(User member, Long foodTruckId) {
+        FoodTruck foodTruck = foodTruckRepository.findById(foodTruckId)
+                .orElseThrow(() -> new EntityNotFoundException(FOOD_TRUCK_NOT_FOUND));
+
+        // 채팅방이 이미 존재하는지 확인
+        ChatRoom chatRoom = chatRoomRepository.findByMemberAndFoodTruck(member, foodTruck)
+                .orElseGet(() -> chatRoomRepository.save(ChatRoom.createChatRoom(member, foodTruck)));
+
+        // MongoDB 메타데이터 존재 여부 확인
+        chatRoomMetaDataRepository.findByRoomId(chatRoom.getChatRoomId())
+                .orElseGet(() -> {
+                    // 없을 경우 새로 생성
+                    ChatRoomMetaData metaData = ChatRoomMetaData.from(chatRoom);
+                    return chatRoomMetaDataRepository.save(metaData);
+                });
+
+        return ChatRoomIdResponse.of(chatRoom);
+    }
+
+    public ChatRoomMetaDataResponse getChatRoomMetaData(User user, Long roomId, boolean isOwner) {
+        ChatRoom chatRoom = chatRoomRepository.findById(roomId)
+                .orElseThrow(() -> new EntityNotFoundException(CHAT_ROOM_NOT_FOUND));
+
+        Long reservationId = reservationRepository.findByChatRoom(chatRoom)
+                .map(Reservation::getReservationId)
+                .orElse(null);             // 없으면 null
+
+        if(isOwner && user.getRole() != Role.OWNER) {
+            throw new BusinessException(USER_FORBIDDEN);
+        }
+
+        // 푸드트럭 사장일 경우 예약자 이름 반환
+        if(isOwner) return ChatRoomMetaDataResponse.of(chatRoom.getMember().getName(), null, reservationId);
+
+        // 예약자일 경우 푸드트럭 사장 이름 및 푸드트럭 이름 반환
+        FoodTruck foodTruck = chatRoom.getFoodTruck();
+        return ChatRoomMetaDataResponse.of(foodTruck.getOwner().getName(), foodTruck.getFoodTruckInfo().getName(), reservationId);
+    }
+
+    public CursorPagingResponse<ChatRoomResponse> getChatRooms(User member, Boolean isOwner, Long cursor, Integer size) {
+        int pageSize = (size == null || size < 1) ? 20 : size;
+
+        Long cursorSortKey = (cursor != null) ? cursor : Long.MAX_VALUE;
+        int limit = pageSize + 1;
+
+        // 1. MongoDB에서 메타데이터 + unreadCount 조회
+        List<ChatRoomMetaDataProjection> metaList =
+                chatRoomMetaDataRepository.findChatRoomsForUser(member.getUserId(), isOwner, cursorSortKey, limit);
+
+        boolean hasNext = metaList.size() > pageSize;
+        if (hasNext) {
+            metaList = metaList.subList(0, pageSize);
+        }
+
+        // 2. roomId 리스트로 RDB에서 ChatRoom 배치 조회
+        List<Long> roomIds = metaList.stream()
+                .map(ChatRoomMetaDataProjection::getRoomId)
+                .toList();
+
+        List<ChatRoom> chatRooms = chatRoomRepository.findByChatRoomIdIn(roomIds);
+        Map<Long, ChatRoom> chatRoomMap = chatRooms.stream()
+                .collect(Collectors.toMap(ChatRoom::getChatRoomId, Function.identity()));
+
+        // 3. 예약 확정 여부 조회
+        Map<Long, Boolean> reservationConfirmedMap;
+        if (roomIds.isEmpty()) {
+            reservationConfirmedMap = Collections.emptyMap();
+        } else {
+            List<ReservationConfirmedProjection> confirmedList = reservationRepository.findReservationConfirmedByChatRoomIds(roomIds);
+
+            reservationConfirmedMap = confirmedList.stream()
+                    .collect(Collectors.toMap(
+                            ReservationConfirmedProjection::getRoomId,
+                            ReservationConfirmedProjection::getConfirmed
+                    ));
+        }
+
+        // 4. 메타데이터 + RDB 정보 조합해서 ChatRoomResponse 생성
+        List<ChatRoomResponse> responses = metaList.stream()
+                .map(meta -> ChatRoomResponse.from(chatRoomMap.get(meta.getRoomId()), meta, isOwner,
+                        reservationConfirmedMap.getOrDefault(meta.getRoomId(), false)))
+                .toList();
+
+        // 5. CursorPagingResponse 생성
+        Long lastCursor = responses.isEmpty() ? null : metaList.get(metaList.size() - 1).getSortKey();
+        return new CursorPagingResponse<>(
+                responses,
+                lastCursor,
+                hasNext,
+                null
+        );
+    }
+}

src/main/java/konkuk/chacall/domain/chat/domain/ChatMessage.java

@@ -1,43 +1,45 @@
 package konkuk.chacall.domain.chat.domain;
 
-import jakarta.persistence.*;
 import konkuk.chacall.domain.chat.domain.value.MessageContentType;
 import konkuk.chacall.domain.user.domain.model.User;
-import konkuk.chacall.global.common.domain.BaseEntity;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
+import lombok.*;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.index.CompoundIndex;
+import org.springframework.data.mongodb.core.mapping.Document;
 
 import java.time.LocalDateTime;
 
-@Entity
-@Table(name = "chat_messages")
+@Getter
+@Document(collection = "chat_messages")
+@CompoundIndex(
+        name = "room_sender_read_time_idx",
+        def = "{'roomId': 1, 'senderId': 1, 'read': 1, 'sendTime': 1}"
+)
+@Builder
+@AllArgsConstructor
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
-public class ChatMessage extends BaseEntity {
+public class ChatMessage {
 
     @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(nullable = false)
-    private Long chatMessageId;
+    private String id;
 
-    @Column(name = "content", nullable = false, length = 1000)
+    private Long roomId;
+    private Long senderId;
     private String content;
-
-    @Column(nullable = false)
-    private LocalDateTime sendTime;
-
-    @Column(name = "is_read", nullable = false)
-    private boolean isRead;
-
-    @ManyToOne(fetch = FetchType.LAZY, optional = false)
-    @JoinColumn(name = "chat_room_id", nullable = false)
-    private ChatRoom chatRoom;
-
-    @ManyToOne(fetch = FetchType.LAZY, optional = false)
-    @JoinColumn(name = "user_id", nullable = false)
-    private User senderUser;
-
-    @Enumerated(EnumType.STRING)
-    @Column(nullable = false, length = 20)
-    private MessageContentType contentType;
-
+    private String contentType;
+
+    @Builder.Default
+    private LocalDateTime sendTime = LocalDateTime.now();
+
+    @Builder.Default
+    private boolean read = false;
+
+    public static ChatMessage createChatMessage(Long roomId, User sender, String content, MessageContentType contentType) {
+        return ChatMessage.builder()
+                .roomId(roomId)
+                .senderId(sender.getUserId())
+                .content(content)
+                .contentType(contentType.name())
+                .build();
+    }
 }