유저 상호 평가 api 추가

backend/ddang/src/docs/asciidoc/docs.adoc

@@ -404,3 +404,29 @@ include::{snippets}/device-token-controller-test/디바이스_토큰을_저장_
 ==== 응답
 
 include::{snippets}/device-token-controller-test/디바이스_토큰을_저장_또는_갱신한다/http-response.adoc[]
+
+== 유저 상호 평가 API
+
+=== 사용자 평가 등록
+
+==== 요청
+
+include::{snippets}/review-controller-test/평가를_등록한다/http-request.adoc[]
+include::{snippets}/review-controller-test/평가를_등록한다/request-headers.adoc[]
+include::{snippets}/review-controller-test/평가를_등록한다/request-fields.adoc[]
+
+==== 응답
+
+include::{snippets}/review-controller-test/평가를_등록한다/http-response.adoc[]
+
+=== 지정한 사용자가 받은 평가 목록 조회
+
+==== 요청
+
+include::{snippets}/review-controller-test/주어진_사용자가_받은_평가_목록을_최신순으로_조회한다/http-request.adoc[]
+include::{snippets}/review-controller-test/주어진_사용자가_받은_평가_목록을_최신순으로_조회한다/query-parameters.adoc[]
+
+==== 응답
+
+include::{snippets}/review-controller-test/주어진_사용자가_받은_평가_목록을_최신순으로_조회한다/http-response.adoc[]
+include::{snippets}/review-controller-test/주어진_사용자가_받은_평가_목록을_최신순으로_조회한다/response-fields.adoc[]

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

@@ -29,6 +29,7 @@
 import com.ddang.ddang.report.application.exception.InvalidChatRoomReportException;
 import com.ddang.ddang.report.application.exception.InvalidReportAuctionException;
 import com.ddang.ddang.report.application.exception.InvalidReporterToAuctionException;
+import com.ddang.ddang.review.application.exception.AlreadyReviewException;
 import com.ddang.ddang.user.application.exception.UserNotFoundException;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
@@ -325,6 +326,16 @@ public ResponseEntity<ExceptionResponse> handleDeviceTokenNotFoundException(fina
                              .body(new ExceptionResponse(ex.getMessage()));
     }
 
