[ADD] 문제 생성 + 저장 API 하나로 결합하기

Author: hyunbin1

src/main/java/com/example/ai_tutor/domain/practice/application/ProfessorPracticeService.java

@@ -228,6 +228,77 @@ private User getUser(UserPrincipal userPrincipal) {
                 .orElseThrow(() -> new IllegalArgumentException("사용자를 찾을 수 없습니다."));
     }
 
+    @Transactional
+    public Mono<ResponseEntity<ApiResponse<List<ProfessorPracticeRes>>>> generateAndSavePractice(
+            UserPrincipal userPrincipal, Long noteId, CreatePracticeReq createPracticeReq) {
+
+        // 유저와 교수 인증 (예외 발생 시 중단)
+        validateUser(userPrincipal);
+        validateProfessor(userPrincipal);
+
+        // 비동기로 노트 조회 (블로킹 방지)
+        return getNoteAsync(noteId)
+            .flatMap(note -> {
+                String summary = note.getSummary().getContent();
+                int practiceSize = determinePracticeSize(createPracticeReq.getPracticeSize());
+
+                Mono<List<CreatePracticeRes>> practiceMono;
+                if ("BOTH".equalsIgnoreCase(createPracticeReq.getType())) {
+                    int oxCount = calculateOxCount(practiceSize);
+                    int shortCount = practiceSize - oxCount;
+
+                    Mono<List<CreatePracticeRes>> oxMono = quizGeneratorService.generateQuestions(summary, oxCount, "OX", 1);
+                    Mono<List<CreatePracticeRes>> shortMono = quizGeneratorService.generateQuestions(summary, shortCount, "SHORT", oxCount + 1);
+                    practiceMono = Mono.zip(oxMono, shortMono)
+                            .map(tuple -> combineQuestions(tuple.getT1(), tuple.getT2()));
+                } else {
+                    practiceMono = quizGeneratorService.generateQuestions(summary, practiceSize, createPracticeReq.getType(), 1);
+                }
+
+                // 기존 sequence 최대값 조회 → Mono로 감싸서 flatMap 안에서 사용
+                return Mono.fromCallable(() -> practiceRepository.findMaxSequenceByNoteId(noteId))
+                    .subscribeOn(Schedulers.boundedElastic())
+                    .flatMap(lastSequence -> practiceMono.flatMap(practices -> {
+
+                        int startSequence = lastSequence + 1; // 기존 마지막 번호 다음부터 시작
+                        List<Practice> entities = new ArrayList<>();
+
+                        for (int i = 0; i < practices.size(); i++) {
+                            CreatePracticeRes p = practices.get(i);
+                            PracticeType type = PracticeType.valueOf(p.getPracticeType());
+
+                            entities.add(Practice.builder()
+                                .note(note)
+                                .sequence(startSequence + i)
+                                .content(p.getContent())
+                                .result(p.getResult())
+                                .solution(p.getSolution())
+                                .additionalResults(type == PracticeType.OX ? null : p.getAdditionalResults())
+                                .practiceType(type)
+                                .build());
+                        }
+
+                        return Mono.fromCallable(() -> {
+                            practiceRepository.saveAll(entities);
+                            return entities;
+                            }).subscribeOn(Schedulers.boundedElastic())
+                            .map(saved -> {
+                                List<ProfessorPracticeRes> responses = saved.stream()
+                                    .map(this::toResponse)
+                                    .toList();
+
+                                ApiResponse<List<ProfessorPracticeRes>> api = ApiResponse.<List<ProfessorPracticeRes>>builder()
+                                    .check(true)
+                                    .information(responses)
+                                    .build();
+
+                                return ResponseEntity.ok(api);
+                        });}));
+            });
+
+    }
+
+
 
     /** Practice → ProfessorPracticeRes 매핑용 */
     private ProfessorPracticeRes toResponse(Practice p) {

src/main/java/com/example/ai_tutor/domain/practice/application/QuizGeneratorService.java

@@ -6,8 +6,11 @@
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.web.reactive.function.client.WebClientResponseException;
 import reactor.core.publisher.Mono;
+import reactor.util.retry.Retry;
 
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -24,12 +27,12 @@ public Mono<List<CreatePracticeRes>> generateQuestions(String summary, int size,
         log.info("GPT API 호출하여 문제를 생성합니다.");
         // 비동기 방식으로 GPT API 호출
         return gptService.callChatGpt(prompt)
+                .retryWhen(Retry.backoff(3, Duration.ofSeconds(2))
+                        .filter(e -> e instanceof WebClientResponseException.TooManyRequests))
                 .flatMap(response -> {
                     if (response == null) {
                         return Mono.error(new RuntimeException("GPT API 응답이 없습니다."));
                     }
-
-                    // 응답 파싱하여 List<CreatePracticeRes> 반환
                     List<CreatePracticeRes> practiceResList = parseResponse(response, num, type);
                     return Mono.just(practiceResList);
                 })

src/main/java/com/example/ai_tutor/domain/practice/domain/repository/PracticeRepository.java

@@ -3,6 +3,8 @@
 import com.example.ai_tutor.domain.note.domain.Note;
 import com.example.ai_tutor.domain.practice.domain.Practice;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
@@ -20,4 +22,8 @@ public interface PracticeRepository extends JpaRepository<Practice, Long> {
 
     List<Practice> findByNoteOrderBySequenceAsc(Note note);
 
+    @Query("SELECT COALESCE(MAX(p.sequence), 0) FROM Practice p WHERE p.note.noteId = :noteId")
+    int findMaxSequenceByNoteId(@Param("noteId") Long noteId);
+
+
 }

src/main/java/com/example/ai_tutor/domain/practice/dto/response/CreatePracticeRes.java

@@ -14,13 +14,19 @@
 @AllArgsConstructor
 @NoArgsConstructor
 public class CreatePracticeRes {
+    @Schema(type = "Long", example ="1", description="문제의 id입니다.")
+    private Long practiceId;
 
     @Schema(type = "int", example ="1", description="문제의 번호입니다.")
     private int practiceNumber;
 
     @Schema(type = "String", example ="광복절의 중앙경축식은 매년 서울에서만 거행된다.", description="문제의 내용입니다.")
     private String content;
 
+    // 추가 답안 (교수자가 입력할 시 사용)
+    @ArraySchema(schema = @Schema(type = "String", example ="[Answer, ANSWER, answer, 정답]", description="문제의 추가 인정 답안으로, 교수자가 직접 작성하며 단답형 문제에만 해당합니다."))
+    private List<String> additionalResults;
+
     // 문제 답안
     @Schema(type = "String", example ="X",
             description="문제의 답안입니다. OX문제의 경우 O 또는 X, 객관식 문제의 경우 A, B, C, D입니다.")
@@ -30,6 +36,6 @@ public class CreatePracticeRes {
     private String solution;
 
     // 문제 타입
-    @Schema(type = "String", example ="OX", description="문제의 타입입니다. OX, MULTIPLE")
+    @Schema(type = "String", example ="OX", description="문제의 타입입니다. OX, SHORT")
     private String practiceType;
-}
+}

src/main/java/com/example/ai_tutor/domain/practice/presentation/ProfessorPracticeController.java

@@ -38,32 +38,34 @@ public class ProfessorPracticeController {
     private final ProfessorPracticeService professorPracticeService;
 
     @Operation(
-            summary = "요약본에 대한 문제 생성",
+            summary = "요약본에 대한 문제 생성 후 저장",
             security = { @SecurityRequirement(name = "BearerAuth") },
-            description = "이전에 요약본 생성 API를 통해 저장한 요약본 데이터를 기반으로 문제를 생성합니다." +
-                    "이는 CreatePracticeReq를 참고하여 문제를 생성하고 파일을 업로드합니다. " +
-                    "주의할 점은 이 요청은 응답을 DB에 저장하지 않습니다. 이는 응답만 할 뿐, 이후 선택된 문제들만 문제 저장 API를 요청하여 저장해주세요.",
+            description = "요약본 데이터를 기반으로 문제를 생성하고, 생성된 문제를 DB에 곧바로 저장합니다. " +
+                    "기존 두 API(generate + save)를 하나로 통합한 API입니다.",
             responses = {
-                    @ApiResponse(responseCode = "200", description = "Practice 문제 생성 성공",
+                    @ApiResponse(responseCode = "200", description = "Practice 문제 생성 및 저장 성공",
                             content = @Content(schema = @Schema(implementation = com.example.ai_tutor.global.payload.ApiResponse.class))),
                     @ApiResponse(responseCode = "400", description = "잘못된 요청",
                             content = @Content(schema = @Schema(implementation = com.example.ai_tutor.global.payload.ApiResponse.class))),
                     @ApiResponse(responseCode = "500", description = "서버 오류",
                             content = @Content(schema = @Schema(implementation = com.example.ai_tutor.global.payload.ApiResponse.class)))
-            })
-    @PostMapping(value = "/{noteId}/new")
-    public Mono<ResponseEntity<com.example.ai_tutor.global.payload.ApiResponse<CreatePracticeListRes>>> generatePractice(
-            @Parameter(description = "Access Token을 입력해주세요.", required = true) @AuthenticationPrincipal UserPrincipal userPrincipal,
-            @Parameter(description = "note의 id를 입력해주세요", required = true) @PathVariable Long noteId,
+        })
+    @PostMapping(value = "/{noteId}/generate-and-save")
+    public Mono<ResponseEntity<com.example.ai_tutor.global.payload.ApiResponse<List<ProfessorPracticeRes>>>> generateAndSavePractice(
+            @Parameter(description = "Access Token을 입력해주세요.", required = true)
+            @AuthenticationPrincipal UserPrincipal userPrincipal,
+
+            @Parameter(description = "노트의 ID를 입력해주세요", required = true)
+            @PathVariable Long noteId,
+
             @io.swagger.v3.oas.annotations.parameters.RequestBody(
                     description = "Schemas의 CreatePracticeReq를 참고해주세요",
                     required = true,
                     content = @Content(schema = @Schema(implementation = CreatePracticeReq.class))
             )
             @RequestBody CreatePracticeReq createPracticeReq
     ) {
-        return professorPracticeService.generatePractice(userPrincipal, noteId, createPracticeReq)
-                .map(ResponseEntity::ok);
+        return professorPracticeService.generateAndSavePractice(userPrincipal, noteId, createPracticeReq);
     }
 
     // 문제 저장