[fix] 홈피드 문항 번호로 세트 조회하던 문제 해결 및 풀이 횟수 통계 업데이트

src/main/java/com/moplus/moplus_server/client/homefeed/service/HomeFeedFacadeService.java

@@ -10,7 +10,6 @@
 import com.moplus.moplus_server.client.submit.service.ProblemSubmitGetService;
 import com.moplus.moplus_server.domain.problemset.service.ProblemSetGetService;
 import com.moplus.moplus_server.member.domain.Member;
-import com.moplus.moplus_server.statistic.Problem.domain.ProblemSetStatistic;
 import com.moplus.moplus_server.statistic.Problem.repository.ProblemSetStatisticRepository;
 import java.time.DayOfWeek;
 import java.time.LocalDate;
@@ -38,28 +37,23 @@ public class HomeFeedFacadeService {
 
     @Transactional(readOnly = true)
     public HomeFeedResponse getHomeFeed(Member member) {
-        log.info("홈피드 조회 시작 - memberId: {}, 조회 기간: {} ~ {}", member.getId(), monday, friday);
         Long memberId = member.getId();
 
         List<Publish> publishes = publishGetService.getPublishesBetweenDates(monday, friday);
-        log.info("조회된 발행 개수: {}", publishes.size());
 
         List<DailyProgressResponse> dailyProgresses = getDailyProgresses(memberId, publishes);
-        log.info("일일 진행 현황 생성 완료 - 개수: {}", dailyProgresses.size());
 
         List<ProblemSetHomeFeedResponse> problemSets = getWeekdayProblemSets(publishes);
-        log.info("문제 세트 응답 생성 완료 - 개수: {}", problemSets.size());
 
         return HomeFeedResponse.of(dailyProgresses, problemSets);
     }
 
     private List<DailyProgressResponse> getDailyProgresses(Long memberId, List<Publish> publishes) {
-        log.info("일일 진행 현황 조회 시작 - memberId: {}", memberId);
-
-        Map<LocalDate, ProgressStatus> progressStatuses = problemSubmitGetService.getProgressStatuses(memberId, publishes);
-        log.info("진행 상태 조회 완료 - 상태 개수: {}", progressStatuses.size());
-        progressStatuses.forEach((date, status) -> 
-            log.info("진행 상태 - 날짜: {}, 상태: {}", date, status));
+
+        Map<LocalDate, ProgressStatus> progressStatuses = problemSubmitGetService.getProgressStatuses(memberId,
+                publishes);
+        progressStatuses.forEach((date, status) ->
+                log.info("진행 상태 - 날짜: {}, 상태: {}", date, status));
 
         List<DailyProgressResponse> responses = new ArrayList<>();
         for (LocalDate date = monday; !date.isAfter(friday); date = date.plusDays(1)) {
@@ -72,37 +66,31 @@ private List<DailyProgressResponse> getDailyProgresses(Long memberId, List<Publi
     }
 
     private List<ProblemSetHomeFeedResponse> getWeekdayProblemSets(List<Publish> publishes) {
-        log.info("주간 문제 세트 조회 시작 - 발행 개수: {}", publishes.size());
 
         Map<LocalDate, Publish> publishByDate = publishes.stream()
                 .collect(Collectors.toMap(Publish::getPublishedDate, publish -> publish));
-        log.info("날짜별 발행 매핑 완료 - 매핑 개수: {}", publishByDate.size());
 
-        publishByDate.forEach((date, publish) -> 
-            log.info("발행 정보 - 날짜: {}, 발행 ID: {}, 문제 세트 ID: {}", 
-                    date, publish.getId(), publish.getProblemSetId()));
+        publishByDate.forEach((date, publish) ->
+                log.info("발행 정보 - 날짜: {}, 발행 ID: {}, 문제 세트 ID: {}",
+                        date, publish.getId(), publish.getProblemSetId()));
 
         List<Long> problemSetIds = publishes.stream()
                 .map(Publish::getProblemSetId)
                 .toList();
-        log.info("문제 세트 ID 추출 완료 - ID 목록: {}", problemSetIds);
 
         Map<Long, ProblemSetGetResponse> problemSetMap = problemSetGetService.getProblemSets(problemSetIds).stream()
                 .collect(Collectors.toMap(ProblemSetGetResponse::id, response -> response));
-        log.info("문제 세트 정보 조회 완료 - 조회된 세트 개수: {}", problemSetMap.size());
 
         List<ProblemSetHomeFeedResponse> responses = new ArrayList<>();
         for (LocalDate date = monday; !date.isAfter(friday); date = date.plusDays(1)) {
-            log.info("날짜별 응답 생성 시작 - 날짜: {}", date);
-
+
             Publish publish = publishByDate.get(date);
             if (publish != null) {
                 ProblemSetGetResponse problemSet = problemSetMap.get(publish.getProblemSetId());
-                Long submitCount = problemSetStatisticRepository.findById(problemSet.id())
-                        .map(ProblemSetStatistic::getSubmitCount)
-                        .orElse(0L);
-
-                log.info("응답 생성 - 날짜: {}, 발행 ID: {}, 문제 세트 ID: {}, 제출 수: {}", 
+                Long submitCount = problemSetStatisticRepository.findByProblemSetIdElseThrow(problemSet.id())
+                        .getSubmitCount();
+
+                log.info("응답 생성 - 날짜: {}, 발행 ID: {}, 문제 세트 ID: {}, 제출 수: {}",
                         date, publish.getId(), problemSet.id(), submitCount);
                 responses.add(ProblemSetHomeFeedResponse.of(date, publish.getId(), problemSet, submitCount));
             } else {
@@ -111,7 +99,6 @@ private List<ProblemSetHomeFeedResponse> getWeekdayProblemSets(List<Publish> pub
             }
         }
 
-        log.info("주간 문제 세트 응답 생성 완료 - 총 응답 개수: {}", responses.size());
         return responses;
     }
 } 

src/main/java/com/moplus/moplus_server/client/submit/service/ClientSubmitService.java

@@ -1,6 +1,7 @@
 package com.moplus.moplus_server.client.submit.service;
 
 
+import com.moplus.moplus_server.admin.publish.domain.Publish;
 import com.moplus.moplus_server.client.submit.domain.ChildProblemSubmit;
 import com.moplus.moplus_server.client.submit.domain.ChildProblemSubmitStatus;
 import com.moplus.moplus_server.client.submit.domain.ProblemSubmit;
@@ -17,7 +18,13 @@
 import com.moplus.moplus_server.domain.problem.domain.problem.Problem;
 import com.moplus.moplus_server.domain.problem.repository.ChildProblemRepository;
 import com.moplus.moplus_server.domain.problem.repository.ProblemRepository;
+import com.moplus.moplus_server.domain.problemset.domain.ProblemSet;
+import com.moplus.moplus_server.domain.problemset.repository.ProblemSetRepository;
+import com.moplus.moplus_server.domain.problemset.service.ProblemSetGetService;
 import com.moplus.moplus_server.domain.publish.repository.PublishRepository;
+import com.moplus.moplus_server.statistic.Problem.domain.StatisticEntityTarget;
+import com.moplus.moplus_server.statistic.Problem.service.CountStatisticsGetService;
+import com.moplus.moplus_server.statistic.Problem.service.CountStatisticsUpdateService;
 import java.util.List;
 import java.util.Optional;
 import lombok.RequiredArgsConstructor;
@@ -33,22 +40,39 @@ public class ClientSubmitService {
     private final ChildProblemSubmitRepository childProblemSubmitRepository;
     private final PublishRepository publishRepository;
     private final ChildProblemRepository childProblemRepository;
+    private final CountStatisticsUpdateService countStatisticsUpdateService;
+    private final ProblemSetGetService problemSetGetService;
+    private final ProblemSetRepository problemSetRepository;
+    private final CountStatisticsGetService countStatisticsGetService;
+
+    private static Long getFirstProblemInProblemSet(ProblemSet problemSet) {
+        return problemSet.getProblemIds().get(0);
+    }
 
     @Transactional
     public void createProblemSubmit(Long memberId, ProblemSubmitCreateRequest request) {
 
         // 존재하는 발행인지 검증
-        publishRepository.existsByIdElseThrow(request.publishId());
+        Publish publish = publishRepository.findByIdElseThrow(request.publishId());
         // 존재하는 문항인지 검증
         problemRepository.existsByIdElseThrow(request.problemId());
 
         // 제출이력이 없을때만 생성
-        Optional<ProblemSubmit> existingProblemSubmit = problemSubmitRepository.findByMemberIdAndPublishIdAndProblemId(memberId,
+        Optional<ProblemSubmit> existingProblemSubmit = problemSubmitRepository.findByMemberIdAndPublishIdAndProblemId(
+                memberId,
                 request.publishId(), request.problemId());
         if (existingProblemSubmit.isEmpty()) {
             ProblemSubmit problemSubmit = request.toEntity(memberId);
             problemSubmitRepository.save(problemSubmit);
         }
+
+        //문제 풀이 통계 업데이트
+        countStatisticsUpdateService.createStatistics(request.problemId(), StatisticEntityTarget.PROBLEM);
+        ProblemSet problemSet = problemSetRepository.findByIdElseThrow(publish.getProblemSetId());
+        if (getFirstProblemInProblemSet(problemSet).equals(request.problemId())) {
+            //TODO: 현재는 첫번째 문항을 풀었을 때 set 풀이 count가 올라가지만 나중에는 어떤 문제를 풀든 첫 문제를 풀면 count가 올라가야해요
+            countStatisticsUpdateService.createStatistics(publish.getProblemSetId(), StatisticEntityTarget.PROBLEM_SET);
+        }
     }
 
     @Transactional
@@ -80,7 +104,8 @@ public void createChildProblemSubmit(Long memberId, ChildProblemSubmitCreateRequ
         problemRepository.existsByIdElseThrow(request.problemId());
 
         // 문항제출 이력이 없으면 문항제출 생성
-        Optional<ProblemSubmit> existingProblemSubmit = problemSubmitRepository.findByMemberIdAndPublishIdAndProblemId(memberId,
+        Optional<ProblemSubmit> existingProblemSubmit = problemSubmitRepository.findByMemberIdAndPublishIdAndProblemId(
+                memberId,
                 request.publishId(), request.problemId());
         if (existingProblemSubmit.isEmpty()) {
             ProblemSubmit problemSubmit = ProblemSubmit.builder()
@@ -100,7 +125,8 @@ public void createChildProblemSubmit(Long memberId, ChildProblemSubmitCreateRequ
         for (ChildProblem childProblem : childProblems) {
             Long childProblemId = childProblem.getId();
 
-            Optional<ChildProblemSubmit> existingChildProblemSubmit = childProblemSubmitRepository.findByMemberIdAndPublishIdAndChildProblemId(memberId,
+            Optional<ChildProblemSubmit> existingChildProblemSubmit = childProblemSubmitRepository.findByMemberIdAndPublishIdAndChildProblemId(
+                    memberId,
                     request.publishId(), childProblemId);
             if (existingChildProblemSubmit.isEmpty()) {
                 ChildProblemSubmit childProblemSubmit = ChildProblemSubmit.builder()
@@ -115,7 +141,8 @@ public void createChildProblemSubmit(Long memberId, ChildProblemSubmitCreateRequ
     }
 
     @Transactional
-    public ChildProblemSubmitUpdateResponse updateChildProblemSubmit(Long memberId, ChildProblemSubmitUpdateRequest request) {
+    public ChildProblemSubmitUpdateResponse updateChildProblemSubmit(Long memberId,
+                                                                     ChildProblemSubmitUpdateRequest request) {
 
         // 존재하는 발행인지 검증
         publishRepository.existsByIdElseThrow(request.publishId());
@@ -124,10 +151,12 @@ public ChildProblemSubmitUpdateResponse updateChildProblemSubmit(Long memberId,
         ChildProblem childProblem = childProblemRepository.findByIdElseThrow(request.childProblemId());
 
         //새끼문항 제출 데이터 조회
-        ChildProblemSubmit childProblemSubmit = childProblemSubmitRepository.findByMemberIdAndPublishIdAndChildProblemIdElseThrow(memberId,
+        ChildProblemSubmit childProblemSubmit = childProblemSubmitRepository.findByMemberIdAndPublishIdAndChildProblemIdElseThrow(
+                memberId,
                 request.publishId(), request.childProblemId());
         // 제출한 답안에 대한 상태 결정
-        ChildProblemSubmitStatus status = ChildProblemSubmitStatus.determineStatus(childProblemSubmit.getStatus(), request.answer(),
+        ChildProblemSubmitStatus status = ChildProblemSubmitStatus.determineStatus(childProblemSubmit.getStatus(),
+                request.answer(),
                 childProblem.getAnswer());
 
         childProblemSubmit.updateStatus(status);
@@ -144,7 +173,8 @@ public void updateChildProblemSubmitIncorrect(Long memberId, ChildProblemSubmitU
         ChildProblem childProblem = childProblemRepository.findByIdElseThrow(request.childProblemId());
 
         //새끼문항 제출 데이터 조회
-        ChildProblemSubmit childProblemSubmit = childProblemSubmitRepository.findByMemberIdAndPublishIdAndChildProblemIdElseThrow(memberId,
+        ChildProblemSubmit childProblemSubmit = childProblemSubmitRepository.findByMemberIdAndPublishIdAndChildProblemIdElseThrow(
+                memberId,
                 request.publishId(), request.childProblemId());
         // 틀림 처리
         childProblemSubmit.updateStatusIncorrect();

src/main/java/com/moplus/moplus_server/client/submit/service/ProblemSubmitGetService.java

@@ -22,14 +22,15 @@ public class ProblemSubmitGetService {
     private final ProblemSetRepository problemSetRepository;
 
     @Transactional(readOnly = true)
-    public ProgressStatus getProgressStatus(Long memberId, Long publishId) {
+    public ProgressStatus getProgressStatus(Long memberId, Publish publish) {
+        Long publishId = publish.getId();
         List<ProblemSubmit> submits = problemSubmitRepository.findByMemberIdAndPublishId(memberId, publishId);
 
         if (submits.isEmpty()) {
             return ProgressStatus.NOT_STARTED;
         }
 
-        ProblemSet problemSet = problemSetRepository.findByIdElseThrow(submits.get(0).getProblemId());
+        ProblemSet problemSet = problemSetRepository.findByIdElseThrow(publish.getProblemSetId());
 
         int totalProblems = problemSet.getProblemIds().size();
 
@@ -43,8 +44,8 @@ public ProgressStatus getProgressStatus(Long memberId, Long publishId) {
     public Map<LocalDate, ProgressStatus> getProgressStatuses(Long memberId, List<Publish> publishes) {
         return publishes.stream()
                 .collect(Collectors.toMap(
-                    Publish::getPublishedDate,
-                    publish -> getProgressStatus(memberId, publish.getId())
+                        Publish::getPublishedDate,
+                        publish -> getProgressStatus(memberId, publish)
                 ));
     }
 } 

src/main/java/com/moplus/moplus_server/statistic/Problem/repository/ProblemSetStatisticRepository.java

@@ -3,11 +3,20 @@
 import com.moplus.moplus_server.global.error.exception.ErrorCode;
 import com.moplus.moplus_server.global.error.exception.NotFoundException;
 import com.moplus.moplus_server.statistic.Problem.domain.ProblemSetStatistic;
+import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
 
 public interface ProblemSetStatisticRepository extends JpaRepository<ProblemSetStatistic, Long> {
+
+    Optional<ProblemSetStatistic> findByProblemSetId(Long id);
+
+    default ProblemSetStatistic findByProblemSetIdElseThrow(Long id) {
+        return findByProblemSetId(id)
+                .orElseThrow(() -> new NotFoundException(ErrorCode.PROBLEM_SET_STATISTIC_NOT_FOUND));
+    }
+
     default ProblemSetStatistic findByIdElseThrow(Long id) {
         return findById(id)
-            .orElseThrow(() -> new NotFoundException(ErrorCode.PROBLEM_SET_STATISTIC_NOT_FOUND));
+                .orElseThrow(() -> new NotFoundException(ErrorCode.PROBLEM_SET_STATISTIC_NOT_FOUND));
     }
 } 

src/main/java/com/moplus/moplus_server/statistic/Problem/service/CountStatisticsGetService.java

@@ -12,7 +12,7 @@ public class CountStatisticsGetService {
     private final ProblemSetStatisticRepository problemSetStatisticRepository;
 
     @Transactional(readOnly = true)
-    public Long getProblemSetCount(Long id) {
-        return problemSetStatisticRepository.findByIdElseThrow(id).getSubmitCount();
+    public Long getProblemSetCountBySetId(Long problemSetId) {
+        return problemSetStatisticRepository.findByProblemSetIdElseThrow(problemSetId).getSubmitCount();
     }
 }

src/main/java/com/moplus/moplus_server/statistic/Problem/service/CountStatisticsUpdateService.java

@@ -1,5 +1,8 @@
 package com.moplus.moplus_server.statistic.Problem.service;
 
+import com.moplus.moplus_server.statistic.Problem.domain.ChildProblemStatistic;
+import com.moplus.moplus_server.statistic.Problem.domain.ProblemSetStatistic;
+import com.moplus.moplus_server.statistic.Problem.domain.ProblemStatistic;
 import com.moplus.moplus_server.statistic.Problem.domain.StatisticCounter;
 import com.moplus.moplus_server.statistic.Problem.domain.StatisticEntityTarget;
 import com.moplus.moplus_server.statistic.Problem.domain.StatisticFieldType;
@@ -18,16 +21,25 @@ public class CountStatisticsUpdateService {
     private final ChildProblemStatisticRepository childProblemStatisticRepository;
 
     @Transactional
-    public void updateStatistics(Long id, StatisticFieldType type, StatisticEntityTarget target) {
-        StatisticCounter statistic = findStatistic(id, target);
+    public void updateStatistics(Long statisticId, StatisticFieldType type, StatisticEntityTarget target) {
+        StatisticCounter statistic = findStatistic(statisticId, target);
         statistic.updateCount(type);
     }
 
-    private StatisticCounter findStatistic(Long id, StatisticEntityTarget target) {
+    @Transactional
+    public StatisticCounter createStatistics(Long statisticId, StatisticEntityTarget target) {
+        return switch (target) {
+            case PROBLEM -> problemStatisticRepository.save(new ProblemStatistic(statisticId));
+            case PROBLEM_SET -> problemSetStatisticRepository.save(new ProblemSetStatistic(statisticId));
+            case CHILD_PROBLEM -> childProblemStatisticRepository.save(new ChildProblemStatistic(statisticId));
+        };
+    }
+
+    private StatisticCounter findStatistic(Long statisticId, StatisticEntityTarget target) {
         return switch (target) {
-            case PROBLEM -> problemStatisticRepository.findByIdElseThrow(id);
-            case PROBLEM_SET -> problemSetStatisticRepository.findByIdElseThrow(id);
-            case CHILD_PROBLEM -> childProblemStatisticRepository.findByIdElseThrow(id);
+            case PROBLEM -> problemStatisticRepository.findByIdElseThrow(statisticId);
+            case PROBLEM_SET -> problemSetStatisticRepository.findByIdElseThrow(statisticId);
+            case CHILD_PROBLEM -> childProblemStatisticRepository.findByIdElseThrow(statisticId);
         };
     }
 }