Q&A 기능 추가

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

@@ -24,6 +24,7 @@
 import com.ddang.ddang.image.infrastructure.local.exception.UnsupportedImageFileExtensionException;
 import com.ddang.ddang.notification.application.exception.NotificationFailedException;
 import com.ddang.ddang.qna.application.exception.AlreadyAnsweredException;
+import com.ddang.ddang.qna.application.exception.AnswerNotFoundException;
 import com.ddang.ddang.qna.application.exception.InvalidAnswererException;
 import com.ddang.ddang.qna.application.exception.InvalidAuctionToAskQuestionException;
 import com.ddang.ddang.qna.application.exception.InvalidQuestionerException;
@@ -32,6 +33,7 @@
 import com.ddang.ddang.report.application.exception.AlreadyReportAuctionException;
 import com.ddang.ddang.report.application.exception.AlreadyReportChatRoomException;
 import com.ddang.ddang.report.application.exception.InvalidChatRoomReportException;
+import com.ddang.ddang.report.application.exception.InvalidQuestionReportException;
 import com.ddang.ddang.report.application.exception.InvalidReportAuctionException;
 import com.ddang.ddang.report.application.exception.InvalidReporterToAuctionException;
 import com.ddang.ddang.user.application.exception.UserNotFoundException;
@@ -330,39 +332,55 @@ public ResponseEntity<ExceptionResponse> handleDeviceTokenNotFoundException(fina
 
     @ExceptionHandler(InvalidAuctionToAskQuestionException.class)
     public ResponseEntity<ExceptionResponse> handleInvalidAuctionToAskQuestionException(final InvalidAuctionToAskQuestionException ex) {
-        logger.warn(String.format(EXCEPTION_FORMAT, InvalidAuctionToAskQuestionException.class), ex);
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, ex.getClass().getSimpleName(), ex.getMessage()));
 
         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);
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, ex.getClass().getSimpleName(), ex.getMessage()));
 
         return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                              .body(new ExceptionResponse(ex.getMessage()));
     }
 
     @ExceptionHandler(QuestionNotFoundException.class)
     public ResponseEntity<ExceptionResponse> handleQuestionNotFoundException(final QuestionNotFoundException ex) {
-        logger.warn(String.format(EXCEPTION_FORMAT, QuestionNotFoundException.class), ex);
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, ex.getClass().getSimpleName(), ex.getMessage()));
+
+        return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
+    @ExceptionHandler(AnswerNotFoundException.class)
+    public ResponseEntity<ExceptionResponse> handleAnswerNotFoundException(final AnswerNotFoundException ex) {
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, ex.getClass().getSimpleName(), ex.getMessage()));
 
         return ResponseEntity.status(HttpStatus.NOT_FOUND)
                              .body(new ExceptionResponse(ex.getMessage()));
     }
 
     @ExceptionHandler(InvalidAnswererException.class)
     public ResponseEntity<ExceptionResponse> handleInvalidAnswererException(final InvalidAnswererException ex) {
-        logger.warn(String.format(EXCEPTION_FORMAT, InvalidAnswererException.class), ex);
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, ex.getClass().getSimpleName(), ex.getMessage()));
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                             .body(new ExceptionResponse(ex.getMessage()));
+    }
+
+    @ExceptionHandler(InvalidQuestionReportException.class)
+    public ResponseEntity<ExceptionResponse> handleInvalidQuestionReportException(final InvalidQuestionReportException ex) {
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, ex.getClass().getSimpleName(), ex.getMessage()));
 
         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);
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, ex.getClass().getSimpleName(), ex.getMessage()));
 
         return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                              .body(new ExceptionResponse(ex.getMessage()));

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

@@ -1,7 +1,9 @@
 package com.ddang.ddang.qna.application;
 
+import com.ddang.ddang.auction.application.exception.UserForbiddenException;
 import com.ddang.ddang.qna.application.dto.CreateAnswerDto;
 import com.ddang.ddang.qna.application.exception.AlreadyAnsweredException;
+import com.ddang.ddang.qna.application.exception.AnswerNotFoundException;
 import com.ddang.ddang.qna.application.exception.InvalidAnswererException;
 import com.ddang.ddang.qna.application.exception.QuestionNotFoundException;
 import com.ddang.ddang.qna.domain.Answer;
@@ -54,4 +56,18 @@ private void checkAlreadyAnswered(final Question question) {
             throw new AlreadyAnsweredException("이미 답변한 질문입니다.");
         }
     }
+
+    @Transactional
+    public void deleteById(final Long answerId, final Long userId) {
+        final Answer answer = answerRepository.findByIdAndDeletedIsFalse(answerId)
+                                              .orElseThrow(() -> new AnswerNotFoundException("해당 답변을 찾을 수 없습니다."));
+        final User user = userRepository.findByIdAndDeletedIsFalse(userId)
+                                        .orElseThrow(() -> new UserNotFoundException("해당 사용자를 찾을 수 없습니다."));
+
+        if (!answer.isWriter(user)) {
+            throw new UserForbiddenException("삭제할 권한이 없습니다.");
+        }
+
+        answer.delete();
+    }
 }

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

