feat(repository, global): BaseInitData 추가, GitHubApiClient 추가, Repository 관련 로직 수정

feat(repository, global): BaseInitData 추가, GitHubApiClient 추가, Repository 관련 로직 수정

Author: Hyeseung-OH

backend/src/main/java/com/backend/domain/analysis/repository/ScoreRepository.java

@@ -0,0 +1,7 @@
+package com.backend.domain.analysis.repository;
+
+import com.backend.domain.analysis.entity.Score;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ScoreRepository extends JpaRepository<Score, Long> {
+}

backend/src/main/java/com/backend/domain/analysis/service/AnalysisService.java

@@ -1,16 +1,18 @@
 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.service.RepositoryService;
 import com.backend.global.exception.BusinessException;
 import com.backend.global.exception.ErrorCode;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-
 import java.util.Optional;
 
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class AnalysisService {
@@ -19,20 +21,38 @@ public class AnalysisService {
 
     @Transactional
     public void analyze(String githubUrl) {
-        if(githubUrl == null || !githubUrl.startsWith("https://github.com/")) {
+        String[] repoInfo = parseGitHubUrl(githubUrl);
+        String owner = repoInfo[0];
+        String repo = repoInfo[1];
+
+        // Repository 데이터 수집
+        RepositoryData repositoryData = repositoryService.fetchAndSaveRepository(owner, repo);
+
+        // TODO: AI 평가
+        // EvaluationResult evaluation = evaluationService.evaluate(repositoryData);
+
+        // TODO: AI 평가 저장
+    }
+
+    private String[] parseGitHubUrl(String githubUrl) {
+        log.info("🚩 분석 요청 url: {}", githubUrl);
+
+        if (githubUrl == null || !githubUrl.startsWith("https://github.com/")) {
             throw new BusinessException(ErrorCode.INVALID_GITHUB_URL);
         }
 
-        String[] parts = githubUrl.replace("https://github.com/", "").split("/");
-        if(parts.length < 2){
-            throw new BusinessException(ErrorCode.INVALID_REPOSITORY_PATH);
+        String path = githubUrl.replace("https://github.com/", "");
+        if (path.endsWith("/")) {
+            path = path.substring(0, path.length() - 1);
         }
 
-        String owner = parts[0];
-        String repo = parts[1];
+        String[] parts = path.split("/");
+        if (parts.length < 2 || parts[0].trim().isEmpty() || parts[1].trim().isEmpty()) {
+            throw new BusinessException(ErrorCode.INVALID_REPOSITORY_PATH);
+        }
 
-        // GitHub API 호출
-        repositoryService.fetchAndSaveRepository(owner, repo);
+        log.info("🚩 파싱 완료 - owner: '{}', repo: '{}'", parts[0].trim(), parts[1].trim());
+        return new String[]{parts[0].trim(), parts[1].trim()};
     }
 
     // AnalysisRresult에서 repository id로 분석 결과 찾기

backend/src/main/java/com/backend/domain/repository/dto/response/github/ReadmeResponse.java

@@ -1,5 +1,18 @@
 package com.backend.domain.repository.dto.response.github;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
+
 // readme 응답용 DTO
-public record ReadmeResponse() {
+public record ReadmeResponse(
+        String name,
+        String path,
+        String sha,
+        Integer size,
+        String url,
+        @JsonProperty("html_url") String htmlUrl,
+        @JsonProperty("download_url") String downloadUrl,
+        String type,
+        String content,
+        String encoding
+) {
 }

backend/src/main/java/com/backend/domain/repository/dto/response/github/RepoResponse.java

@@ -7,7 +7,7 @@
 public record RepoResponse(
         String name,
         @JsonProperty("full_name") String fullName,
-        boolean _private,
+        @JsonProperty("private") boolean _private,
         String description,
         @JsonProperty("html_url") String htmlUrl,
         String language,

backend/src/main/java/com/backend/domain/repository/entity/Repositories.java

@@ -44,13 +44,15 @@ public class Repositories extends BaseEntity {
 
     @Builder
     public Repositories(
+            User user,
             String name,
             String description,
             String htmlUrl,
             boolean publicRepository,
             String mainBranch,
             List<RepositoryLanguage> languages
     ) {
+        this.user = user;
         this.name = name;
         this.description = description;
         this.htmlUrl = htmlUrl;
@@ -71,6 +73,9 @@ public void updateFrom(Repositories other) {
         this.name = other.name;
         this.description = other.description;
         this.mainBranch = other.mainBranch;
+    }
+
+    public void updatePublicFrom(Repositories other) {
         this.publicRepository = other.publicRepository;
     }
 }

backend/src/main/java/com/backend/domain/repository/service/RepositoryService.java

@@ -5,8 +5,14 @@
 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.FetcherRepository;
-import com.backend.domain.repository.service.mapper.MapperRepository;
+import com.backend.domain.repository.service.fetcher.GitHubDataFetcher;
+import com.backend.domain.repository.service.mapper.ReadmeInfoMapper;
+import com.backend.domain.repository.service.mapper.RepositoriesMapper;
+import com.backend.domain.repository.service.mapper.RepositoryInfoMapper;
+import com.backend.domain.user.entity.User;
+import com.backend.domain.user.repository.UserRepository;
+import com.backend.global.exception.BusinessException;
+import com.backend.global.exception.ErrorCode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -19,27 +25,82 @@
 @RequiredArgsConstructor
 public class RepositoryService {
 
-    private final FetcherRepository fetcherRepository;
-    private final MapperRepository mapperRepository;
+    // 임시
+    private final UserRepository userRepository;
+
+    private final GitHubDataFetcher gitHubDataFetcher;
+    private final RepositoriesMapper repositoriesMapper;
+    private final RepositoryInfoMapper repositoryInfoMapper;
+    private final ReadmeInfoMapper readmeInfoMapper;
     private final RepositoryJpaRepository repositoryJpaRepository;
 
     @Transactional
     public RepositoryData fetchAndSaveRepository(String owner, String repo) {
-        RepoResponse response = fetcherRepository.fetchRepositoryInfo(owner, repo);
+        try {
+            return fetchCompleteRepositoryData(owner, repo);
+        } catch (BusinessException e) {
+            String errorCode = (e.getErrorCode() != null) ? e.getErrorCode().getCode() : "UNKNOWN";
+            log.error("Repository analysis failed for {}/{}: {} - {}",
+                    owner, repo, errorCode, e.getMessage());
+            throw e;
+        } catch (Exception e) {
+            log.error("Unexpected error during repository analysis for {}/{}: {}",
+                    owner, repo, e.getMessage(), e);
+            throw new BusinessException(ErrorCode.INTERNAL_ERROR);
+        }
+    }
+
+    @Transactional
+    public RepositoryData fetchCompleteRepositoryData(String owner, String repo) {
+        RepositoryData data = new RepositoryData();
+
+        // 1. 기본 정보 수집 및 매핑 + Repositories 테이블 저장
+        RepoResponse repoInfo = gitHubDataFetcher.fetchRepositoryInfo(owner, repo);
+        repositoryInfoMapper.mapBasicInfo(data, repoInfo);
+
+        // TODO: 커밋 데이터 수집 및 매핑
+
+
+        // TODO: README 데이터 수집 및 매핑
+        String readmeInfo = gitHubDataFetcher.fetchReadmeContent(owner, repo);
+        readmeInfoMapper.mapReadmeInfo(data, readmeInfo);
+
+        // TODO: 보안 관리 데이터 수집 및 매핑
+
+
+        // TODO: 테스트 데이터 수집 및 매핑
 
-        Repositories entity = mapperRepository.toEntity(response);
-        Repositories repositories = repositoryJpaRepository
+
+        // TODO: CI/CD 데이터 수집 및 매핑
+
+
+        // TODO: 커뮤니티 활성도 데이터 수집 및 매핑
+
+        // Entity 저장 로직
+        saveRepositoryEntity(repoInfo);
+
+        log.info("✅ RepositoryData: {}", data);
+        return data;
+    }
+
+    private void saveRepositoryEntity(RepoResponse repoInfo) {
+        User defaultUser = userRepository.findAll().stream()
+                .findFirst()
+                .orElseThrow(() -> new BusinessException(ErrorCode.INTERNAL_ERROR));
+
+        Repositories entity = repositoriesMapper.toEntity(repoInfo, defaultUser);
+        repositoryJpaRepository
                 .findByHtmlUrl(entity.getHtmlUrl())
                 .map(existing -> {
-                    existing.updateFrom(entity);
+                    existing.updateFrom(repositoriesMapper.toEntity(repoInfo, defaultUser));
                     return existing;
                 })
-                .orElseGet(() -> repositoryJpaRepository.save(entity));
+                .orElseGet(() -> {
+                    Repositories newEntity = repositoriesMapper.toEntity(repoInfo, defaultUser);
+                    return repositoryJpaRepository.save(newEntity);
+                });
 
-        RepositoryData data = mapperRepository.toRepositoryData(response);
-        log.info("RepositoryData 결과: {}", data);
-
-        return data;
+        log.info("✅ Repositories: {}", entity);
     }
 
     // Repository에서 member로 리포지토리 찾기