Merge pull request #212 from prgrms-web-devcourse-final-project/feature/EA3-156-review-implement

[EA3-156] Feature: 리뷰 대상 스터디 조회 수정

Author: dbrkdgus00

src/main/java/grep/neogulcoder/domain/buddy/entity/BuddyEnergy.java

@@ -48,4 +48,11 @@ public void updateEnergy(ReviewType reviewType) {
             this.level -= 1;
         }
     }
+
+    public BuddyEnergyReason findReasonFrom(ReviewType reviewType) {
+        if(reviewType.isPositive()){
+            return BuddyEnergyReason.POSITIVE_REVIEW;
+        }
+        return BuddyEnergyReason.NEGATIVE_REVIEW;
+    }
 }

src/main/java/grep/neogulcoder/domain/review/ReviewType.java

@@ -21,4 +21,8 @@ public boolean isSameType(ReviewType reviewType) {
     public boolean isNotSameType(ReviewType reviewType) {
         return !isSameType(reviewType);
     }
+
+    public boolean isPositive() {
+        return this == GOOD || this == EXCELLENT;
+    }
 }

src/main/java/grep/neogulcoder/domain/review/controller/ReviewController.java

@@ -32,8 +32,7 @@ public ApiResponse<ReviewTargetUsersInfo> getReviewTargetUsersInfo(@PathVariable
     }
 
     @GetMapping("/studies/me")
