[BE] issue120: 스터디 리뷰 작성

backend/src/main/java/com/woowacourse/moamoa/auth/controller/AuthenticationInterceptor.java

@@ -22,7 +22,7 @@ public boolean preHandle(final HttpServletRequest request, final HttpServletResp
             return true;
         }
 
-        if (request.getMethod().equals("POST") && request.getServletPath().equals("/api/studies")) {
+        if (request.getMethod().equals("POST") && validatePath(request)) {
             String token = AuthenticationExtractor.extract(request);
             validateToken(token);
 
@@ -41,4 +41,9 @@ private void validateToken(String token) {
             throw new UnauthorizedException("유효하지 않은 토큰입니다.");
         }
     }
+
+    private boolean validatePath(final HttpServletRequest request) {
+        return request.getServletPath().equals("/api/studies") ||
+                request.getServletPath().matches("/api/studies/\\d+/reviews");
+    }
 }

backend/src/main/java/com/woowacourse/moamoa/common/advice/CommonControllerAdvice.java

@@ -1,8 +1,10 @@
 package com.woowacourse.moamoa.common.advice;
 
-import com.woowacourse.moamoa.common.exception.UnauthorizedException;
 import com.woowacourse.moamoa.common.advice.response.ErrorResponse;
+import com.woowacourse.moamoa.common.exception.BadRequestException;
 import com.woowacourse.moamoa.common.exception.InvalidFormatException;
+import com.woowacourse.moamoa.common.exception.NotFoundException;
+import com.woowacourse.moamoa.common.exception.UnauthorizedException;
 import com.woowacourse.moamoa.study.domain.exception.InvalidPeriodException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -14,14 +16,20 @@ public class CommonControllerAdvice {
 
     @ExceptionHandler({
             InvalidFormatException.class,
-            InvalidPeriodException.class
+            InvalidPeriodException.class,
+            BadRequestException.class
     })
     public ResponseEntity<ErrorResponse> handleBadRequest(final Exception e) {
         return ResponseEntity.badRequest().body(new ErrorResponse(e.getMessage()));
     }
 
-    @ExceptionHandler
-    public ResponseEntity<Void> handleUnauthorized(final UnauthorizedException e) {
+    @ExceptionHandler({UnauthorizedException.class})
+    public ResponseEntity<Void> handleUnauthorized(final Exception e) {
         return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
     }
+
+    @ExceptionHandler({NotFoundException.class})
+    public ResponseEntity<ErrorResponse> handleNotFound(final Exception e) {
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse(e.getMessage()));
+    }
 }

backend/src/main/java/com/woowacourse/moamoa/common/exception/BadRequestException.java

@@ -0,0 +1,8 @@
+package com.woowacourse.moamoa.common.exception;
+
+public class BadRequestException extends RuntimeException {
+
+    public BadRequestException(final String message) {
+        super(message);
+    }
+}

backend/src/main/java/com/woowacourse/moamoa/common/exception/NotFoundException.java

@@ -0,0 +1,8 @@
+package com.woowacourse.moamoa.common.exception;
+
+public class NotFoundException extends RuntimeException {
+
+    public NotFoundException(final String message) {
+        super(message);
+    }
+}

backend/src/main/java/com/woowacourse/moamoa/member/query/MemberDao.java

@@ -23,10 +23,20 @@ public MemberDao(final JdbcTemplate jdbcTemplate) {
         this.jdbcTemplate = jdbcTemplate;
     }
 
-    public List<MemberData> findMembersByStudyId(Long studyId) {
-        String sql = "SELECT github_id, username, image_url, profile_url "
+    public List<MemberData> findMembersByStudyId(final Long studyId) {
+        final String sql = "SELECT github_id, username, image_url, profile_url "
                 + "FROM member JOIN study_member ON member.id = study_member.member_id "
                 + "WHERE study_member.study_id = ?";
         return jdbcTemplate.query(sql, ROW_MAPPER, studyId);
     }
+
+    public boolean existsByStudyIdAndMemberId(final Long studyId, final Long memberId) {
+        final String sql = "SELECT EXISTS "
+                + "( "
+                + "SELECT * "
+                + "FROM member JOIN study_member ON member.id = study_member.member_id "
+                + "WHERE study_member.study_id = ? AND study_member.member_id = ? "
+                + ")";
+        return Boolean.TRUE.equals(jdbcTemplate.queryForObject(sql, Boolean.class, studyId, memberId));
+    }
 }

