[BE] feat: 리뷰 폼 응답 재구현

backend/src/main/java/reviewme/question/domain/Question2.java

@@ -53,6 +53,6 @@ public boolean isSelectable() {
     }
 
     public boolean hasGuideline() {
-        return guideline != null;
+        return guideline != null && !guideline.isEmpty();
     }
 }

backend/src/main/java/reviewme/question/domain/exception/MissingOptionItemsInOptionGroupException.java

@@ -0,0 +1,13 @@
+package reviewme.question.domain.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.NotFoundException;
+
+@Slf4j
+public class MissingOptionItemsInOptionGroupException extends NotFoundException {
+
+    public MissingOptionItemsInOptionGroupException(long optionGroupId) {
+        super("서버 내부에서 문제가 발생했어요. 서버에 문의해주세요.");
+        log.warn("OptionGroup has no OptionItems - optionGroupId: {}", optionGroupId);
+    }
+}

backend/src/main/java/reviewme/question/domain/exception/OptionGroupNotFoundByQuestionException.java

@@ -0,0 +1,13 @@
+package reviewme.question.domain.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.NotFoundException;
+
+@Slf4j
+public class OptionGroupNotFoundByQuestionException extends NotFoundException {
+
+    public OptionGroupNotFoundByQuestionException(long questionId) {
+        super("서버 내부에서 문제가 발생했어요. 서버에 문의해주세요.");
+        log.warn("OptionGroup not found by question - questionId: {}", questionId);
+    }
+}

backend/src/main/java/reviewme/question/repository/OptionItemRepository.java