-    public ApiResponse<ReviewTargetStudiesInfo> getReviewTargetStudiesInfo(@AuthenticationPrincipal Principal userDetails,
-                                                                           LocalDateTime currentDateTime) {
+    public ApiResponse<ReviewTargetStudiesInfo> getReviewTargetStudiesInfo(@AuthenticationPrincipal Principal userDetails) {
         ReviewTargetStudiesInfo response = reviewService.getReviewTargetStudiesInfo(userDetails.getUserId(), LocalDateTime.now());
         return ApiResponse.success(response);
     }

src/main/java/grep/neogulcoder/domain/review/controller/ReviewSpecification.java

@@ -54,7 +54,7 @@ public interface ReviewSpecification {
                     - `studyInfo`: 리뷰 가능한 스터디의 이름과 이미지 정보 리스트입니다.
                     """
     )
-    ApiResponse<ReviewTargetStudiesInfo> getReviewTargetStudiesInfo(Principal userDetails, LocalDateTime currentDateTime);
+    ApiResponse<ReviewTargetStudiesInfo> getReviewTargetStudiesInfo(Principal userDetails);
 
     @Operation(summary = "리뷰 생성", description = "스터디에 대한 리뷰를 작성 합니다.")
     ApiResponse<Long> save(ReviewSaveRequest request, Principal userDetails);

src/main/java/grep/neogulcoder/domain/review/service/ReviewService.java

@@ -1,6 +1,10 @@
 package grep.neogulcoder.domain.review.service;
 
-import grep.neogulcoder.domain.buddy.service.BuddyEnergyService;
+import grep.neogulcoder.domain.buddy.entity.BuddyEnergy;
+import grep.neogulcoder.domain.buddy.entity.BuddyLog;
+import grep.neogulcoder.domain.buddy.exception.BuddyEnergyNotFoundException;
+import grep.neogulcoder.domain.buddy.repository.BuddyEnergyLogRepository;
+import grep.neogulcoder.domain.buddy.repository.BuddyEnergyRepository;
 import grep.neogulcoder.domain.review.*;
 import grep.neogulcoder.domain.review.controller.dto.response.MyReviewTagsInfo;
 import grep.neogulcoder.domain.review.controller.dto.response.ReviewContentsPagingInfo;
@@ -14,8 +18,10 @@
 import grep.neogulcoder.domain.review.repository.ReviewRepository;
 import grep.neogulcoder.domain.review.repository.ReviewTagRepository;
 import grep.neogulcoder.domain.review.service.request.ReviewSaveServiceRequest;
+import grep.neogulcoder.domain.study.Studies;
 import grep.neogulcoder.domain.study.Study;
 import grep.neogulcoder.domain.study.StudyMember;
+import grep.neogulcoder.domain.study.StudyMembers;
 import grep.neogulcoder.domain.study.repository.StudyMemberQueryRepository;
 import grep.neogulcoder.domain.study.repository.StudyMemberRepository;
 import grep.neogulcoder.domain.study.repository.StudyRepository;
@@ -30,11 +36,13 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDateTime;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static grep.neogulcoder.domain.buddy.exception.code.BuddyEnergyErrorCode.BUDDY_ENERGY_NOT_FOUND;
 import static grep.neogulcoder.domain.review.ReviewErrorCode.ALREADY_REVIEW_WRITE_USER;
 import static grep.neogulcoder.domain.review.ReviewErrorCode.STUDY_NOT_FOUND;
 
@@ -54,7 +62,8 @@ public class ReviewService {
     private final MyReviewTagRepository myReviewTagRepository;
     private final ReviewTagRepository reviewTagRepository;
 
-    private final BuddyEnergyService buddyEnergyService;
+    private final BuddyEnergyRepository buddyEnergyRepository;
+    private final BuddyEnergyLogRepository buddyEnergyLogRepository;
 
     public ReviewTargetUsersInfo getReviewTargetUsersInfo(long studyId, long userId) {
         List<StudyMember> studyMembers = studyMemberRepository.findFetchStudyByStudyId(studyId);
@@ -67,39 +76,22 @@ public ReviewTargetUsersInfo getReviewTargetUsersInfo(long studyId, long userId)
     }
 
     public ReviewTargetStudiesInfo getReviewTargetStudiesInfo(long userId, LocalDateTime currentDateTime) {
-        List<StudyMember> studyMembers = studyMemberQueryRepository.findMembersByUserId(userId);
-        List<Study> studies = extractConnectedStudies(studyMembers);
-        List<Study> reviewableStudies = filteredReviewableStudies(currentDateTime, studies);
+        List<Study> studies = findReviewableStudies(userId, currentDateTime);
+        List<StudyMember> studyMembers = findJoinedStudyMemberBy(studies);
+        List<StudyMember> otherMembers = StudyMembers.of(studyMembers).excludeByUser(userId);
 
-        List<Long> studyIds = reviewableStudies.stream()
-                .map(Study::getId)
-                .toList();
-
-        List<StudyMember> studyMemberList = studyMemberQueryRepository.findByIdIn(studyIds);
-
-
-        Map<Long, Long> groupedStudyIdCountMap = studyMemberList.stream()
-                .map(StudyMember::getStudy)
-                .collect(
-                        Collectors.groupingBy(
-                                Study::getId,
-                                Collectors.counting()
-                        )
-                );
+        List<ReviewEntity> myReviews = reviewQueryRepository.findReviewsByReviewerInStudies(
+                Studies.of(studies).extractId(), userId
+        );
 
-        List<ReviewEntity> myReviews = reviewQueryRepository.findReviewsByReviewerInStudies(studyIds, userId);
-        Map<Long, List<ReviewEntity>> groupedStudyIdMap = myReviews.stream()
-                .collect(
-                        Collectors.groupingBy(
-                                ReviewEntity::getStudyId
-                        )
-                );
+        Map<Long, Long> groupedStudyIdCountMap = StudyMembers.of(otherMembers).getGroupedStudyIdCountMap();
+        Map<Long, List<ReviewEntity>> groupedStudyIdMap = getGroupedStudyIdMap(myReviews);
 
-        List<Study> studies1 = studies.stream()
-                .filter(study -> groupedStudyIdCountMap.get(study.getId()) - 1 != groupedStudyIdMap.get(study.getId()).size())
+        List<Study> reviewTargetStudies = studies.stream()
+                .filter(study -> isCompletedReview(study, groupedStudyIdCountMap, groupedStudyIdMap))
                 .toList();
 
-        return ReviewTargetStudiesInfo.of(studies1);
+        return ReviewTargetStudiesInfo.of(reviewTargetStudies);
     }
 
     @Transactional
@@ -108,15 +100,16 @@ public long save(ReviewSaveServiceRequest request, long writeUserId) {
             throw new BusinessException(ALREADY_REVIEW_WRITE_USER);
         }
 
-        Study study = findValidStudy(request.getStudyId());
+        Study study = studyRepository.findById(request.getStudyId())
+                .orElseThrow(() -> new NotFoundException(STUDY_NOT_FOUND));
+
         ReviewTags reviewTags = ReviewTags.from(convertStringToReviewTag(request.getReviewTag()));
         ReviewType reviewType = reviewTags.ensureSingleReviewType();
 
         Review review = request.toReview(reviewTags.getReviewTags(), reviewType, writeUserId);
         List<ReviewTagEntity> reviewTagEntities = mapToReviewTagEntities(reviewTags);
 
-        buddyEnergyService.updateEnergyByReview(request.getTargetUserId(), reviewType);
-
+        updatedBuddyEnergy(writeUserId, reviewType);
         return reviewRepository.save(ReviewEntity.from(review, reviewTagEntities, study.getId())).getId();
     }
 
@@ -160,23 +153,39 @@ private List<User> excludeMe(List<User> users, long userId) {
                 .toList();
     }
 
-    private List<Study> filteredReviewableStudies(LocalDateTime currentDateTime, List<Study> studies) {
-        return studies.stream()
+    private List<Study> findReviewableStudies(long userId, LocalDateTime currentDateTime) {
+        List<StudyMember> myStudyMembers = studyMemberQueryRepository.findMembersByUserId(userId);
+        List<Study> myStudies = extractConnectedStudies(myStudyMembers);
+
+        return myStudies.stream()
                 .filter(study -> study.isReviewableAt(currentDateTime))
                 .toList();
     }
 
+    private boolean isCompletedReview(Study study, Map<Long, Long> groupedStudyIdCountMap, Map<Long, List<ReviewEntity>> groupedStudyIdMap) {
+        return groupedStudyIdCountMap.getOrDefault(study.getId(), 0L) != groupedStudyIdMap.getOrDefault(study.getId(), Collections.emptyList()).size();
+    }
+
+    private List<StudyMember> findJoinedStudyMemberBy(List<Study> studies) {
+        List<Long> studyIds = Studies.of(studies).extractId();
+        return studyMemberQueryRepository.findByIdIn(studyIds);
+    }
+
+    private Map<Long, List<ReviewEntity>> getGroupedStudyIdMap(List<ReviewEntity> myReviews) {
+        return myReviews.stream()
+                .collect(
+                        Collectors.groupingBy(
+                                ReviewEntity::getStudyId
+                        )
+                );
+    }
+
     private List<Study> extractConnectedStudies(List<StudyMember> studyMembers) {
         return studyMembers.stream()
                 .map(StudyMember::getStudy)
                 .toList();
     }
 
-    private Study findValidStudy(long studyId) {
-        return studyRepository.findById(studyId)
-                .orElseThrow(() -> new NotFoundException(STUDY_NOT_FOUND));
-    }
-
     private boolean isAlreadyWrittenReviewBy(long studyId, long targetUserId, long writeUserId) {
         return reviewQueryRepository.findBy(studyId, targetUserId, writeUserId) != null;
     }
@@ -192,6 +201,15 @@ private List<ReviewTagEntity> mapToReviewTagEntities(ReviewTags reviewTags) {
         return reviewTagRepository.findByReviewTagIn(reviewTagDescriptions);
     }
 
+    private BuddyEnergy updatedBuddyEnergy(long writeUserId, ReviewType reviewType) {
+        BuddyEnergy energy = buddyEnergyRepository.findByUserId(writeUserId)
+                .orElseThrow(() -> new BuddyEnergyNotFoundException(BUDDY_ENERGY_NOT_FOUND));
+
+        energy.updateEnergy(reviewType);
+        buddyEnergyLogRepository.save(BuddyLog.of(energy, energy.findReasonFrom(reviewType)));
+        return energy;
+    }
+
     private List<ReviewTag> extractReviewTags(List<ReviewEntity> myReviews) {
         List<ReviewTagEntity> reviewTagEntities = getReviewTagEntities(myReviews);
         return reviewTagEntities.stream()

src/main/java/grep/neogulcoder/domain/study/Studies.java

@@ -0,0 +1,22 @@
+package grep.neogulcoder.domain.study;
+
+import java.util.List;
+
+public class Studies {
+
+    private final List<Study> studies;
+
+    private Studies(List<Study> studies) {
+        this.studies = studies;
+    }
+
+    public static Studies of(List<Study> studies){
+        return new Studies(studies);
+    }
+
+    public List<Long> extractId(){
+        return this.studies.stream()
+                .map(Study::getId)
+                .toList();
+    }
+}

src/main/java/grep/neogulcoder/domain/study/StudyMember.java

@@ -46,10 +46,10 @@ public static StudyMember createLeader(Study study, Long userId) {
 
     public static StudyMember createMember(Study study, Long userId) {
         return StudyMember.builder()
-            .study(study)
-            .userId(userId)
-            .role(StudyMemberRole.MEMBER)
-            .build();
+                .study(study)
+                .userId(userId)
+                .role(StudyMemberRole.MEMBER)
+                .build();
     }
 
     public void delete() {

src/main/java/grep/neogulcoder/domain/study/StudyMembers.java

@@ -0,0 +1,35 @@
+package grep.neogulcoder.domain.study;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class StudyMembers {
+
+    private List<StudyMember> studyMembers;
+
+    private StudyMembers(List<StudyMember> studyMembers) {
+        this.studyMembers = studyMembers;
+    }
+
+    public static StudyMembers of(List<StudyMember> studyMembers){
+        return new StudyMembers(studyMembers);
+    }
+
+    public List<StudyMember> excludeByUser(long userId){
+        return this.studyMembers.stream()
+                .filter(studyMember -> studyMember.getUserId() != userId)
+                .toList();
+    }
+
+    public Map<Long, Long> getGroupedStudyIdCountMap() {
+        return this.studyMembers.stream()
+                .map(StudyMember::getStudy)
+                .collect(
+                        Collectors.groupingBy(
+                                Study::getId,
+                                Collectors.counting()
+                        )
+                );
+    }
+}

src/main/java/grep/neogulcoder/domain/study/repository/StudyMemberQueryRepository.java

@@ -75,7 +75,7 @@ public List<ExtendParticipationResponse> findExtendParticipation(Long studyId) {
     public List<StudyMember> findByIdIn(List<Long> studyIds) {
         return queryFactory.selectFrom(studyMember)
                 .where(
-                        studyMember.id.in(studyIds),
+                        studyMember.study.id.in(studyIds),
                         studyMember.activated.isTrue()
                 )
                 .join(studyMember.study, study).fetchJoin()