채팅방 생성 api 추가

backend/ddang/src/main/java/com/ddang/ddang/auction/domain/Auction.java

@@ -31,6 +31,7 @@
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 @Entity
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
@@ -147,4 +148,21 @@ private BidPrice calculateNextMinimumBidPrice() {
         final int nextMinimumBidPrice = this.lastBid.getPrice().getValue() + this.bidUnit.getValue();
         return new BidPrice(nextMinimumBidPrice);
     }
+
+    public boolean isWinner(final User user, final LocalDateTime targetTime) {
+        return findWinner(targetTime).filter(user::equals)
+                                     .isPresent();
+    }
+
+    public Optional<User> findWinner(final LocalDateTime targetTime) {
+        if (isWinnerExist(targetTime)) {
+            return Optional.of(lastBid.getBidder());
+        }
+
+        return Optional.empty();
+    }
+
+    private boolean isWinnerExist(final LocalDateTime targetTime) {
+        return auctioneerCount != 0 && isClosed(targetTime);
+    }
 }

backend/ddang/src/main/java/com/ddang/ddang/auction/domain/exception/WinnerNotFoundException.java

@@ -0,0 +1,8 @@
+package com.ddang.ddang.auction.domain.exception;
+
+public class WinnerNotFoundException extends IllegalArgumentException {
+
+    public WinnerNotFoundException(final String message) {
+        super(message);
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/chat/application/ChatRoomService.java

@@ -1,7 +1,13 @@
 package com.ddang.ddang.chat.application;
 
+import com.ddang.ddang.auction.application.exception.AuctionNotFoundException;
+import com.ddang.ddang.auction.domain.Auction;
+import com.ddang.ddang.auction.domain.exception.WinnerNotFoundException;
+import com.ddang.ddang.auction.infrastructure.persistence.JpaAuctionRepository;
+import com.ddang.ddang.chat.application.dto.CreateChatRoomDto;
 import com.ddang.ddang.chat.application.dto.ReadParticipatingChatRoomDto;
 import com.ddang.ddang.chat.application.exception.ChatRoomNotFoundException;
+import com.ddang.ddang.chat.application.exception.InvalidAuctionToChatException;
 import com.ddang.ddang.chat.application.exception.UserNotAccessibleException;
 import com.ddang.ddang.chat.domain.ChatRoom;
 import com.ddang.ddang.chat.infrastructure.persistence.JpaChatRoomRepository;
@@ -22,23 +28,69 @@ public class ChatRoomService {
 
     private final JpaChatRoomRepository chatRoomRepository;
     private final JpaUserRepository userRepository;
+    private final JpaAuctionRepository auctionRepository;
+
+    @Transactional
+    public Long create(final Long userId, final CreateChatRoomDto chatRoomDto) {
+        final User findUser = userRepository.findById(userId)
+                                            .orElseThrow(() -> new UserNotFoundException("사용자 정보를 찾을 수 없습니다."));
+        final Auction findAuction = auctionRepository.findById(chatRoomDto.auctionId())
+                                                     .orElseThrow(() ->
+                                                             new AuctionNotFoundException("해당 경매를 찾을 수 없습니다."));
+
+        final ChatRoom persistChatRoom = findOrCreateChatRoomByAuction(findUser, findAuction);
+
+        return persistChatRoom.getId();
+    }
+
+    private ChatRoom findOrCreateChatRoomByAuction(final User user, final Auction auction) {
+        return chatRoomRepository.findByAuctionId(auction.getId())
+                                 .orElseGet(() -> createAndSaveChatRoom(user, auction));
+    }
+
+    private ChatRoom createAndSaveChatRoom(final User user, final Auction auction) {
+        checkAuctionStatus(auction);
+        final User winner = auction.findWinner(LocalDateTime.now())
+                                   .orElseThrow(() -> new WinnerNotFoundException("낙찰자가 존재하지 않습니다"));
+        checkUserCanParticipate(user, auction);
+
+        final ChatRoom chatRoom = new ChatRoom(auction, winner);
+
+        return chatRoomRepository.save(chatRoom);
+    }
+
+    private void checkAuctionStatus(final Auction findAuction) {
+        if (!findAuction.isClosed(LocalDateTime.now())) {
+            throw new InvalidAuctionToChatException("경매가 아직 종료되지 않았습니다.");
+        }
+        if (findAuction.isDeleted()) {
+            throw new InvalidAuctionToChatException("삭제된 경매입니다.");
+        }
+    }
+
+    private void checkUserCanParticipate(final User findUser, final Auction findAuction) {
+        if (!isSellerOrWinner(findUser, findAuction)) {
+            throw new UserNotAccessibleException("경매의 판매자 또는 최종 낙찰자만 채팅이 가능합니다.");
+        }
+    }
+
+    private boolean isSellerOrWinner(final User findUser, final Auction findAuction) {
+        return findAuction.isOwner(findUser) || findAuction.isWinner(findUser, LocalDateTime.now());
+    }
 
     public List<ReadParticipatingChatRoomDto> readAllByUserId(final Long userId) {
-        final User findUser = findUser(userId);
+        final User findUser = userRepository.findById(userId)
+                                            .orElseThrow(() -> new UserNotFoundException("사용자 정보를 찾을 수 없습니다."));
         final List<ChatRoom> chatRooms = chatRoomRepository.findAllByUserId(findUser.getId());
 
         return chatRooms.stream()
-                        .map(chatRoom -> toDto(findUser, chatRoom))
+                        .map(chatRoom -> ReadParticipatingChatRoomDto.of(findUser, chatRoom, LocalDateTime.now()))
                         .toList();
     }
 
-    private User findUser(final Long userId) {
-        return userRepository.findById(userId)
-                             .orElseThrow(() -> new UserNotFoundException("사용자 정보를 찾을 수 없습니다."));
-    }
-
     public ReadParticipatingChatRoomDto readByChatRoomId(final Long chatRoomId, final Long userId) {
-        final User findUser = findUser(userId);
+        final User findUser = userRepository.findById(userId)
+                                            .orElseThrow(() -> new UserNotFoundException("사용자 정보를 찾을 수 없습니다."));
         final ChatRoom chatRoom = chatRoomRepository.findById(chatRoomId)
                                                     .orElseThrow(() ->
                                                             new ChatRoomNotFoundException(
@@ -47,19 +99,12 @@ public ReadParticipatingChatRoomDto readByChatRoomId(final Long chatRoomId, fina
                                                     );
         checkAccessible(findUser, chatRoom);
 
-        return toDto(findUser, chatRoom);
+        return ReadParticipatingChatRoomDto.of(findUser, chatRoom, LocalDateTime.now());
     }
 
     private void checkAccessible(final User findUser, final ChatRoom chatRoom) {
         if (!chatRoom.isParticipant(findUser)) {
             throw new UserNotAccessibleException("해당 채팅방에 접근할 권한이 없습니다.");
         }
     }
-
-    private ReadParticipatingChatRoomDto toDto(final User findUser, final ChatRoom chatRoom) {
-        return ReadParticipatingChatRoomDto.of(
-                chatRoom.calculateChatPartnerOf(findUser),
-                chatRoom,
-                chatRoom.isChatAvailableTime(LocalDateTime.now()));
-    }
 }

backend/ddang/src/main/java/com/ddang/ddang/chat/application/dto/CreateChatRoomDto.java

@@ -0,0 +1,10 @@
+package com.ddang.ddang.chat.application.dto;
+
+import com.ddang.ddang.chat.presentation.dto.request.CreateChatRoomRequest;
+
+public record CreateChatRoomDto(Long auctionId) {
+
+    public static CreateChatRoomDto from(final CreateChatRoomRequest chatRoomRequest) {
+        return new CreateChatRoomDto(chatRoomRequest.auctionId());
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/chat/application/dto/ReadParticipatingChatRoomDto.java

@@ -3,6 +3,8 @@
 import com.ddang.ddang.chat.domain.ChatRoom;
 import com.ddang.ddang.user.domain.User;
 
+import java.time.LocalDateTime;
+
 public record ReadParticipatingChatRoomDto(
         Long id,
         ReadAuctionDto auctionDto,
@@ -11,15 +13,17 @@ public record ReadParticipatingChatRoomDto(
 ) {
 
     public static ReadParticipatingChatRoomDto of(
-            final User partner,
+            final User findUser,
             final ChatRoom chatRoom,
-            final boolean isChatAvailable
+            final LocalDateTime targetTime
     ) {
+        final User partner = chatRoom.calculateChatPartnerOf(findUser);
+
         return new ReadParticipatingChatRoomDto(
                 chatRoom.getId(),
                 ReadAuctionDto.from(chatRoom.getAuction()),
                 ReadUserDto.from(partner),
-                isChatAvailable
+                chatRoom.isChatAvailableTime(targetTime)
         );
     }
 }

backend/ddang/src/main/java/com/ddang/ddang/chat/application/exception/InvalidAuctionToChatException.java

@@ -0,0 +1,8 @@
+package com.ddang.ddang.chat.application.exception;
+
+public class InvalidAuctionToChatException extends IllegalArgumentException {
+
+    public InvalidAuctionToChatException(final String message) {
+        super(message);
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/chat/infrastructure/persistence/JpaChatRoomRepository.java

@@ -2,12 +2,8 @@
 
 import com.ddang.ddang.chat.domain.ChatRoom;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
 
-import java.util.List;
+public interface JpaChatRoomRepository extends JpaRepository<ChatRoom, Long>, QuerydslChatRoomRepository {
 
-public interface JpaChatRoomRepository extends JpaRepository<ChatRoom, Long> {
-
-    @Query("select c from ChatRoom c where c.auction.seller.id = :userId or c.buyer.id = :userId")
-    List<ChatRoom> findAllByUserId(final Long userId);
+    boolean existsByAuctionId(final Long auctionId);
 }

backend/ddang/src/main/java/com/ddang/ddang/chat/infrastructure/persistence/QuerydslChatRoomRepository.java

@@ -0,0 +1,13 @@
+package com.ddang.ddang.chat.infrastructure.persistence;
+
+import com.ddang.ddang.chat.domain.ChatRoom;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface QuerydslChatRoomRepository {
+
+    List<ChatRoom> findAllByUserId(final Long userId);
+
+    Optional<ChatRoom> findByAuctionId(final Long auctionId);
+}

backend/ddang/src/main/java/com/ddang/ddang/chat/infrastructure/persistence/QuerydslChatRoomRepositoryImpl.java

@@ -0,0 +1,44 @@
+package com.ddang.ddang.chat.infrastructure.persistence;
+
+import com.ddang.ddang.chat.domain.ChatRoom;
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+import static com.ddang.ddang.auction.domain.QAuction.auction;
+import static com.ddang.ddang.chat.domain.QChatRoom.chatRoom;
+
+@Repository
+@RequiredArgsConstructor
+public class QuerydslChatRoomRepositoryImpl implements QuerydslChatRoomRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public List<ChatRoom> findAllByUserId(final Long userId) {
+        return queryFactory.selectFrom(chatRoom)
+                           .leftJoin(chatRoom.auction, auction).fetchJoin()
+                           .where(isSellerOrWinner(userId))
+                           .orderBy(chatRoom.id.desc())
+                           .fetch();
+    }
+
+    private BooleanExpression isSellerOrWinner(final Long userId) {
+        return (auction.seller.id.eq(userId))
+                .or(chatRoom.buyer.id.eq(userId));
+    }
+
+    @Override
+    public Optional<ChatRoom> findByAuctionId(final Long auctionId) {
+        final ChatRoom findChatRoom = queryFactory.selectFrom(chatRoom)
+                                                  .leftJoin(chatRoom.auction, auction).fetchJoin()
+                                                  .where(auction.id.eq(auctionId))
+                                                  .fetchOne();
+
+        return Optional.ofNullable(findChatRoom);
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/chat/presentation/ChatRoomController.java

@@ -2,10 +2,12 @@
 
 import com.ddang.ddang.chat.application.ChatRoomService;
 import com.ddang.ddang.chat.application.MessageService;
+import com.ddang.ddang.chat.application.dto.CreateChatRoomDto;
 import com.ddang.ddang.chat.application.dto.CreateMessageDto;
 import com.ddang.ddang.chat.application.dto.ReadParticipatingChatRoomDto;
 import com.ddang.ddang.chat.presentation.auth.AuthenticateUser;
 import com.ddang.ddang.chat.presentation.auth.AuthenticateUserInfo;
+import com.ddang.ddang.chat.presentation.dto.request.CreateChatRoomRequest;
 import com.ddang.ddang.chat.presentation.dto.request.CreateMessageRequest;
 import com.ddang.ddang.chat.presentation.dto.response.CreateMessageResponse;
 import com.ddang.ddang.chat.presentation.dto.response.ReadChatRoomResponse;
@@ -33,6 +35,17 @@ public class ChatRoomController {
     private final ChatRoomService chatRoomService;
     private final MessageService messageService;
 
+    @PostMapping
+    public ResponseEntity<Void> create(
+            @AuthenticateUser final AuthenticateUserInfo userInfo,
+            @RequestBody @Valid final CreateChatRoomRequest chatRoomRequest
+    ) {
+        final Long chatRoomId = chatRoomService.create(userInfo.id(), CreateChatRoomDto.from(chatRoomRequest));
+
+        return ResponseEntity.created(URI.create("/chattings/" + chatRoomId))
+                             .build();
+    }
+
     @GetMapping
     public ResponseEntity<List<ReadChatRoomResponse>> readAllParticipatingChatRooms(
             @AuthenticateUser final AuthenticateUserInfo userInfo

backend/ddang/src/main/java/com/ddang/ddang/chat/presentation/dto/request/CreateChatRoomRequest.java

@@ -0,0 +1,11 @@
+package com.ddang.ddang.chat.presentation.dto.request;
+
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
+
+public record CreateChatRoomRequest(
+        @NotNull(message = "경매 아이디가 입력되지 않았습니다.")
+        @Positive(message = "경매 아이디는 양수입니다.")
+        Long auctionId
+) {
+}

backend/ddang/src/main/java/com/ddang/ddang/exception/GlobalExceptionHandler.java

@@ -3,14 +3,15 @@
 import com.ddang.ddang.auction.application.exception.AuctionNotFoundException;
 import com.ddang.ddang.auction.application.exception.UserForbiddenException;
 import com.ddang.ddang.auction.domain.exception.InvalidPriceValueException;
+import com.ddang.ddang.auction.domain.exception.WinnerNotFoundException;
 import com.ddang.ddang.authentication.configuration.exception.UserUnauthorizedException;
 import com.ddang.ddang.authentication.domain.exception.InvalidTokenException;
 import com.ddang.ddang.authentication.domain.exception.UnsupportedSocialLoginException;
 import com.ddang.ddang.bid.application.exception.InvalidBidException;
 import com.ddang.ddang.category.application.exception.CategoryNotFoundException;
 import com.ddang.ddang.chat.application.exception.ChatRoomNotFoundException;
+import com.ddang.ddang.chat.application.exception.InvalidAuctionToChatException;
 import com.ddang.ddang.chat.application.exception.UserNotAccessibleException;
-import com.ddang.ddang.user.application.exception.UserNotFoundException;
 import com.ddang.ddang.exception.dto.ExceptionResponse;
 import com.ddang.ddang.image.application.exception.ImageNotFoundException;
 import com.ddang.ddang.image.infrastructure.local.exception.EmptyImageException;
@@ -20,8 +21,7 @@
 import com.ddang.ddang.report.application.exception.AlreadyReportAuctionException;
 import com.ddang.ddang.report.application.exception.InvalidReportAuctionException;
 import com.ddang.ddang.report.application.exception.InvalidReporterToAuctionException;
-import java.net.MalformedURLException;
-import java.util.stream.Collectors;
+import com.ddang.ddang.user.application.exception.UserNotFoundException;
 import org.springframework.context.support.DefaultMessageSourceResolvable;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
@@ -33,6 +33,9 @@
 import org.springframework.web.context.request.WebRequest;
 import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
 
+import java.net.MalformedURLException;
+import java.util.stream.Collectors;
+
 @RestControllerAdvice
 public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 
@@ -139,8 +142,7 @@ public ResponseEntity<ExceptionResponse> handleStoreImageFailureException(
     }
 
     @ExceptionHandler(UnsupportedImageFileExtensionException.class)
-    public ResponseEntity<ExceptionResponse> handleUnsupportedImageFileExtensionException(
-            final UnsupportedImageFileExtensionException ex) {
+    public ResponseEntity<ExceptionResponse> handleUnsupportedImageFileExtensionException(final UnsupportedImageFileExtensionException ex) {
         logger.warn(String.format(EXCEPTION_FORMAT, UnsupportedImageFileExtensionException.class), ex);
 
         return ResponseEntity.status(HttpStatus.BAD_REQUEST)
@@ -173,6 +175,26 @@ public ResponseEntity<ExceptionResponse> handleUserNotAccessibleException(
                              .body(new ExceptionResponse(ex.getMessage()));
     }
 
+    @ExceptionHandler(WinnerNotFoundException.class)
+    public ResponseEntity<ExceptionResponse> handleWinnerNotFoundException(
+            final WinnerNotFoundException ex
+    ) {
+        logger.warn(String.format(EXCEPTION_FORMAT, WinnerNotFoundException.class), ex);
+
+        return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
+    @ExceptionHandler(InvalidAuctionToChatException.class)
+    public ResponseEntity<ExceptionResponse> handleInvalidAuctionToChatException(
+            final InvalidAuctionToChatException ex
+    ) {
+        logger.warn(String.format(EXCEPTION_FORMAT, InvalidAuctionToChatException.class), ex);
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
     @ExceptionHandler(InvalidReporterToAuctionException.class)
     public ResponseEntity<ExceptionResponse> handleInvalidReporterToAuctionException(final InvalidReporterToAuctionException ex) {
         logger.warn(String.format(EXCEPTION_FORMAT, InvalidReporterToAuctionException.class), ex);