backend/src/main/java/com/woowacourse/moamoa/member/service/MemberService.java

@@ -3,7 +3,7 @@
 import com.woowacourse.moamoa.member.domain.Member;
 import com.woowacourse.moamoa.member.domain.repository.MemberRepository;
 import com.woowacourse.moamoa.member.query.data.MemberData;
-import com.woowacourse.moamoa.member.service.exception.InvalidMemberException;
+import com.woowacourse.moamoa.member.service.exception.MemberNotFoundException;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -24,7 +24,7 @@ public void saveOrUpdate(final Member member) {
 
     public MemberData searchBy(final Long githubId) {
         final Member member = memberRepository.findByGithubId(githubId)
-                .orElseThrow(() -> new InvalidMemberException("사용자를 찾을 수 없습니다."));
+                .orElseThrow(MemberNotFoundException::new);
         return new MemberData(member.getGithubId(), member.getUsername(), member.getImageUrl(), member.getProfileUrl());
     }
 }

backend/src/main/java/com/woowacourse/moamoa/member/service/exception/MemberNotFoundException.java

@@ -0,0 +1,10 @@
+package com.woowacourse.moamoa.member.service.exception;
+
+import com.woowacourse.moamoa.common.exception.NotFoundException;
+
+public class MemberNotFoundException extends NotFoundException {
+
+    public MemberNotFoundException() {
+        super("회원을 찾을 수 없습니다.");
+    }
+}

backend/src/main/java/com/woowacourse/moamoa/member/service/exception/NotParticipatedMemberException.java

@@ -0,0 +1,10 @@
+package com.woowacourse.moamoa.member.service.exception;
+
+import com.woowacourse.moamoa.common.exception.UnauthorizedException;
+
+public class NotParticipatedMemberException extends UnauthorizedException {
+
+    public NotParticipatedMemberException() {
+        super("스터디에 참여한 회원만 후기를 작성할 수 있습니다.");
+    }
+}

backend/src/main/java/com/woowacourse/moamoa/review/controller/ReviewController.java

@@ -1,29 +1,32 @@
 package com.woowacourse.moamoa.review.controller;
 
+import com.woowacourse.moamoa.auth.config.AuthenticationPrincipal;
 import com.woowacourse.moamoa.review.service.ReviewService;
