feat(analysis): Repository 조회 관련 메서드 개선

Hyeseung-OH · Hyeseung-OH · commit d11ddf6679f4 · 2025-10-20T15:39:46.000+09:00
diff --git a/backend/src/main/java/com/backend/domain/analysis/controller/AnalysisController.java b/backend/src/main/java/com/backend/domain/analysis/controller/AnalysisController.java
@@ -1,11 +1,11 @@
 package com.backend.domain.analysis.controller;
 
+import com.backend.domain.analysis.dto.request.AnalysisRequest;
 import com.backend.domain.analysis.dto.response.AnalysisResultResponseDto;
 import com.backend.domain.analysis.dto.response.HistoryResponseDto;
-import com.backend.domain.analysis.dto.request.AnalysisRequest;
 import com.backend.domain.analysis.entity.AnalysisResult;
-import com.backend.domain.analysis.entity.Score;
 import com.backend.domain.analysis.service.AnalysisService;
+import com.backend.domain.repository.dto.response.RepositoryResponse;
 import com.backend.domain.repository.entity.Repositories;
 import com.backend.domain.repository.service.RepositoryService;
 import com.backend.global.exception.BusinessException;
@@ -18,7 +18,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 @RestController
 @RequiredArgsConstructor
@@ -38,59 +37,79 @@ public ResponseEntity<ApiResponse<Void>> analyzeRepository(@RequestBody Analysis
         return ResponseEntity.ok(ApiResponse.success());
     }
 
-    // GET: 사용자 히스토리 전체 목록 조회
-    @GetMapping("/{memberId}")
+    // GET: 사용자의 모든 Repository 목록 조회
+    @GetMapping("/{memberId}/repositories")
     @Transactional(readOnly = true)