@@ -1,12 +1,14 @@
 package com.ddang.ddang.qna.application;
 
 import com.ddang.ddang.auction.application.exception.AuctionNotFoundException;
+import com.ddang.ddang.auction.application.exception.UserForbiddenException;
 import com.ddang.ddang.auction.domain.Auction;
 import com.ddang.ddang.auction.infrastructure.persistence.JpaAuctionRepository;
 import com.ddang.ddang.qna.application.dto.CreateQuestionDto;
 import com.ddang.ddang.qna.application.dto.ReadQnasDto;
 import com.ddang.ddang.qna.application.exception.InvalidAuctionToAskQuestionException;
 import com.ddang.ddang.qna.application.exception.InvalidQuestionerException;
+import com.ddang.ddang.qna.application.exception.QuestionNotFoundException;
 import com.ddang.ddang.qna.domain.Question;
 import com.ddang.ddang.qna.infrastructure.JpaQuestionRepository;
 import com.ddang.ddang.user.application.exception.UserNotFoundException;
@@ -28,6 +30,7 @@ public class QuestionService {
     private final JpaUserRepository userRepository;
     private final JpaQuestionRepository questionRepository;
 
+    @Transactional
     public Long create(final CreateQuestionDto questionDto) {
         final User questioner = userRepository.findByIdAndDeletedIsFalse(questionDto.userId())
                                               .orElseThrow(() -> new UserNotFoundException("해당 사용자를 찾을 수 없습니다."));
@@ -60,8 +63,22 @@ public ReadQnasDto readAllByAuctionId(final Long auctionId) {
             throw new AuctionNotFoundException("해당 경매를 찾을 수 없습니다.");
         }
 
-        final List<Question> questions = questionRepository.readAllByAuctionId(auctionId);
+        final List<Question> questions = questionRepository.findAllByAuctionId(auctionId);
 
         return ReadQnasDto.from(questions);
     }
+
+    @Transactional
+    public void deleteById(final Long questionId, final Long userId) {
+        final Question question = questionRepository.findById(questionId)
+                                                    .orElseThrow(() -> new QuestionNotFoundException("해당 질문을 찾을 수 없습니다."));
+        final User user = userRepository.findByIdAndDeletedIsFalse(userId)
+                                        .orElseThrow(() -> new UserNotFoundException("해당 사용자를 찾을 수 없습니다."));
+
+        if (!question.isWriter(user)) {
+            throw new UserForbiddenException("삭제할 권한이 없습니다.");
+        }
+
+        question.delete();
+    }
 }

backend/ddang/src/main/java/com/ddang/ddang/qna/application/exception/AnswerNotFoundException.java

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

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

@@ -1,6 +1,7 @@
 package com.ddang.ddang.qna.domain;
 
 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;
@@ -20,9 +21,11 @@
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @Getter
 @EqualsAndHashCode(of = "id", callSuper = false)