-import com.woowacourse.moamoa.review.service.response.ReviewsResponse;
+import com.woowacourse.moamoa.review.service.request.WriteReviewRequest;
+import java.net.URI;
+import javax.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
-@RequestMapping("/api/studies")
+@RequestMapping("/api/studies/{study-id}/reviews")
 @RequiredArgsConstructor
 public class ReviewController {
 
     private final ReviewService reviewService;
 
-    @GetMapping("/{study-id}/reviews")
-    public ResponseEntity<ReviewsResponse> getReviews(
-            @PathVariable(name = "study-id") Long studyId,
-            @RequestParam(required = false) Integer size
+    @PostMapping
+    public ResponseEntity<Void> writeReview(
+            @AuthenticationPrincipal final Long githubId,
+            @PathVariable(name = "study-id") final Long studyId,
+            @Valid @RequestBody final WriteReviewRequest writeReviewRequest
     ) {
-        final ReviewsResponse reviewsResponse = reviewService.getReviewsByStudy(studyId, size);
-
-        return ResponseEntity.ok(reviewsResponse);
+        final Long id = reviewService.writeReview(githubId, studyId, writeReviewRequest);
+        return ResponseEntity.created(URI.create("/api/studies/" + studyId + "/reviews/" + id)).build();
     }
 }

backend/src/main/java/com/woowacourse/moamoa/review/controller/SearchingReviewController.java

@@ -0,0 +1,28 @@
+package com.woowacourse.moamoa.review.controller;
+
+import com.woowacourse.moamoa.review.service.SearchingReviewService;
+import com.woowacourse.moamoa.review.service.response.ReviewsResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/studies/{study-id}/reviews")
+@RequiredArgsConstructor
+public class SearchingReviewController {
+
+    private final SearchingReviewService searchingReviewService;
+
+    @GetMapping
+    public ResponseEntity<ReviewsResponse> getReviews(
+            @PathVariable(name = "study-id") final Long studyId,
+            @RequestParam(required = false) final Integer size
+    ) {
+        final ReviewsResponse reviewsResponse = searchingReviewService.getReviewsByStudy(studyId, size);
+        return ResponseEntity.ok(reviewsResponse);
+    }
+}

backend/src/main/java/com/woowacourse/moamoa/review/domain/AssociatedStudy.java

@@ -9,9 +9,9 @@
 import lombok.NoArgsConstructor;
 
 @Embeddable
+@NoArgsConstructor(access = PROTECTED)
 @AllArgsConstructor
 @Getter
-@NoArgsConstructor(access = PROTECTED)
 public class AssociatedStudy {
 
     @Column(name = "study_id", nullable = false)

backend/src/main/java/com/woowacourse/moamoa/review/domain/Review.java

@@ -19,9 +19,9 @@
 import org.springframework.data.annotation.LastModifiedDate;
 
 @Entity
-@Getter
 @NoArgsConstructor(access = PROTECTED)
 @AllArgsConstructor
+@Getter
 public class Review {
 
     @Id
@@ -39,10 +39,17 @@ public class Review {
     private String content;
 
     @CreatedDate
-    @Column(nullable = false)
+    @Column(nullable = false, updatable = false)
     private LocalDateTime createdDate;
 
     @LastModifiedDate
     @Column(nullable = false)
     private LocalDateTime lastModifiedDate;
+
+    public Review(
+            final AssociatedStudy associatedStudy, final Member member, final String content,
+            final LocalDateTime createdDate, final LocalDateTime lastModifiedDate
+    ) {
+        this(null, associatedStudy, member, content, createdDate, lastModifiedDate);
+    }
 }

backend/src/main/java/com/woowacourse/moamoa/review/domain/exception/WritingReviewBadRequestException.java

@@ -0,0 +1,10 @@
+package com.woowacourse.moamoa.review.domain.exception;
+
+import com.woowacourse.moamoa.common.exception.BadRequestException;
+
+public class WritingReviewBadRequestException extends BadRequestException {
+
+    public WritingReviewBadRequestException() {
+        super("스터디 시작 전 후기를 작성할 수 없습니다.");
+    }
+}

backend/src/main/java/com/woowacourse/moamoa/review/domain/repository/ReviewRepository.java

@@ -6,5 +6,7 @@
 
 public interface ReviewRepository {
 
+    Review save(Review review);
+
     List<Review> findAllByAssociatedStudy(AssociatedStudy associatedStudy);
 }

backend/src/main/java/com/woowacourse/moamoa/review/service/ReviewService.java

@@ -1,41 +1,53 @@
 package com.woowacourse.moamoa.review.service;
 
-import static java.util.stream.Collectors.toList;
-
+import com.woowacourse.moamoa.member.domain.Member;
+import com.woowacourse.moamoa.member.domain.repository.MemberRepository;
+import com.woowacourse.moamoa.member.service.exception.MemberNotFoundException;
+import com.woowacourse.moamoa.member.service.exception.NotParticipatedMemberException;
 import com.woowacourse.moamoa.review.domain.AssociatedStudy;
 import com.woowacourse.moamoa.review.domain.Review;
+import com.woowacourse.moamoa.review.domain.exception.WritingReviewBadRequestException;
 import com.woowacourse.moamoa.review.domain.repository.ReviewRepository;
-import com.woowacourse.moamoa.review.service.response.ReviewResponse;
-import com.woowacourse.moamoa.review.service.response.ReviewsResponse;
-import java.util.List;
+import com.woowacourse.moamoa.review.service.request.WriteReviewRequest;
+import com.woowacourse.moamoa.study.domain.Participant;
+import com.woowacourse.moamoa.study.domain.Study;
+import com.woowacourse.moamoa.study.domain.repository.StudyRepository;
+import com.woowacourse.moamoa.study.service.exception.StudyNotFoundException;
+import java.time.LocalDateTime;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 @Service
-@Transactional(readOnly = true)
+@Transactional
 @RequiredArgsConstructor
 public class ReviewService {
 
     private final ReviewRepository reviewRepository;
-
-    public ReviewsResponse getReviewsByStudy(Long studyId, Integer size) {
-        final AssociatedStudy associatedStudy = new AssociatedStudy(studyId);
-
-        final List<Review> reviews = reviewRepository.findAllByAssociatedStudy(associatedStudy);
-
-        if (size != null) {
-            return makeReviewsResponse(reviews.subList(0, size), reviews.size());
+    private final MemberRepository memberRepository;
+    private final StudyRepository studyRepository;
+
+    public Long writeReview(final Long githubId, final Long studyId, final WriteReviewRequest writeReviewRequest) {
+        final Study study = studyRepository.findById(studyId)
+                .orElseThrow(StudyNotFoundException::new);
+        final Member member = memberRepository.findByGithubId(githubId)
+                .orElseThrow(MemberNotFoundException::new);
+
+        final Participant participant = new Participant(member.getId());
+        if (!study.isParticipated(participant)) {
+            throw new NotParticipatedMemberException();
         }
 
-        return makeReviewsResponse(reviews, reviews.size());
-    }
+        final LocalDateTime reviewCreatedDate = LocalDateTime.now();
+        if (study.isBeforeThanStudyStartDate(reviewCreatedDate.toLocalDate())) {
+            throw new WritingReviewBadRequestException();
+        }
 
-    private ReviewsResponse makeReviewsResponse(final List<Review> reviews, final int totalCount) {
-        final List<ReviewResponse> reviewResponses = reviews.stream()
-                .map(ReviewResponse::new)
-                .collect(toList());
+        final AssociatedStudy associatedStudy = new AssociatedStudy(studyId);
+        final Review review = new Review(
+                associatedStudy, member, writeReviewRequest.getContent(), reviewCreatedDate, reviewCreatedDate
+        );
 
-        return new ReviewsResponse(reviewResponses, totalCount);
+        return reviewRepository.save(review).getId();
     }
 }

backend/src/main/java/com/woowacourse/moamoa/review/service/SearchingReviewService.java

@@ -0,0 +1,41 @@
+package com.woowacourse.moamoa.review.service;
+
+import static java.util.stream.Collectors.toList;
+
+import com.woowacourse.moamoa.review.domain.AssociatedStudy;
+import com.woowacourse.moamoa.review.domain.Review;
+import com.woowacourse.moamoa.review.domain.repository.ReviewRepository;
+import com.woowacourse.moamoa.review.service.response.ReviewResponse;
+import com.woowacourse.moamoa.review.service.response.ReviewsResponse;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+public class SearchingReviewService {
+
+    private final ReviewRepository reviewRepository;
+
+    public ReviewsResponse getReviewsByStudy(Long studyId, Integer size) {
+        final AssociatedStudy associatedStudy = new AssociatedStudy(studyId);
+
+        final List<Review> reviews = reviewRepository.findAllByAssociatedStudy(associatedStudy);
+
+        if (size != null) {
+            return makeReviewsResponse(reviews.subList(0, size), reviews.size());
+        }
+
+        return makeReviewsResponse(reviews, reviews.size());
+    }
+
+    private ReviewsResponse makeReviewsResponse(final List<Review> reviews, final int totalCount) {
+        final List<ReviewResponse> reviewResponses = reviews.stream()
+                .map(ReviewResponse::new)
+                .collect(toList());
+
+        return new ReviewsResponse(reviewResponses, totalCount);
+    }
+}