-    public ResponseEntity<List<HistoryResponseDto>> getMemberHistory(@PathVariable Long memberId){
+    public ResponseEntity<List<RepositoryResponse>> getMemberHistory(
+            @PathVariable Long memberId
+    ){
         if (memberId == null) {
             throw new BusinessException(ErrorCode.INVALID_INPUT_VALUE);
         }
 
-        List<Repositories> repositories = repositoryService.findRepositoryByMember(memberId);
-        List<HistoryResponseDto> historyList = new ArrayList<>();
+        List<RepositoryResponse> repositories = repositoryService
+                .findRepositoryByMember(memberId)
+                .stream()
+                .map(RepositoryResponse::new)
+                .toList();
 
-        for (Repositories repo : repositories) {
-            Optional<AnalysisResult> optionalAnalysis = analysisService.findByRepositoryId(repo.getId());
+        return ResponseEntity.ok(repositories);
+    }
 
-            if (optionalAnalysis.isEmpty()) {
-                continue;
-            }
+    // GET: 특정 Repository의 분석 히스토리 조회, 모든 분석 결과 조회
+    @GetMapping("/{memberId}/repositories/{repositoriesId}")
+    @Transactional(readOnly = true)
+    public ResponseEntity<HistoryResponseDto> getAnalysisByRepositoriesId(
+            @PathVariable("memberId") Long memberId,
+            @PathVariable("repositoriesId") Long repoId
+    ){
+        // TODO: 추후 인증/인가 기능 완성 후 소유권 검증 로직 추가
 
-            AnalysisResult analysisResult = optionalAnalysis.get();
-            Score score = analysisResult.getScore();
+        // 1. Repository 정보 조회
+        Repositories repository = repositoryService.findById(repoId)
+                .orElseThrow(() -> new BusinessException(ErrorCode.GITHUB_REPO_NOT_FOUND));
 
-            List<String> languages = repositoryService.findLanguagesByRepisotryId(repo.getId())
-                    .stream()
-                    .map(Enum::name) // RepositoryLanguage -> Language enum
-                    .toList();
+        RepositoryResponse repositoryResponse = new RepositoryResponse(repository);
 
-            HistoryResponseDto dto = new HistoryResponseDto(repo, analysisResult, score, languages);
-            historyList.add(dto);
+        // 2. 분석 결과 목록 조회 (최신순 정렬)
+        List<AnalysisResult> analysisResults =
+                analysisService.getAnalysisResultList(repoId);
+
+        // 3. 버전 DTO 생성 (최신이 가장 큰 번호)
+        List<HistoryResponseDto.AnalysisVersionDto> versions = new ArrayList<>();
+        int versionNumber = analysisResults.size();
+
+        for (AnalysisResult analysis : analysisResults) {
+            versions.add(HistoryResponseDto.AnalysisVersionDto.from(analysis, versionNumber));
+            versionNumber--;
         }
 
-        // 최신순 정렬
-        historyList.sort((a, b) -> b.createDate().compareTo(a.createDate()));
+        // 4. 응답 조합
+        HistoryResponseDto response = HistoryResponseDto.of(repositoryResponse, versions);
 
-        return ResponseEntity.ok(historyList);
+        return ResponseEntity.ok(response);
     }
 
-    // GET: 사용자 분석 결과 조회
-    @GetMapping("/{memberId}/{repositoriesId}")
+    // GET: 특정 분석 결과 상세 조회
+    @GetMapping("/{memberId}/repositories/{repositoryId}/results/{analysisId}")
     @Transactional(readOnly = true)
-    public ResponseEntity<List<AnalysisResultResponseDto>> getAnalysisByRepositoriesId(
-            @PathVariable("memberId") Long memberId,
-            @PathVariable("repositoriesId") Long repoId
-    ){
-        List<AnalysisResult> optionalResult = analysisService.getAnalysisResultList(repoId);
-        List<AnalysisResultResponseDto> resultList = new ArrayList<>();
+    public ResponseEntity<AnalysisResultResponseDto> getAnalysisDetail(
+            @PathVariable Long memberId,
+            @PathVariable Long repositoryId,
+            @PathVariable Long analysisId
+    ) {
+        // TODO: 추후 인증/인가 검증
 
+        // 분석 결과 조회
+        AnalysisResult analysisResult = analysisService.getAnalysisById(analysisId);
 
-        for(AnalysisResult result : optionalResult){
-            Score score = result.getScore();
-            AnalysisResultResponseDto dto = new AnalysisResultResponseDto(result, score);
-            resultList.add(dto);
+        if (!analysisResult.getRepositories().getId().equals(repositoryId)) {
+            throw new BusinessException(ErrorCode.INVALID_INPUT_VALUE);
         }
 
-        return ResponseEntity.ok(resultList);
+        AnalysisResultResponseDto response =
+                new AnalysisResultResponseDto(analysisResult, analysisResult.getScore());
+
+        return ResponseEntity.ok(response);
     }
 }
diff --git a/backend/src/main/java/com/backend/domain/analysis/dto/response/AnalysisResultResponseDto.java b/backend/src/main/java/com/backend/domain/analysis/dto/response/AnalysisResultResponseDto.java
@@ -3,6 +3,10 @@
 import com.backend.domain.analysis.entity.AnalysisResult;
 import com.backend.domain.analysis.entity.Score;
 
+/**
+ * 특정 분석 결과의 상세 정보 응답 DTO
+ * 분석 점수, 피드백 등을 포함
+ */
 public record AnalysisResultResponseDto(
     int totalScore,
     int readmeScore,
diff --git a/backend/src/main/java/com/backend/domain/analysis/dto/response/HistoryResponseDto.java b/backend/src/main/java/com/backend/domain/analysis/dto/response/HistoryResponseDto.java
@@ -1,26 +1,44 @@
 package com.backend.domain.analysis.dto.response;
 
 import com.backend.domain.analysis.entity.AnalysisResult;
-import com.backend.domain.analysis.entity.Score;
-import com.backend.domain.repository.entity.Repositories;
+import com.backend.domain.repository.dto.response.RepositoryResponse;
 
 import java.time.LocalDateTime;
 import java.util.List;
 
+/**
+ * Repository 상세 정보 + 분석 버전 목록 응답 DTO
+ * 특정 Repository의 모든 분석 버전을 조회할 때 사용
+ */
 public record HistoryResponseDto(
-    String repositoryName,
-    LocalDateTime createDate,
-    List<String> languages,
-    int totalScore,
-    boolean publicStatus
+        RepositoryResponse repository,           // Repository 기본 정보
+        List<AnalysisVersionDto> analysisVersions
 ) {
-   public HistoryResponseDto(Repositories repositories, AnalysisResult analysisResult, Score score, List<String> languages){
-       this(
-               repositories.getName(),
-               analysisResult.getCreateDate(),
-               languages,
-               score.getTotalScore(),
-               repositories.isPublicRepository()
-       );
-   }
+    public static HistoryResponseDto of(
+            RepositoryResponse repository,
+            List<AnalysisVersionDto> versions
+    ) {
+        return new HistoryResponseDto(repository, versions);
+    }
+
+    public record AnalysisVersionDto(
+            Long analysisId,
+            LocalDateTime analysisDate,
+            Integer totalScore,
+            String versionLabel
+    ) {
+        public static AnalysisVersionDto from(
+                AnalysisResult analysis,
+                int versionNumber
+        ) {
+            return new AnalysisVersionDto(
+                    analysis.getId(),
+                    analysis.getCreateDate(),
+                    analysis.getScore().getTotalScore(),
+                    String.format("v%d (%s)",
+                            versionNumber,
+                            analysis.getCreateDate().toLocalDate())
+            );
+        }
+    }
 }
diff --git a/backend/src/main/java/com/backend/domain/analysis/service/AnalysisService.java b/backend/src/main/java/com/backend/domain/analysis/service/AnalysisService.java
@@ -1,8 +1,8 @@
 package com.backend.domain.analysis.service;
 
-import com.backend.domain.repository.dto.response.RepositoryData;
 import com.backend.domain.analysis.entity.AnalysisResult;
 import com.backend.domain.analysis.repository.AnalysisResultRepository;
+import com.backend.domain.repository.dto.response.RepositoryData;
 import com.backend.domain.repository.service.RepositoryService;
 import com.backend.global.exception.BusinessException;
 import com.backend.global.exception.ErrorCode;
@@ -12,7 +12,6 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
-import java.util.Optional;
 
 @Slf4j
 @Service
@@ -21,6 +20,12 @@ public class AnalysisService {
     private final RepositoryService repositoryService;
     private final AnalysisResultRepository analysisResultRepository;
 
+    /* Analysis 분석 프로세스 오케스트레이션 담당
+    * 1. GitHub URL 파싱 및 검증
+    * 2. Repository 도메인을 통한 데이터 수집
+    * 3. Evaluation 도메인을 통한 AI 평가
+    * 4. 분석 결과 저장
+    * */
     @Transactional
     public void analyze(String githubUrl) {
         String[] repoInfo = parseGitHubUrl(githubUrl);
@@ -44,6 +49,7 @@ public void analyze(String githubUrl) {
         // TODO: AI 평가 저장
     }
 
+    // GitHub URL 파싱하여 owner와 repo 이름 추출
     private String[] parseGitHubUrl(String githubUrl) {
         log.info("🚩 분석 요청 url: {}", githubUrl);
 
@@ -69,6 +75,7 @@ private String[] parseGitHubUrl(String githubUrl) {
         return new String[]{parts[0].trim(), parts[1].trim()};
     }
 
+    // Repository 데이터 수집 중 발생한 예외 처리
     private BusinessException handleRepositoryFetchError(BusinessException e, String owner, String repo) {
         return switch (e.getErrorCode()) {
             case GITHUB_REPO_NOT_FOUND ->
@@ -79,13 +86,14 @@ private BusinessException handleRepositoryFetchError(BusinessException e, String
         };
     }
 
-    // AnalysisRresult에서 repository id로 분석 결과 찾기
-    public Optional<AnalysisResult> findByRepositoryId(Long RepositoryId) {
-        return analysisResultRepository.findByRepositoriesId(RepositoryId);
+    // 특정 Repository의 모든 분석 결과 조회 (최신순)
+    public List<AnalysisResult> getAnalysisResultList(Long repositoryId){
+        return analysisResultRepository.findAnalysisResultByRepositoriesId(repositoryId);
     }
 
-    // AnalysisResult를 list로 반환
-    public List<AnalysisResult> getAnalysisResultList(Long RepositoryId){
-        return analysisResultRepository.findAnalysisResultByRepositoriesId(RepositoryId);
+    // 분석 결과 ID로 단건 조회
+    public AnalysisResult getAnalysisById(Long analysisId) {
+        return analysisResultRepository.findById(analysisId)
+                .orElseThrow(() -> new BusinessException(ErrorCode.ANALYSIS_NOT_FOUND));
     }
 }
diff --git a/backend/src/main/java/com/backend/domain/repository/dto/response/RepositoryResponse.java b/backend/src/main/java/com/backend/domain/repository/dto/response/RepositoryResponse.java
@@ -5,6 +5,10 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+/**
+ * Repository 기본 정보 응답 DTO
+ * 사용자의 Repository 목록 조회 시 사용
+ */
 public record RepositoryResponse(
         Long id,
         String name,
diff --git a/backend/src/main/java/com/backend/domain/repository/service/RepositoryService.java b/backend/src/main/java/com/backend/domain/repository/service/RepositoryService.java
@@ -2,7 +2,6 @@
 
 import com.backend.domain.repository.dto.response.RepositoryData;
 import com.backend.domain.repository.dto.response.github.*;
-import com.backend.domain.repository.entity.Language;
 import com.backend.domain.repository.entity.Repositories;
 import com.backend.domain.repository.repository.RepositoryJpaRepository;
 import com.backend.domain.repository.service.fetcher.GitHubDataFetcher;
@@ -21,12 +20,13 @@
 import java.time.temporal.ChronoUnit;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 @Service
 @RequiredArgsConstructor
 public class RepositoryService {
 
-    // 임시
+    // TODO: 임시 - 인증/인가 기능 구현 후 실제 로그인한 사용자로 대체 필요
     private final UserRepository userRepository;
 
     private final GitHubDataFetcher gitHubDataFetcher;
@@ -46,13 +46,13 @@ public RepositoryData fetchAndSaveRepository(String owner, String repo) {
         try {
             return fetchCompleteRepositoryData(owner, repo);
         } catch (BusinessException e) {
-            String errorCode = (e.getErrorCode() != null) ? e.getErrorCode().getCode() : "UNKNOWN";
             throw e;
         } catch (Exception e) {
             throw new BusinessException(ErrorCode.INTERNAL_ERROR);
         }
     }
 
+    // Github 저장소 데이터를 수집하고 DB에 저장 및 RepositoryData로 매핑
     @Transactional
     public RepositoryData fetchCompleteRepositoryData(String owner, String repo) {
         RepositoryData data = new RepositoryData();
@@ -97,6 +97,8 @@ public RepositoryData fetchCompleteRepositoryData(String owner, String repo) {
         return data;
     }
 
+    /* Repository Entity를 DB에 저장하거나 기존 데이터 업데이트
+    * 같은 htmlUrl이 존재하면 업데이트, 없으면 신규 데이터 저장 */
     private Repositories saveOrUpdateRepository(RepoResponse repoInfo, String owner, String repo) {
         User defaultUser = userRepository.findAll().stream()
                 .findFirst()
@@ -117,17 +119,17 @@ private Repositories saveOrUpdateRepository(RepoResponse repoInfo, String owner,
                 });
     }
 
-    // Repository에서 member로 리포지토리 찾기
+    // 특정 사용자의 모든 Repository 조회
     public List<Repositories> findRepositoryByMember(Long userId){
         return repositoryJpaRepository.findByUserId(userId);
     }
 
-    // Repository ID로 언어 조회
-    public List<Language> findLanguagesByRepisotryId(Long gitRepositoryId){
-        return repositoryJpaRepository.findLanguagesByRepositoryId(gitRepositoryId);
+    // Repository ID로 단건 조회
+    public Optional<Repositories> findById(Long repositoriesId) {
+        return repositoryJpaRepository.findById(repositoriesId);
     }
 
-    // repository 삭제
+    // Repository 삭제
     @Transactional
     public void delete(Long repositoriesId){
         if (repositoriesId == null) {
diff --git a/backend/src/main/java/com/backend/global/init/BaseInitData.java b/backend/src/main/java/com/backend/global/init/BaseInitData.java
