[BE] feat: 하이라이트 추가 및 수정 API 구현

backend/src/main/java/reviewme/highlight/controller/HighlightController.java

@@ -19,7 +19,7 @@ public class HighlightController {
     @PostMapping("/v2/highlight")
     public ResponseEntity<Void> highlight(@Valid @RequestBody HighlightsRequest request,
                                           @SessionAttribute("reviewRequestCode") String reviewRequestCode) {
-        highlightService.highlight(request);
+        highlightService.highlight(request, reviewRequestCode);
         return ResponseEntity.ok().build();
     }
 }

backend/src/main/java/reviewme/highlight/domain/HighLight.java

@@ -0,0 +1,52 @@
+package reviewme.highlight.domain;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "highlight")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@EqualsAndHashCode(of = "id")
+@Getter
+public class HighLight {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "review_group_id", nullable = false)
+    private long reviewGroupId;
+
+    @Column(name = "question_id", nullable = false)
+    private long questionId;
+
+    @Column(name = "answer_id", nullable = false)
+    private long answerId;
+
+    @Column(name = "line_index", nullable = false)
+    private long lineIndex;
+
+    @Column(name = "start_index", nullable = false)
+    private long startIndex;
+
+    @Column(name = "end_index", nullable = false)
+    private long endIndex;
+
+    public HighLight(long reviewGroupId, long questionId, long answerId,
+                     long lineIndex, long startIndex, long endIndex) {
+        this.reviewGroupId = reviewGroupId;
+        this.questionId = questionId;
+        this.answerId = answerId;
+        this.lineIndex = lineIndex;
+        this.startIndex = startIndex;
+        this.endIndex = endIndex;
+    }
+}

backend/src/main/java/reviewme/highlight/repository/HighlightRepository.java

@@ -0,0 +1,9 @@
+package reviewme.highlight.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import reviewme.highlight.domain.HighLight;
+
+public interface HighlightRepository extends JpaRepository<HighLight, Long> {
+
+    void deleteByReviewGroupIdAndQuestionId(long reviewGroupId, long questionId);
+}

backend/src/main/java/reviewme/highlight/service/HighlightService.java

@@ -1,12 +1,51 @@
 package reviewme.highlight.service;
 
+import java.util.List;
+import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import reviewme.highlight.domain.HighLight;
+import reviewme.highlight.repository.HighlightRepository;
 import reviewme.highlight.service.dto.HighlightsRequest;
+import reviewme.highlight.service.validator.HighlightValidator;
+import reviewme.review.service.exception.ReviewGroupNotFoundByReviewRequestCodeException;
+import reviewme.reviewgroup.repository.ReviewGroupRepository;
 
 @Service