@@ -16,6 +16,8 @@ public interface OptionItemRepository extends JpaRepository<OptionItem, Long> {
 
     List<OptionItem> findAllByOptionGroupId(long optionGroupId);
 
+    boolean existsByOptionTypeAndId(OptionType optionType, long id);
+
     @Query(value = """
             SELECT o.id FROM option_item o
             LEFT JOIN checkbox_answer ca
@@ -38,8 +40,6 @@ public interface OptionItemRepository extends JpaRepository<OptionItem, Long> {
             """, nativeQuery = true)
     List<OptionItem> findSelectedOptionItemsByReviewIdAndQuestionId(long reviewId, long questionId);
 
-    boolean existsByOptionTypeAndId(OptionType optionType, long id);
-
     default OptionItem getOptionItemById(long id) {
         return findById(id).orElseThrow(() -> new OptionItemNotFoundException(id));
     }

backend/src/main/java/reviewme/question/repository/Question2Repository.java

@@ -1,9 +1,11 @@
 package reviewme.question.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
 import reviewme.question.domain.Question2;
 import reviewme.question.domain.exception.QuestionNotFoundException;
 
+@Repository
 public interface Question2Repository extends JpaRepository<Question2, Long> {
 
     default Question2 getQuestionById(long id) {

backend/src/main/java/reviewme/review/domain/exception/InvalidAnswerLengthException.java

@@ -7,8 +7,8 @@
 public class InvalidAnswerLengthException extends BadRequestException {
 
     public InvalidAnswerLengthException(int answerLength, int minLength, int maxLength) {
-        super("답변의 길이는 %d자 이상 %d자 이하여야 합니다.".formatted(minLength, maxLength));
-        log.info("AnswerLength is out of bound - answerLength:{}, minLength: {}, maxLength: {}",
+        super("답변의 길이는 %d자 이상 %d자 이하여야 해요.".formatted(minLength, maxLength));
+        log.info("AnswerLength is out of bound - answerLength: {}, minLength: {}, maxLength: {}",
                 answerLength, minLength, maxLength);
     }
 }

backend/src/main/java/reviewme/template/controller/TemplateController.java

@@ -0,0 +1,22 @@
+package reviewme.template.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import reviewme.template.dto.response.TemplateResponse;
+import reviewme.template.service.TemplateService;
+
+@RestController
+@RequiredArgsConstructor
+public class TemplateController {
+
+    private final TemplateService templateService;
+
+    @GetMapping("/v2/reviews/write")
+    public ResponseEntity<TemplateResponse> getReviewForm(@RequestParam String reviewRequestCode) {
+        TemplateResponse response = templateService.generateReviewForm(reviewRequestCode);
+        return ResponseEntity.ok(response);
+    }
+}

backend/src/main/java/reviewme/template/domain/Section.java

@@ -1,7 +1,7 @@
 package reviewme.template.domain;
 
-import jakarta.persistence.CascadeType;
 import jakarta.persistence.Column;
+import jakarta.persistence.CascadeType;
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;

backend/src/main/java/reviewme/template/domain/exception/DefaultTemplateNotFoundException.java

@@ -0,0 +1,13 @@
+package reviewme.template.domain.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.NotFoundException;
+
+@Slf4j
+public class DefaultTemplateNotFoundException extends NotFoundException {
+
+    public DefaultTemplateNotFoundException(long id) {
+        super("서버 내부에서 문제가 발생했어요. 서버에 문의해주세요.");
+        log.warn("DefaultTemplateNotFoundException is occurred - id: {}", id);
+    }
+}

backend/src/main/java/reviewme/template/domain/exception/SectionNotFoundException.java

@@ -7,7 +7,7 @@
 public class SectionNotFoundException extends NotFoundException {
 
     public SectionNotFoundException(long id) {
-        super("섹션이 존재하지 않아요.");
-        log.info("SectionNotFoundException is occurred - id: {}", id);
+        super("서버 내부에서 문제가 발생했어요. 서버에 문의해주세요.");
+        log.warn("SectionNotFoundException is occurred - id: {}", id);
     }
 }

backend/src/main/java/reviewme/template/dto/response/OptionGroupResponse.java

@@ -0,0 +1,12 @@
+package reviewme.template.dto.response;
+
+import java.util.List;
+
+public record OptionGroupResponse(
+
+        long optionGroupId,
+        int minCount,
+        int maxCount,
+        List<OptionItemResponse> options
+) {
+}

backend/src/main/java/reviewme/template/dto/response/OptionItemResponse.java

@@ -0,0 +1,8 @@
+package reviewme.template.dto.response;
+
+public record OptionItemResponse(
+
+        long optionId,
+        String content
+) {
+}

backend/src/main/java/reviewme/template/dto/response/QuestionResponse.java

@@ -0,0 +1,15 @@
+package reviewme.template.dto.response;
+
+import jakarta.annotation.Nullable;
+
+public record QuestionResponse(
+
+        long questionId,
+        boolean required,
+        String content,
+        String questionType,
+        @Nullable OptionGroupResponse optionGroup,
+        boolean hasGuideline,
+        @Nullable String guideline
+) {
+}

backend/src/main/java/reviewme/template/dto/response/SectionResponse.java

@@ -0,0 +1,14 @@
+package reviewme.template.dto.response;
+
+import jakarta.annotation.Nullable;
+import java.util.List;
+
+public record SectionResponse(
+
+        long sectionId,
+        String visible,
+        @Nullable Long onSelectedOptionId,
+        String header,
+        List<QuestionResponse> questions
+) {
+}

backend/src/main/java/reviewme/template/dto/response/TemplateResponse.java

@@ -0,0 +1,12 @@
+package reviewme.template.dto.response;
+
+import java.util.List;
+
+public record TemplateResponse(
+
+        long formId,
+        String revieweeName,
+        String projectName,
+        List<SectionResponse> sections
+) {
+}

backend/src/main/java/reviewme/template/service/TemplateMapper.java

@@ -0,0 +1,102 @@
+package reviewme.template.service;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import reviewme.question.domain.OptionGroup;
+import reviewme.question.domain.OptionItem;
+import reviewme.question.domain.Question2;
+import reviewme.question.domain.exception.MissingOptionItemsInOptionGroupException;
+import reviewme.question.repository.OptionGroupRepository;
+import reviewme.question.repository.OptionItemRepository;
+import reviewme.question.repository.Question2Repository;
+import reviewme.reviewgroup.domain.ReviewGroup;
+import reviewme.template.domain.Section;
+import reviewme.template.domain.SectionQuestion;
+import reviewme.template.domain.Template;
+import reviewme.template.domain.TemplateSection;
+import reviewme.template.dto.response.OptionGroupResponse;
+import reviewme.template.dto.response.OptionItemResponse;
+import reviewme.template.dto.response.QuestionResponse;
+import reviewme.template.dto.response.SectionResponse;
+import reviewme.template.dto.response.TemplateResponse;
+import reviewme.template.repository.SectionRepository;
+
+@Component
+@RequiredArgsConstructor
+public class TemplateMapper {
+
+    private final SectionRepository sectionRepository;
+    private final Question2Repository questionRepository;
+    private final OptionGroupRepository optionGroupRepository;
+    private final OptionItemRepository optionItemRepository;
+
+    public TemplateResponse mapToTemplateResponse(ReviewGroup reviewGroup, Template template) {
+        List<SectionResponse> sectionResponses = template.getSectionIds()
+                .stream()
+                .map(this::mapToSectionResponse)
+                .toList();
+
+        return new TemplateResponse(
+                template.getId(),
+                reviewGroup.getReviewee(),
+                reviewGroup.getProjectName(),
+                sectionResponses
+        );
+    }
+
+    private SectionResponse mapToSectionResponse(TemplateSection templateSection) {
+        Section section = sectionRepository.getSectionById(templateSection.getSectionId());
+        List<QuestionResponse> questionResponses = section.getQuestionIds()
+                .stream()
+                .map(this::mapToQuestionResponse)
+                .toList();
+
+        return new SectionResponse(
+                section.getId(),
+                section.getVisibleType().name(),
+                section.getOnSelectedOptionId(),
+                section.getHeader(),
+                questionResponses
+        );
+    }
+
+    private QuestionResponse mapToQuestionResponse(SectionQuestion sectionQuestion) {
+        Question2 question = questionRepository.getQuestionById(sectionQuestion.getQuestionId());
+        OptionGroupResponse optionGroupResponse = optionGroupRepository.findByQuestionId(question.getId())
+                .map(this::mapToOptionGroupResponse)
+                .orElse(null);
+
+        return new QuestionResponse(
+                question.getId(),
+                question.isRequired(),
+                question.getContent(),
+                question.getContent(),
+                optionGroupResponse,
+                question.hasGuideline(),
+                question.getGuideline()
+        );
+    }
+
+    private OptionGroupResponse mapToOptionGroupResponse(OptionGroup optionGroup) {
+        List<OptionItem> optionItems = optionItemRepository.findAllByOptionGroupId(optionGroup.getId());
+        if (optionItems.isEmpty()) {
+            throw new MissingOptionItemsInOptionGroupException(optionGroup.getId());
+        }
+
+        List<OptionItemResponse> optionItemResponses = optionItems.stream()
+                .map(this::mapToOptionItemResponse)
+                .toList();
+
+        return new OptionGroupResponse(
+                optionGroup.getId(),
+                optionGroup.getMinSelectionCount(),
+                optionGroup.getMaxSelectionCount(),
+                optionItemResponses
+        );
+    }
+
+    private OptionItemResponse mapToOptionItemResponse(OptionItem optionItem) {
+        return new OptionItemResponse(optionItem.getId(), optionItem.getContent());
+    }
+}

backend/src/main/java/reviewme/template/service/TemplateService.java

@@ -0,0 +1,34 @@
+package reviewme.template.service;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import reviewme.review.domain.exception.ReviewGroupNotFoundByRequestReviewCodeException;
+import reviewme.reviewgroup.domain.ReviewGroup;
+import reviewme.reviewgroup.repository.ReviewGroupRepository;
+import reviewme.template.domain.Template;
+import reviewme.template.domain.exception.DefaultTemplateNotFoundException;
+import reviewme.template.dto.response.TemplateResponse;
+import reviewme.template.repository.TemplateRepository;
+
+@Service
+@RequiredArgsConstructor
+public class TemplateService {
+
+    private static final long USE_TEMPLATE_ID = 1L;
+
+    private final ReviewGroupRepository reviewGroupRepository;
+    private final TemplateRepository templateRepository;
+    private final TemplateMapper templateMapper;
+
+    @Transactional(readOnly = true)
+    public TemplateResponse generateReviewForm(String reviewRequestCode) {
+        ReviewGroup reviewGroup = reviewGroupRepository.findByReviewRequestCode(reviewRequestCode)
+                .orElseThrow(() -> new ReviewGroupNotFoundByRequestReviewCodeException(reviewRequestCode));
+
+        Template defaultTemplate = templateRepository.findById(USE_TEMPLATE_ID)
+                .orElseThrow(() -> new DefaultTemplateNotFoundException(USE_TEMPLATE_ID));
+
+        return templateMapper.mapToTemplateResponse(reviewGroup, defaultTemplate);
+    }
+}

backend/src/test/java/reviewme/support/DatabaseCleaner.java

@@ -6,6 +6,7 @@
 import jakarta.persistence.Table;
 import jakarta.persistence.metamodel.EntityType;
 import jakarta.transaction.Transactional;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 
@@ -22,10 +23,10 @@ public class DatabaseCleaner {
     @PostConstruct
     public void afterPropertiesSet() {
         Set<EntityType<?>> entities = entityManager.getMetamodel().getEntities();
-        tableNames = entities.stream()
+        tableNames = new ArrayList<>(entities.stream()
                 .filter(entity -> entity.getJavaType().isAnnotationPresent(Table.class))
                 .map(entity -> entity.getJavaType().getAnnotation(Table.class).name())
-                .toList();
+                .toList());
     }
 
     @Transactional