-@ToString(of = {"id", "content"})
+@ToString(of = {"id", "content", "deleted"})
 public class Answer extends BaseCreateTimeEntity {
 
+    private static final boolean DELETED_STATUS = true;
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -34,11 +37,26 @@ public class Answer extends BaseCreateTimeEntity {
     @Column(columnDefinition = "text")
     private String content;
 
+    @Column(name = "is_deleted")
+    private boolean deleted = false;
+
     public Answer(final String content) {
         this.content = content;
     }
 
     public void initQuestion(final Question question) {
         this.question = question;
     }
+
+    public boolean isWriter(final User user) {
+        return question.getAuction().isOwner(user);
+    }
+
+    public void delete() {
+        deleted = DELETED_STATUS;
+    }
+
+    public User getWriter() {
+        return question.getWriter();
+    }
 }

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

@@ -23,9 +23,11 @@
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @Getter
 @EqualsAndHashCode(of = "id", callSuper = false)
-@ToString(of = {"id", "content"})
+@ToString(of = {"id", "content", "deleted"})
 public class Question extends BaseCreateTimeEntity {
 
+    private static final boolean DELETED_STATUS = true;
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -44,6 +46,9 @@ public class Question extends BaseCreateTimeEntity {
     @OneToOne(mappedBy = "question")
     private Answer answer;
 
+    @Column(name = "is_deleted")
+    private boolean deleted = false;
+
     public Question(final Auction auction, final User writer, final String content) {
         this.auction = auction;
         this.writer = writer;
@@ -58,4 +63,12 @@ public void addAnswer(final Answer answer) {
     public boolean isAnsweringAllowed(final User user) {
         return auction.isOwner(user);
     }
+
+    public boolean isWriter(final User user) {
+        return writer.equals(user);
+    }
+
+    public void delete() {
+        deleted = DELETED_STATUS;
+    }
 }

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

@@ -1,9 +1,15 @@
 package com.ddang.ddang.qna.infrastructure;
 
 import com.ddang.ddang.qna.domain.Answer;
+import org.springframework.data.jpa.repository.EntityGraph;
 import org.springframework.data.jpa.repository.JpaRepository;
 
+import java.util.Optional;
+
 public interface JpaAnswerRepository extends JpaRepository<Answer, Long> {
 
     boolean existsByQuestionId(Long questionId);
+
+    @EntityGraph(attributePaths = {"question", "question.auction", "question.auction.seller"})
+    Optional<Answer> findByIdAndDeletedIsFalse(Long answerId);
 }

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

@@ -5,9 +5,12 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 
 import java.util.List;
+import java.util.Optional;
 
 public interface JpaQuestionRepository extends JpaRepository<Question, Long> {
 
+    Optional<Question> findByIdAndDeletedIsFalse(final Long id);
+
     @EntityGraph(attributePaths = {"writer", "answer", "auction", "auction.seller"})
-    List<Question> readAllByAuctionId(final Long auctionId);
+    List<Question> findAllByAuctionId(final Long auctionId);
 }

backend/ddang/src/main/java/com/ddang/ddang/qna/presentation/QnaController.java

@@ -11,6 +11,7 @@
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -49,4 +50,26 @@ public ResponseEntity<Void> createAnswer(
         return ResponseEntity.created(URI.create("/auctions/" + answerRequest.auctionId()))
                              .build();
     }
+
+    @DeleteMapping("/{questionId}")
+    public ResponseEntity<Void> deleteQuestion(
+            @AuthenticateUser AuthenticationUserInfo userInfo,
+            @PathVariable final Long questionId
+    ) {
+        questionService.deleteById(questionId, userInfo.userId());
+
+        return ResponseEntity.noContent()
+                             .build();
+    }
+
+    @DeleteMapping("/answers/{answerId}")
+    public ResponseEntity<Void> deleteAnswer(
+            @AuthenticateUser AuthenticationUserInfo userInfo,
+            @PathVariable final Long answerId
+    ) {
+        answerService.deleteById(answerId, userInfo.userId());
+
+        return ResponseEntity.noContent()
+                             .build();
+    }
 }

backend/ddang/src/main/java/com/ddang/ddang/report/application/AnswerReportService.java

@@ -0,0 +1,61 @@
+package com.ddang.ddang.report.application;
+
+import com.ddang.ddang.qna.application.exception.AnswerNotFoundException;
+import com.ddang.ddang.qna.domain.Answer;
+import com.ddang.ddang.qna.infrastructure.JpaAnswerRepository;
+import com.ddang.ddang.report.application.dto.CreateAnswerReportDto;
+import com.ddang.ddang.report.application.dto.ReadAnswerReportDto;
+import com.ddang.ddang.report.application.exception.InvalidAnswererReportException;
+import com.ddang.ddang.report.domain.AnswerReport;
+import com.ddang.ddang.report.infrastructure.persistence.JpaAnswerReportRepository;
+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.util.List;
+
+@Service
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+public class AnswerReportService {
+
+    private final JpaAnswerRepository answerRepository;
+    private final JpaUserRepository userRepository;
+    private final JpaAnswerReportRepository answerReportRepository;
+
+    @Transactional
+    public Long create(final CreateAnswerReportDto answerReportDto) {
+        final Answer answer = answerRepository.findByIdAndDeletedIsFalse(answerReportDto.answerId())
+                                              .orElseThrow(() ->
+                                                      new AnswerNotFoundException("해당 답변을 찾을 수 없습니다.")
+                                              );
+        final User reporter = userRepository.findByIdAndDeletedIsFalse(answerReportDto.reporterId())
+                                            .orElseThrow(() -> new UserNotFoundException("해당 사용자를 찾을 수 없습니다."));
+        checkInvalidAnswerReport(reporter, answer);
+
+        final AnswerReport answerReport = answerReportDto.toEntity(answer, reporter);
+
+        return answerReportRepository.save(answerReport)
+                                     .getId();
+    }
+
+    private void checkInvalidAnswerReport(final User reporter, final Answer answer) {
+        if (answer.isWriter(reporter)) {
+            throw new InvalidAnswererReportException("본인 답변입니다.");
+        }
+        if (answerReportRepository.existsByIdAndReporterId(answer.getId(), reporter.getId())) {
+            throw new InvalidAnswererReportException("이미 신고한 답변입니다.");
+        }
+    }
+
+    public List<ReadAnswerReportDto> readAll() {
+        final List<AnswerReport> answerReports = answerReportRepository.findAllByOrderByIdAsc();
+
+        return answerReports.stream()
+                            .map(ReadAnswerReportDto::from)
+                            .toList();
+    }
+}