+@RequiredArgsConstructor
 public class HighlightService {
 
-    public void highlight(HighlightsRequest request) {
-        // TODO: implement method
+    private final HighlightRepository highlightRepository;
+    private final ReviewGroupRepository reviewGroupRepository;
+
+    private final HighlightValidator highlightValidator;
+
+    @Transactional
+    public void highlight(HighlightsRequest request, String reviewRequestCode) {
+        long reviewGroupId = reviewGroupRepository.findByReviewRequestCode(reviewRequestCode)
+                .orElseThrow(() -> new ReviewGroupNotFoundByReviewRequestCodeException(reviewRequestCode))
+                .getId();
+
+        highlightValidator.validate(request, reviewGroupId);
+        deleteOldHighlight(request.questionId(), reviewGroupId);
+        saveNewHighlight(request, reviewGroupId);
+    }
+
+    private void deleteOldHighlight(long questionId, long reviewGroupId) {
+        highlightRepository.deleteByReviewGroupIdAndQuestionId(reviewGroupId, questionId);
+    }
+
+    private void saveNewHighlight(HighlightsRequest highlightsRequest, long reviewGroupId) {
+        List<HighLight> highLights = highlightsRequest.highlights()
+                .stream()
+                .flatMap(highlightRequest -> highlightRequest.lines().stream()
+                        .flatMap(line -> line.ranges().stream()
+                                .map(range -> new HighLight(
+                                        reviewGroupId, highlightsRequest.questionId(), highlightRequest.answerId(),
+                                        line.index(), range.startIndex(), range.endIndex()
+                                ))
+                        ))
+                .toList();
+        highlightRepository.saveAll(highLights);
     }
 }

backend/src/main/java/reviewme/highlight/service/exception/HighlightDuplicatedException.java

@@ -0,0 +1,14 @@
+package reviewme.highlight.service.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.BadRequestException;
+
+@Slf4j
+public class HighlightDuplicatedException extends BadRequestException {
+
+    public HighlightDuplicatedException(long answerId, long lineIndex, long startIndex, long endIndex) {
+        super("중복된 하이라이트는 생성할 수 없어요.");
+        log.info("Highlight is duplicated - answerId: {}, lineIndex: {}, startIndex: {}, endIndex: {}",
+                answerId, lineIndex, startIndex, endIndex);
+    }
+}

backend/src/main/java/reviewme/highlight/service/exception/InvalidHighlightLineIndexException.java

@@ -0,0 +1,13 @@
+package reviewme.highlight.service.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.BadRequestException;
+
+@Slf4j
+public class InvalidHighlightLineIndexException extends BadRequestException {
+
+    public InvalidHighlightLineIndexException(long submittedLineIndex, long maxLineIndex) {
+        super("줄 번호는 %d 이하여야해요.".formatted(maxLineIndex));
+        log.info("Line index is out of bound - maxIndex: {}, submittedLineIndex: {}", maxLineIndex, submittedLineIndex);
+    }
+}

backend/src/main/java/reviewme/highlight/service/exception/InvalidHighlightRangeException.java

@@ -0,0 +1,13 @@
+package reviewme.highlight.service.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.BadRequestException;
+
+@Slf4j
+public class InvalidHighlightRangeException extends BadRequestException {
+
+    public InvalidHighlightRangeException(long startIndex, long endIndex) {
+        super("하이라이트 시작 글자 인덱스는 종료 글자 인덱스보다 작아야해요.");
+        log.info("Highlight index is out of bound - startIndex: {}, endIndex: {}", startIndex, endIndex);
+    }
+}

backend/src/main/java/reviewme/highlight/service/exception/SubmittedAnswerAndProvidedAnswerMismatchException.java

@@ -0,0 +1,16 @@
+package reviewme.highlight.service.exception;
+
+import java.util.Collection;
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.BadRequestException;
+
+@Slf4j
+public class SubmittedAnswerAndProvidedAnswerMismatchException extends BadRequestException {
+
+    public SubmittedAnswerAndProvidedAnswerMismatchException(Collection<Long> providedAnswerIds,
+                                                             Collection<Long> submittedAnswerIds) {
+        super("제출된 응답이 제공된 응답과 일치하지 않아요.");
+        log.info("SubmittedAnswer and providedAnswer mismatch - providedAnswerIds: {}, submittedAnswerIds: {}",
+                providedAnswerIds, submittedAnswerIds);
+    }
+}

backend/src/main/java/reviewme/highlight/service/validator/HighlightKey.java

@@ -0,0 +1,38 @@
+package reviewme.highlight.service.validator;
+
+import java.util.Objects;
+import lombok.Getter;
+
+@Getter
+public class HighlightKey {
+
+    private final Long answerId;
+    private final Long lineIndex;
+    private final Long startIndex;
+    private final Long endIndex;
+
+    public HighlightKey(Long answerId, Long lineIndex, Long startIndex, Long endIndex) {
+        this.answerId = answerId;
+        this.lineIndex = lineIndex;
+        this.startIndex = startIndex;
+        this.endIndex = endIndex;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        HighlightKey that = (HighlightKey) o;
+        return answerId.equals(that.answerId) && lineIndex.equals(that.lineIndex) &&
+               startIndex.equals(that.startIndex) && endIndex.equals(that.endIndex);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(answerId, lineIndex, startIndex, endIndex);
+    }
+}

backend/src/main/java/reviewme/highlight/service/validator/HighlightValidator.java

@@ -0,0 +1,119 @@
+package reviewme.highlight.service.validator;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import reviewme.highlight.service.dto.HighlightRequest;
+import reviewme.highlight.service.dto.HighlightedLineRequest;
+import reviewme.highlight.service.dto.HighlightsRequest;
+import reviewme.highlight.service.exception.HighlightDuplicatedException;
+import reviewme.highlight.service.exception.InvalidHighlightLineIndexException;
+import reviewme.highlight.service.exception.InvalidHighlightRangeException;
+import reviewme.highlight.service.exception.SubmittedAnswerAndProvidedAnswerMismatchException;
+import reviewme.question.repository.QuestionRepository;
+import reviewme.review.domain.TextAnswer;
+import reviewme.review.repository.AnswerRepository;
+import reviewme.review.repository.TextAnswerRepository;
+import reviewme.review.service.exception.AnswerNotFoundByIdException;
+import reviewme.review.service.exception.SubmittedQuestionAndProvidedQuestionMismatchException;
+
+@Component
+@RequiredArgsConstructor
+public class HighlightValidator {
+
+    private final AnswerRepository answerRepository;
+    private final TextAnswerRepository textAnswerRepository;
+    private final QuestionRepository questionRepository;
+
+    public void validate(HighlightsRequest request, long reviewGroupId) {
+        validateAnswerByReviewGroup(request, reviewGroupId);
+        validateQuestionByReviewGroup(request, reviewGroupId);
+        validateAnswerByQuestion(request);
+        validateLineIndex(request);
+        validateRange(request);
+        validateDuplicate(request);
+    }
+
+    private void validateAnswerByReviewGroup(HighlightsRequest request, long reviewGroupId) {
+        Set<Long> providedAnswerIds = answerRepository.findIdsByReviewGroupId(reviewGroupId);
+        List<Long> submittedAnswerIds = request.highlights()
+                .stream()
+                .map(HighlightRequest::answerId)
+                .toList();
+
+        if (!providedAnswerIds.containsAll(submittedAnswerIds)) {
+            throw new SubmittedAnswerAndProvidedAnswerMismatchException(providedAnswerIds, submittedAnswerIds);
+        }
+    }
+
+    private void validateQuestionByReviewGroup(HighlightsRequest request, long reviewGroupId) {
+        Set<Long> providedQuestionIds = questionRepository.findIdsByReviewGroupId(reviewGroupId);
+        long submittedQuestionId = request.questionId();
+
+        if (!providedQuestionIds.contains(submittedQuestionId)) {
+            throw new SubmittedQuestionAndProvidedQuestionMismatchException(submittedQuestionId, providedQuestionIds);
+        }
+    }
+
+    private void validateAnswerByQuestion(HighlightsRequest request) {
+        Set<Long> providedAnswerIds = answerRepository.findIdsByQuestionId(request.questionId());
+        List<Long> submittedAnswerIds = request.highlights()
+                .stream()
+                .map(HighlightRequest::answerId)
+                .toList();
+
+        if (!providedAnswerIds.containsAll(submittedAnswerIds)) {
+            throw new SubmittedAnswerAndProvidedAnswerMismatchException(providedAnswerIds, submittedAnswerIds);
+        }
+    }
+
+    private void validateLineIndex(HighlightsRequest request) {
+        for (HighlightRequest highlight : request.highlights()) {
+            TextAnswer textAnswer = textAnswerRepository.findById(highlight.answerId())
+                    .orElseThrow(() -> new AnswerNotFoundByIdException(highlight.answerId()));
+            long maxLineIndex = textAnswer.getContent().lines().count();
+
+            for (HighlightedLineRequest line : highlight.lines()) {
+                long submittedLineIndex = line.index();
+                if (maxLineIndex < submittedLineIndex) {
+                    throw new InvalidHighlightLineIndexException(submittedLineIndex, maxLineIndex);
+                }
+            }
+        }
+    }
+
+    private void validateRange(HighlightsRequest request) {
+        request.highlights()
+                .stream()
+                .flatMap(highlightRequest -> highlightRequest.lines().stream()
+                        .flatMap(highlightedLineRequest -> highlightedLineRequest.ranges().stream()
+                                .filter(range -> range.startIndex() > range.endIndex())
+                        )
+                )
+                .findFirst()
+                .ifPresent(range -> {
+                    throw new InvalidHighlightRangeException(range.startIndex(), range.endIndex());
+                });
+    }
+
+    private void validateDuplicate(HighlightsRequest request) {
+        Set<HighlightKey> uniqueHighlights = new HashSet<>();
+
+        request.highlights().forEach(highlight ->
+                highlight.lines().forEach(line ->
+                        line.ranges().forEach(range -> {
+                            HighlightKey key = new HighlightKey(
+                                    highlight.answerId(), line.index(), range.startIndex(), range.endIndex()
+                            );
+                            if (!uniqueHighlights.add(key)) {
+                                throw new HighlightDuplicatedException(
+                                        highlight.answerId(), line.index(), range.startIndex(), range.endIndex()
+                                );
+                            }
+                        })
+                )
+        );
+    }
+}

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

@@ -27,4 +27,16 @@ public interface QuestionRepository extends JpaRepository<Question, Long> {
             WHERE ts.template_id = :templateId
             """, nativeQuery = true)
     List<Question> findAllByTemplatedId(long templateId);
+
+    @Query(value = """
+            SELECT q.id FROM question q
+            JOIN section_question sq
+            ON q.id = sq.question_id
+            JOIN template_section ts
+            ON sq.section_id = ts.section_id
+            JOIN review_group rg
+            ON ts.template_id = rg.template_id
+            WHERE rg.id = :reviewGroupId
+            """, nativeQuery = true)
+    Set<Long> findIdsByReviewGroupId(long reviewGroupId);
 }

backend/src/main/java/reviewme/review/repository/AnswerRepository.java

@@ -0,0 +1,27 @@
+package reviewme.review.repository;
+
+import java.util.Set;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+import reviewme.review.domain.Answer;
+
+@Repository
+public interface AnswerRepository extends JpaRepository<Answer, Long> {
+
+    @Query(value = """
+            select a.id from answer a
+            join new_review r
+            on a.review_id = r.id
+            where r.review_group_id = :reviewGroupId
+            """, nativeQuery = true)
+    Set<Long> findIdsByReviewGroupId(long reviewGroupId);
+
+    @Query(value = """
+            select a.id from answer a
+            join question q
+            on a.question_id = q.id
+            where q.id = :questionId
+            """, nativeQuery = true)
+    Set<Long> findIdsByQuestionId(long questionId);
+}