Q&A 기능 추가

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

@@ -23,6 +23,10 @@
 import com.ddang.ddang.image.infrastructure.local.exception.StoreImageFailureException;
 import com.ddang.ddang.image.infrastructure.local.exception.UnsupportedImageFileExtensionException;
 import com.ddang.ddang.notification.application.exception.NotificationFailedException;
+import com.ddang.ddang.questionandanswer.application.exception.AlreadyAnsweredException;
+import com.ddang.ddang.questionandanswer.application.exception.InvalidAnswererException;
+import com.ddang.ddang.questionandanswer.application.exception.InvalidAuctionToAskQuestionException;
+import com.ddang.ddang.questionandanswer.application.exception.InvalidQuestionerException;
 import com.ddang.ddang.region.application.exception.RegionNotFoundException;
 import com.ddang.ddang.report.application.exception.AlreadyReportAuctionException;
 import com.ddang.ddang.report.application.exception.AlreadyReportChatRoomException;
@@ -325,6 +329,38 @@ public ResponseEntity<ExceptionResponse> handleDeviceTokenNotFoundException(fina
                              .body(new ExceptionResponse(ex.getMessage()));
     }
 
+    @ExceptionHandler(InvalidAuctionToAskQuestionException.class)
+    public ResponseEntity<ExceptionResponse> handleInvalidAuctionToAskQuestionException(final InvalidAuctionToAskQuestionException ex) {
+        logger.warn(String.format(EXCEPTION_FORMAT, InvalidAuctionToAskQuestionException.class), ex);
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
+    @ExceptionHandler(InvalidQuestionerException.class)
+    public ResponseEntity<ExceptionResponse> handleInvalidQuestionerException(final InvalidQuestionerException ex) {
+        logger.warn(String.format(EXCEPTION_FORMAT, InvalidQuestionerException.class), ex);
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
+    @ExceptionHandler(InvalidAnswererException.class)
+    public ResponseEntity<ExceptionResponse> handleInvalidAnswererException(final InvalidAnswererException ex) {
+        logger.warn(String.format(EXCEPTION_FORMAT, InvalidAnswererException.class), ex);
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
+    @ExceptionHandler(AlreadyAnsweredException.class)
+    public ResponseEntity<ExceptionResponse> handleAlreadyAnsweredException(final AlreadyAnsweredException ex) {
+        logger.warn(String.format(EXCEPTION_FORMAT, AlreadyAnsweredException.class), ex);
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
     @Override
     protected ResponseEntity<Object> handleMethodArgumentNotValid(
             final MethodArgumentNotValidException ex,

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/AnswerService.java

@@ -0,0 +1,58 @@
+package com.ddang.ddang.questionandanswer.application;
+
+import com.ddang.ddang.auction.application.exception.AuctionNotFoundException;
+import com.ddang.ddang.questionandanswer.application.dto.CreateAnswerDto;
+import com.ddang.ddang.questionandanswer.application.exception.AlreadyAnsweredException;
+import com.ddang.ddang.questionandanswer.application.exception.InvalidAnswererException;
+import com.ddang.ddang.questionandanswer.domain.Answer;
+import com.ddang.ddang.questionandanswer.domain.Question;
+import com.ddang.ddang.questionandanswer.infrastructure.JpaAnswerRepository;
+import com.ddang.ddang.questionandanswer.infrastructure.JpaQuestionRepository;
+import com.ddang.ddang.user.application.exception.UserNotFoundException;
+import com.ddang.ddang.user.domain.User;
+import com.ddang.ddang.user.infrastructure.persistence.JpaUserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+public class AnswerService {
+
+    private final JpaUserRepository userRepository;
+    private final JpaQuestionRepository questionRepository;
+    private final JpaAnswerRepository answerRepository;
+
+
+    @Transactional
+    public Long create(final CreateAnswerDto answerDto) {
+        final User writer = userRepository.findById(answerDto.userId())
+                                          .orElseThrow(() -> new UserNotFoundException("해당 사용자를 찾을 수 없습니다."));
+        final Question question = questionRepository.findById(answerDto.questionId())
+                                                    .orElseThrow(() ->
+                                                            new AuctionNotFoundException("해당 질문을 찾을 수 없습니다.")
+                                                    );
+
+        checkInvalidAnswerer(question, writer);
+        checkAlreadyAnswered(question);
+
+        final Answer answer = answerDto.toEntity();
+        question.addAnswer(answer);
+
+        return answerRepository.save(answer)
+                               .getId();
+    }
+
+    private void checkInvalidAnswerer(final Question question, final User writer) {
+        if (!question.isAnsweringAllowed(writer)) {
+            throw new InvalidAnswererException("판매자만 답변할 수 있습니다.");
+        }
+    }
+
+    private void checkAlreadyAnswered(final Question question) {
+        if (answerRepository.existsByQuestionId(question.getId())) {
+            throw new AlreadyAnsweredException("이미 답변한 질문입니다.");
+        }
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/QuestionService.java

@@ -0,0 +1,59 @@
+package com.ddang.ddang.questionandanswer.application;
+
+import com.ddang.ddang.auction.application.exception.AuctionNotFoundException;
+import com.ddang.ddang.auction.domain.Auction;
+import com.ddang.ddang.auction.infrastructure.persistence.JpaAuctionRepository;
+import com.ddang.ddang.questionandanswer.application.dto.CreateQuestionDto;
+import com.ddang.ddang.questionandanswer.application.exception.InvalidAuctionToAskQuestionException;
+import com.ddang.ddang.questionandanswer.application.exception.InvalidQuestionerException;
+import com.ddang.ddang.questionandanswer.domain.Question;
+import com.ddang.ddang.questionandanswer.infrastructure.JpaQuestionRepository;
+import com.ddang.ddang.user.application.exception.UserNotFoundException;
+import com.ddang.ddang.user.domain.User;
+import com.ddang.ddang.user.infrastructure.persistence.JpaUserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+
+@Service
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+public class QuestionService {
+
+    private final JpaAuctionRepository auctionRepository;
+    private final JpaUserRepository userRepository;
+    private final JpaQuestionRepository questionRepository;
+
+    public Long create(final CreateQuestionDto questionDto) {
+        final User questioner = userRepository.findByIdAndDeletedIsFalse(questionDto.userId())
+                                              .orElseThrow(() -> new UserNotFoundException("해당 사용자를 찾을 수 없습니다."));
+        final Auction auction = auctionRepository.findById(questionDto.auctionId())
+                                                 .orElseThrow(() -> new AuctionNotFoundException("해당 경매를 찾을 수 없습니다."));
+        checkInvalidAuction(auction);
+        checkInvalidQuestioner(auction, questioner);
+
+        final Question question = questionDto.toEntity(auction, questioner);
+
+        return questionRepository.save(question)
+                                 .getId();
+    }
+
+    private void checkInvalidAuction(final Auction auction) {
+        final LocalDateTime now = LocalDateTime.now();
+
+        if (auction.isDeleted()) {
+            throw new InvalidAuctionToAskQuestionException("삭제된 경매입니다.");
+        }
+        if (auction.isClosed(now)) {
+            throw new InvalidAuctionToAskQuestionException("이미 종료된 경매입니다.");
+        }
+    }
+
+    private void checkInvalidQuestioner(final Auction auction, final User questioner) {
+        if (auction.isOwner(questioner)) {
+            throw new InvalidQuestionerException("경매 등록자는 질문할 수 없습니다.");
+        }
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/dto/CreateAnswerDto.java

@@ -0,0 +1,15 @@
+package com.ddang.ddang.questionandanswer.application.dto;
+
+import com.ddang.ddang.questionandanswer.domain.Answer;
+import com.ddang.ddang.questionandanswer.presentation.dto.CreateAnswerRequest;
+
+public record CreateAnswerDto(Long questionId, String content, Long userId) {
+
+    public static CreateAnswerDto of(final Long questionId, final CreateAnswerRequest answerRequest, final Long userId) {
+        return new CreateAnswerDto(questionId, answerRequest.content(), userId);
+    }
+
+    public Answer toEntity() {
+        return new Answer(content);
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/dto/CreateQuestionDto.java

@@ -0,0 +1,17 @@
+package com.ddang.ddang.questionandanswer.application.dto;
+
+import com.ddang.ddang.auction.domain.Auction;
+import com.ddang.ddang.questionandanswer.domain.Question;
+import com.ddang.ddang.questionandanswer.presentation.dto.CreateQuestionRequest;
+import com.ddang.ddang.user.domain.User;
+
+public record CreateQuestionDto(Long auctionId, String content, Long userId) {
+
+    public static CreateQuestionDto of(final CreateQuestionRequest questionRequest, final Long userId) {
+        return new CreateQuestionDto(questionRequest.auctionId(), questionRequest.content(), userId);
+    }
+
+    public Question toEntity(final Auction auction, final User questioner) {
+        return new Question(auction, questioner, content);
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/exception/AlreadyAnsweredException.java

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

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/exception/InvalidAnswererException.java

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

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/exception/InvalidAuctionToAskQuestionException.java

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

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/application/exception/InvalidQuestionerException.java

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

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/domain/Answer.java

@@ -0,0 +1,44 @@
+package com.ddang.ddang.questionandanswer.domain;
+
+import com.ddang.ddang.common.entity.BaseCreateTimeEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ForeignKey;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToOne;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+@EqualsAndHashCode(of = "id")
+@ToString(of = {"id", "content"})
+public class Answer extends BaseCreateTimeEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "question_id", foreignKey = @ForeignKey(name = "fk_answer_question"))
+    private Question question;
+
+    @Column(columnDefinition = "text")
+    private String content;
+
+    public Answer(final String content) {
+        this.content = content;
+    }
+
+    public void initQuestion(final Question question) {
+        this.question = question;
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/domain/Question.java

@@ -0,0 +1,61 @@
+package com.ddang.ddang.questionandanswer.domain;
+
+import com.ddang.ddang.auction.domain.Auction;
+import com.ddang.ddang.common.entity.BaseCreateTimeEntity;
+import com.ddang.ddang.user.domain.User;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ForeignKey;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToOne;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+@EqualsAndHashCode(of = "id")
+@ToString(of = {"id", "content"})
+public class Question extends BaseCreateTimeEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "auction_id", foreignKey = @ForeignKey(name = "fk_question_auction"))
+    private Auction auction;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "wrtier_id", foreignKey = @ForeignKey(name = "fk_question_writer"))
+    private User writer;
+
+    @Column(columnDefinition = "text")
+    private String content;
+
+    @OneToOne(mappedBy = "question")
+    private Answer answer;
+
+    public Question(final Auction auction, final User writer, final String content) {
+        this.auction = auction;
+        this.writer = writer;
+        this.content = content;
+    }
+
+    public void addAnswer(final Answer answer) {
+        this.answer = answer;
+        answer.initQuestion(this);
+    }
+
+    public boolean isAnsweringAllowed(final User user) {
+        return auction.isOwner(user);
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/infrastructure/JpaAnswerRepository.java

@@ -0,0 +1,9 @@
+package com.ddang.ddang.questionandanswer.infrastructure;
+
+import com.ddang.ddang.questionandanswer.domain.Answer;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface JpaAnswerRepository extends JpaRepository<Answer, Long> {
+
+    boolean existsByQuestionId(Long questionId);
+}

backend/ddang/src/main/java/com/ddang/ddang/questionandanswer/infrastructure/JpaQuestionRepository.java

@@ -0,0 +1,7 @@
+package com.ddang.ddang.questionandanswer.infrastructure;
+
+import com.ddang.ddang.questionandanswer.domain.Question;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface JpaQuestionRepository extends JpaRepository<Question, Long> {
+}