+    @ExceptionHandler(AlreadyReviewException.class)
+    public ResponseEntity<ExceptionResponse> handleAlreadyReviewException(
+            final AlreadyReviewException ex
+    ) {
+        logger.warn(String.format(EXCEPTION_FORMAT, AlreadyReviewException.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/review/application/ReviewService.java

@@ -0,0 +1,86 @@
+package com.ddang.ddang.review.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.review.application.dto.CreateReviewDto;
+import com.ddang.ddang.review.application.dto.ReadReviewDetailDto;
+import com.ddang.ddang.review.application.dto.ReadReviewDto;
+import com.ddang.ddang.review.application.exception.AlreadyReviewException;
+import com.ddang.ddang.review.application.exception.InvalidUserToReview;
+import com.ddang.ddang.review.domain.Review;
+import com.ddang.ddang.review.infrastructure.persistence.JpaReviewRepository;
+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;
+import java.util.List;
+
+@Service
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+public class ReviewService {
+
+    private final JpaReviewRepository reviewRepository;
+    private final JpaAuctionRepository auctionRepository;
+    private final JpaUserRepository userRepository;
+
+    @Transactional
+    public Long create(final CreateReviewDto reviewDto) {
+        final Auction findAuction = auctionRepository.findById(reviewDto.auctionId())
+                                                     .orElseThrow(() ->
+                                                             new AuctionNotFoundException("해당 경매를 찾을 수 없습니다.")
+                                                     );
+        final User writer = userRepository.findById(reviewDto.writerId())
+                                          .orElseThrow(() -> new UserNotFoundException("작성자 정보를 찾을 수 없습니다."));
+        final User target = userRepository.findById(reviewDto.targetId())
+                                          .orElseThrow(() -> new UserNotFoundException("평가 상대의 정보를 찾을 수 없습니다."));
+
+        validateWriterCanReview(findAuction, writer);
+
+        final Review review = reviewDto.toEntity(findAuction, writer, target);
+        final Review persistReview = saveReviewAndUpdateReliability(review, target);
+
+        return persistReview.getId();
+    }
+
+    private void validateWriterCanReview(final Auction auction, final User writer) {
+        if (!auction.isSellerOrWinner(writer, LocalDateTime.now())) {
+            throw new InvalidUserToReview("경매의 판매자 또는 최종 낙찰자만 평가가 가능합니다.");
+        }
+
+        validateAlreadyReviewed(auction, writer);
+    }
+
+    private void validateAlreadyReviewed(final Auction auction, final User writer) {
+        if (reviewRepository.existsByAuctionIdAndWriterId(auction.getId(), writer.getId())) {
+            throw new AlreadyReviewException("이미 평가하였습니다.");
+        }
+    }
+
+    private Review saveReviewAndUpdateReliability(final Review review, final User target) {
+        final Review persistReview = reviewRepository.save(review);
+
+        final List<Review> targetReviews = reviewRepository.findAllByTargetId(target.getId());
+        target.updateReliability(targetReviews);
+        return persistReview;
+    }
+
+    public List<ReadReviewDto> readAllByTargetId(final Long targetId) {
+        final List<Review> targetReviews = reviewRepository.findAllByTargetId(targetId);
+
+        return targetReviews.stream()
+                            .map(ReadReviewDto::from)
+                            .toList();
+    }
+
+    public ReadReviewDetailDto read(final Long writerId, final Long auctionId) {
+        return reviewRepository.findByAuctionIdAndWriterId(auctionId, writerId)
+                               .map(ReadReviewDetailDto::from)
+                               .orElse(ReadReviewDetailDto.empty());
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/review/application/dto/CreateReviewDto.java

@@ -0,0 +1,29 @@
+package com.ddang.ddang.review.application.dto;
+
+import com.ddang.ddang.auction.domain.Auction;
+import com.ddang.ddang.review.domain.Review;
+import com.ddang.ddang.review.presentation.dto.request.CreateReviewRequest;
+import com.ddang.ddang.user.domain.User;
+
+public record CreateReviewDto(Long auctionId, Long writerId, Long targetId, String content, Double score) {
+
+    public static CreateReviewDto of(final Long writerId, final CreateReviewRequest createReviewRequest) {
+        return new CreateReviewDto(
+                createReviewRequest.auctionId(),
+                writerId,
+                createReviewRequest.targetId(),
+                createReviewRequest.content(),
+                createReviewRequest.score()
+        );
+    }
+
+    public Review toEntity(final Auction auction, final User writer, final User target) {
+        return Review.builder()
+                     .auction(auction)
+                     .writer(writer)
+                     .target(target)
+                     .content(content)
+                     .score(score)
+                     .build();
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/review/application/dto/ReadReviewDetailDto.java

@@ -0,0 +1,18 @@
+package com.ddang.ddang.review.application.dto;
+
+import com.ddang.ddang.review.domain.Review;
+
+import javax.annotation.Nullable;
+
+public record ReadReviewDetailDto(@Nullable Double score, @Nullable String content) {
+
+    private static final Double EMPTY_SCORE = null;
+    private static final String EMPTY_CONTENT = null;
+
+    public static ReadReviewDetailDto empty() {
+        return new ReadReviewDetailDto(EMPTY_SCORE, EMPTY_CONTENT);
+    }
+    public static ReadReviewDetailDto from(final Review review) {
+        return new ReadReviewDetailDto(review.getScore(), review.getContent());
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/review/application/dto/ReadReviewDto.java

@@ -0,0 +1,23 @@
+package com.ddang.ddang.review.application.dto;
+
+import com.ddang.ddang.review.domain.Review;
+
+import java.time.LocalDateTime;
+
+public record ReadReviewDto(
+        Long id,
+        ReadUserInReviewDto writer,
+        String content,
+        Double score,
+        LocalDateTime createdTime
+) {
+
+    public static ReadReviewDto from(final Review review) {
+        return new ReadReviewDto(
+                review.getId(),
+                ReadUserInReviewDto.from(review.getWriter()),
+                review.getContent(),
+                review.getScore(),
+                review.getCreatedTime());
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/review/application/dto/ReadUserInReviewDto.java

@@ -0,0 +1,16 @@
+package com.ddang.ddang.review.application.dto;
+
+import com.ddang.ddang.user.domain.User;
+
+public record ReadUserInReviewDto(Long id, String name, Long profileImageId, double reliability, String oauthId) {
+
+    public static ReadUserInReviewDto from(final User user) {
+        return new ReadUserInReviewDto(
+                user.getId(),
+                user.getName(),
+                user.getProfileImage().getId(),
+                user.getReliability(),
+                user.getOauthId()
+        );
+    }
+}

backend/ddang/src/main/java/com/ddang/ddang/review/application/exception/AlreadyReviewException.java

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

backend/ddang/src/main/java/com/ddang/ddang/review/application/exception/InvalidUserToReview.java

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

backend/ddang/src/main/java/com/ddang/ddang/review/domain/Review.java

@@ -0,0 +1,62 @@
+package com.ddang.ddang.review.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.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 lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+@Entity
+@NoArgsConstructor
+@Getter
+@EqualsAndHashCode(of = "id", callSuper = false)
+@ToString(of = {"id", "content", "score"})
+public class Review extends BaseCreateTimeEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "auction_id", nullable = false, foreignKey = @ForeignKey(name = "fk_review_auction"))
+    private Auction auction;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "writer_id", nullable = false, foreignKey = @ForeignKey(name = "fk_review_writer"))
+    private User writer;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "target_id", nullable = false, foreignKey = @ForeignKey(name = "fk_review_target"))
+    private User target;
+
+    private String content;
+
+    private Double score;
+
+    @Builder
+    public Review(
+            final Auction auction,
+            final User writer,
+            final User target,
+            final String content,
+            final Double score
+    ) {
+        this.auction = auction;
+        this.writer = writer;
+        this.target = target;
+        this.content = content;
+        this.score = score;
+    }
+}
+

backend/ddang/src/main/java/com/ddang/ddang/review/infrastructure/persistence/JpaReviewRepository.java

@@ -0,0 +1,24 @@
+package com.ddang.ddang.review.infrastructure.persistence;
+
+import com.ddang.ddang.review.domain.Review;
+import org.springframework.data.jpa.repository.EntityGraph;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface JpaReviewRepository extends JpaRepository<Review, Long> {
+
+    boolean existsByAuctionIdAndWriterId(final Long auctionId, final Long writerId);
+
+    @EntityGraph(attributePaths = {"writer", "target"})
+    @Query("""
+            SELECT r FROM Review r JOIN FETCH r.writer w JOIN FETCH r.target t 
+            WHERE t.id = :targetId 
+            ORDER BY r.id DESC
+           """)
+    List<Review> findAllByTargetId(final Long targetId);
+
+    Optional<Review> findByAuctionIdAndWriterId(final Long auctionId, final Long writerId);
+}