[REFACTOR] AI요금 사용량에 따른 모델 변경 로직 작성

gss-api-app/src/main/java/com/devoops/service/facade/RepositoryFacadeService.java

@@ -17,6 +17,7 @@
 import com.devoops.service.github.WebHookService;
 import com.devoops.service.repository.RepositoryService;
 import java.util.List;
+import java.util.Optional;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
@@ -46,6 +47,13 @@ public GithubRepository save(RepositorySaveRequest request, User user) {
 
     private GithubRepository saveRepository(GithubRepoUrl url, User user) {
         GithubRepoInfoResponse repositoryInfo = gitHubService.getRepositoryInfo(url, user.getGithubToken());
+        long externalId = repositoryInfo.id();
+        Optional<GithubRepository> alreadyRegisteredRepo = repositoryService.findByUserAndExternalId(user, externalId);
+
+        if(alreadyRegisteredRepo.isPresent()) {
+            return reTrackingOrThrowException(user, alreadyRegisteredRepo.get());
+        }
+
         RepositoryCreateCommand createCommand = new RepositoryCreateCommand(
                 user.getId(),
                 repositoryInfo.name(),
@@ -57,6 +65,13 @@ private GithubRepository saveRepository(GithubRepoUrl url, User user) {
         return repositoryService.save(createCommand);
     }
 
+    private GithubRepository reTrackingOrThrowException(User user, GithubRepository registeredRepo) {
+        if(registeredRepo.isTracking()) {
+            throw new GssException(ErrorCode.ALREADY_SAVED_REPOSITORY);
+        }
+        return repositoryService.reTracking(user, registeredRepo.getExternalId());
+    }
+
     public PullRequests findAllPullRequestsByRepository(User user, long repositoryId, int size, int page) {
         return repositoryService.getPullRequestsByRepository(user, repositoryId, size, page);
     }

gss-api-app/src/test/java/com/devoops/BaseRepositoryTest.java

@@ -0,0 +1,25 @@
+package com.devoops;
+
+import com.devoops.domain.repository.analysis.AiChargeRepository;
+import com.devoops.generator.AiChargeGenerator;
+import com.devoops.jpa.repository.analysis.AiChargeJpaRepository;
+import com.devoops.jpa.repository.analysis.AiChargeRepositoryImpl;
+import com.devoops.jpa.repository.github.repo.GithubRepoJpaRepository;
+import com.devoops.jpa.repository.github.pr.PullRequestJpaRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.context.annotation.Import;
+
+@DataJpaTest
+@Import({
+        AiChargeRepository.class,
+        AiChargeRepositoryImpl.class,
+        AiChargeJpaRepository.class,
+        AiChargeGenerator.class,
+})
+public abstract class BaseRepositoryTest {
+
+
+    @Autowired
+    protected AiChargeGenerator aiChargeGenerator;
+}

gss-api-app/src/test/java/com/devoops/BaseServiceTest.java

@@ -1,5 +1,6 @@
 package com.devoops;
 
+import com.devoops.generator.AiChargeGenerator;
 import com.devoops.generator.AnswerGenerator;
 import com.devoops.generator.AnswerRankingGenerator;
 import com.devoops.generator.GithubRepoGenerator;
@@ -39,5 +40,8 @@ public abstract class BaseServiceTest {
 
     @Autowired
     protected WebhookGenerator webhookGenerator;
+
+    @Autowired
+    protected AiChargeGenerator aiChargeGenerator;
 }
 

gss-api-app/src/test/java/com/devoops/repository/analysis/AiChargeRepositoryTest.java

@@ -0,0 +1,57 @@
+package com.devoops.repository.analysis;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.devoops.BaseServiceTest;
+import com.devoops.domain.entity.analysis.AiCharge;
+import com.devoops.domain.repository.analysis.AiChargeRepository;
+import java.time.LocalDate;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+class AiChargeRepositoryTest extends BaseServiceTest {
+
+    @Autowired
+    private AiChargeRepository chargeRepository;
+
+    @Nested
+    class GetByMonth {
+
+        @Test
+        void 월에_해당하는_요금을_가져온다() {
+            double charge = 1500.0;
+            LocalDate localDate = LocalDate.now();
+            aiChargeGenerator.generate(localDate.getYear(), localDate.getMonthValue(), charge);
+
+            AiCharge actual = chargeRepository.getByYearAndMonth(localDate.getYear(), localDate.getMonthValue());
+
+            assertThat(actual.getCharge().doubleValue()).isEqualTo(charge);
+        }
+
+        @Test
+        void 가져올_요금이_없다면_초기화한다() {
+            LocalDate localDate = LocalDate.now();
+
+            AiCharge actual = chargeRepository.getByYearAndMonth(localDate.getYear(), localDate.getMonthValue());
+
+            assertThat(actual.getCharge().doubleValue()).isEqualTo(0.0);
+        }
+    }
+
+    @Nested
+    class Update {
+
+        @Test
+        void 요금을_업데이트_할_수_있다() {
+            double charge = 1500.0;
+            LocalDate localDate = LocalDate.now();
+            aiChargeGenerator.generate(localDate.getYear(), localDate.getMonthValue(), charge);
+
+            chargeRepository.addCharge(localDate.getYear(), localDate.getMonthValue(), charge);
+
+            AiCharge updatedcharge = chargeRepository.getByYearAndMonth(localDate.getYear(), localDate.getMonthValue());
+            assertThat(updatedcharge.getCharge().doubleValue()).isEqualTo(charge * 2);
+        }
+    }
+}

gss-api-app/src/test/java/com/devoops/service/facade/RepositoryFacadeServiceTest.java

@@ -81,6 +81,26 @@ class Save {
                     .hasMessage(ErrorCode.ALREADY_SAVED_REPOSITORY.getMessage());
         }
 
+        @Test
+        void 레포지토리를_재연결_할_수_있다() {
+            User user = userGenerator.generate("김건우");
+            GithubRepository unTrackingRepo = repoGenerator.generate(user, "연결 끊긴 레포지토리", 123L, false);
+            RepositorySaveRequest request = new RepositorySaveRequest("https://github.com/octocat/Hello-World");
+            mockingGithubClient();
+
+            GithubRepository reTrackingRepository = repositoryFacadeService.save(request, user);
+
+            GithubRepository actual = githubRepoDomainRepository.findByIdAndUserId(
+                    unTrackingRepo.getId(),
+                    user.getId()
+            );
+
+            assertAll(
+                    () -> Mockito.verify(gitHubClient, times(1)).createWebhook(any(), any(), any(), any()),
+                    () -> assertThat(actual.isTracking()).isTrue()
+            );
+        }
+
         private void mockingGithubClient() {
             GithubRepoInfoResponse mockResponse = new GithubRepoInfoResponse(123, "testName", "testUrl",
                     new OwnerResponse("김건우"));

gss-api-app/src/test/java/com/devoops/service/repository/RepositoryServiceTest.java

@@ -5,15 +5,12 @@
 import static org.junit.jupiter.api.Assertions.assertAll;
 
 import com.devoops.BaseServiceTest;
-import com.devoops.domain.entity.github.repo.GithubRepository;
+import com.devoops.command.request.RepositoryCreateCommand;
 import com.devoops.domain.entity.github.pr.PullRequest;
 import com.devoops.domain.entity.github.pr.RecordStatus;
+import com.devoops.domain.entity.github.repo.GithubRepository;
 import com.devoops.domain.entity.user.User;
-import com.devoops.domain.repository.github.answer.AnswerDomainRepository;
-import com.devoops.domain.repository.github.answer.AnswerRankingDomainRepository;
 import com.devoops.domain.repository.github.repo.GithubRepoDomainRepository;
-import com.devoops.domain.repository.github.pr.PullRequestDomainRepository;
-import com.devoops.domain.repository.github.question.QuestionDomainRepository;
 import com.devoops.exception.custom.GssException;
 import com.devoops.exception.errorcode.ErrorCode;
 import java.time.LocalDateTime;
@@ -30,17 +27,28 @@ class RepositoryServiceTest extends BaseServiceTest {
     @Autowired
     private GithubRepoDomainRepository githubRepoDomainRepository;
 
-    @Autowired
-    private PullRequestDomainRepository pullRequestDomainRepository;
 
-    @Autowired
-    private QuestionDomainRepository questionDomainRepository;
+    @Nested
+    class Save {
 
-    @Autowired
-    private AnswerRankingDomainRepository answerRankingDomainRepository;
+        @Test
+        void 신규_레포지토리를_저장할_수_있다() {
+            User user = userGenerator.generate("김건우");
+            RepositoryCreateCommand createCommand = new RepositoryCreateCommand(user.getId(), "새로운 레포",
+                    "url", "건우", 0, 123L);
 
-    @Autowired
-    private AnswerDomainRepository answerDomainRepository;
+            GithubRepository savedRepository = repositoryService.save(createCommand);
+
+            assertAll(
+                    () -> assertThat(createCommand.url()).isEqualTo(savedRepository.getUrl()),
+                    () -> assertThat(createCommand.userId()).isEqualTo(savedRepository.getUserId()),
+                    () -> assertThat(createCommand.externalId()).isEqualTo(savedRepository.getExternalId()),
+                    () -> assertThat(createCommand.prCount()).isEqualTo(savedRepository.getPrCount()),
+                    () -> assertThat(createCommand.ownerName()).isEqualTo(savedRepository.getOwner()),
+                    () -> assertThat(createCommand.repositoryName()).isEqualTo(savedRepository.getName())
+            );
+        }
+    }
 
     @Nested
     class getRepositoryPullRequestsByRepository {
@@ -135,7 +143,8 @@ class getRepositoryPullRequests {
                     .toList();
 
             assertThat(pullRequestsId)
-                    .containsExactly(nowPr.getId(), oneMinutesAgoPR.getId(), threeMinutesAgoPR.getId(), fiveMinutesAgoPR.getId());
+                    .containsExactly(nowPr.getId(), oneMinutesAgoPR.getId(), threeMinutesAgoPR.getId(),
+                            fiveMinutesAgoPR.getId());
         }
 
         @Test

gss-client/gss-mcp-client/build.gradle

@@ -3,6 +3,7 @@ plugins {
 }
 
 dependencies {
+    implementation project(":gss-common")
     implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
     implementation 'org.springframework.boot:spring-boot-starter-webflux'
 

gss-client/gss-mcp-client/src/main/java/com/devoops/client/PrAnalysisClient.java

@@ -1,8 +1,10 @@
 package com.devoops.client;
 
+import com.devoops.dto.request.AnalyzePrRequest;
 import com.devoops.dto.response.AnalyzePrResponse;
 
 public interface PrAnalysisClient {
 
-    AnalyzePrResponse analyze(String title, String description, String diff);
+    AnalyzePrResponse analyze(AnalyzePrRequest request);
+
 }

gss-client/gss-mcp-client/src/main/java/com/devoops/client/PrAnalysisClientImpl.java

@@ -1,44 +1,72 @@
 package com.devoops.client;
 
+import com.devoops.dto.request.AnalyzePrRequest;
 import com.devoops.dto.response.AnalyzePrResponse;
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.ObjectMapper;
+import com.devoops.dto.response.PrAnalysis;
+import com.devoops.serdes.PrAnalysisMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.ai.chat.model.ChatModel;
-import org.springframework.beans.factory.annotation.Value;
+import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.chat.metadata.Usage;
+import org.springframework.ai.chat.model.ChatResponse;
+import org.springframework.ai.chat.prompt.ChatOptions;
+import org.springframework.ai.converter.BeanOutputConverter;
+import org.springframework.ai.openai.OpenAiChatOptions;
+import org.springframework.ai.openai.api.ResponseFormat;
+import org.springframework.ai.openai.api.ResponseFormat.Type;
 import org.springframework.stereotype.Component;
 
 @Component
 @RequiredArgsConstructor
 @Slf4j
 public class PrAnalysisClientImpl implements PrAnalysisClient {
 
-    @Value("${dev-oops.github-pr-analysis.prompt}")
-    private String promptTemplate;
-
-    private final ChatModel chatModel;
-    private final ObjectMapper objectMapper;
+    private final ChatClient chatClient;
+    private final PromptBuilder promptBuilder;
+    private final PrAnalysisMapper prAnalysisMapper;
 
     @Override
-    public AnalyzePrResponse analyze(String title, String description, String diff) {
-        String prompt = buildPrompt(title, description, diff);
-//        log.info("prompt = {}", prompt);
-        String content = chatModel.call(prompt);
-        return parseResponse(content);
+    public AnalyzePrResponse analyze(AnalyzePrRequest request) {
+        //option 설정
+        OpenAiChatOptions openAiChatOptions = openAiChatBuilder()
+                .model(request.model())
+                .build();
+
+        ChatResponse chatresponse = callChatResponse(
+                request.title(),
+                request.description(),
+                request.codeDifference(),
+                openAiChatOptions
+        );
+
+        Usage usage = chatresponse.getMetadata().getUsage();
+        String analysisResult = chatresponse.getResult().getOutput().getText();
+        PrAnalysis prAnalysis = prAnalysisMapper.mapToPrAnalysis(analysisResult);
+        return new AnalyzePrResponse(usage, prAnalysis);
+    }
+
+    private OpenAiChatOptions.Builder openAiChatBuilder() {
+        return OpenAiChatOptions.builder()
+                .responseFormat(new ResponseFormat(Type.JSON_SCHEMA, outputJsonSchema()))
+                .reasoningEffort("medium")
+                .temperature(1.0);
+
     }
 
-    private String buildPrompt(String title, String description, String diff) {
-        return String.format(promptTemplate, title, description, diff);
+    private String outputJsonSchema() {
+        BeanOutputConverter<PrAnalysis> outputConverter = new BeanOutputConverter<>(PrAnalysis.class);
+        return outputConverter.getJsonSchema();
     }
 
-    private AnalyzePrResponse parseResponse(String content) {
-        try {
-            return objectMapper.readValue(content, new TypeReference<>() {
-            });
-        } catch (Exception e) {
-            log.error("AI 응답 파싱 실패. 응답 내용: {}", content, e);
-            throw new IllegalArgumentException("AI 응답 파싱 중 오류 발생", e);
-        }
+    private ChatResponse callChatResponse(String title, String description, String codeDifference,
+                                          ChatOptions options) {
+        String userPrompt = promptBuilder.buildUserPrompt(title, description, codeDifference);
+        String systemPrompt = promptBuilder.buildSystemPrompt();
+        return chatClient.prompt()
+                .options(options)
+                .system(systemPrompt)
+                .user(userPrompt)
+                .call()
+                .chatResponse();
     }
 }

gss-client/gss-mcp-client/src/main/java/com/devoops/client/PromptBuilder.java

@@ -0,0 +1,31 @@
+package com.devoops.client;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component
+public class PromptBuilder {
+
+    @Value("${dev-oops.github-pr-analysis.prompt}")
+    private String promptTemplate;
+
+    @Value("${dev-oops.github-pr-analysis.system}")
+    private String systemPrompt;
+
+    public String buildUserPrompt(String title, String description, String diff) {
+        return promptTemplate
+                .replace("{title}", title)
+                .replace("{description}", description)
+                .replace("{diff}", encodeDiff(diff));
+    }
+
+    public String buildSystemPrompt() {
+        return systemPrompt;
+    }
+
+    private String encodeDiff(String diff) {
+        return Base64.getEncoder().encodeToString(diff.getBytes(StandardCharsets.UTF_8));
+    }
+}

gss-client/gss-mcp-client/src/main/java/com/devoops/config/AiConfig.java

@@ -0,0 +1,15 @@
+package com.devoops.config;
+
+import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.openai.OpenAiChatModel;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class AiConfig {
+
+    @Bean
+    public ChatClient chatClient(OpenAiChatModel chatModel) {
+        return ChatClient.create(chatModel);
+    }
+}