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

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

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

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

@@ -0,0 +1,36 @@
+package reviewme.highlight.domain;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Embedded;
+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 = "answer_id", nullable = false)
+    private long answerId;
+
+    @Embedded
+    private HighlightPosition highlightPosition;
+
+    public Highlight(long answerId, long lineIndex, long startIndex, long endIndex) {
+        this.answerId = answerId;
+        this.highlightPosition = new HighlightPosition(lineIndex, startIndex, endIndex);
+    }
+}

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

@@ -0,0 +1,46 @@
+package reviewme.highlight.domain;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import reviewme.highlight.domain.exception.HighlightStartIndexExceedEndIndexException;
+import reviewme.highlight.domain.exception.NegativeHighlightIndexException;
+
+@Embeddable
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+@EqualsAndHashCode
+public class HighlightPosition {
+
+    @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 HighlightPosition(long lineIndex, long startIndex, long endIndex) {
+        validatePositiveIndexNumber(startIndex, endIndex);
+        validateEndIndexOverStartIndex(startIndex, endIndex);
+        this.lineIndex = lineIndex;
+        this.startIndex = startIndex;
+        this.endIndex = endIndex;
+    }
+
+    private void validatePositiveIndexNumber(long startIndex, long endIndex) {
+        if (startIndex < 0 || endIndex < 0) {
+            throw new NegativeHighlightIndexException(startIndex, endIndex);
+        }
+    }
+
+    private void validateEndIndexOverStartIndex(long startIndex, long endIndex) {
+        if (startIndex > endIndex) {
+            throw new HighlightStartIndexExceedEndIndexException(startIndex, endIndex);
+        }
+    }
+}

backend/src/main/java/reviewme/highlight/domain/exception/HighlightStartIndexExceedEndIndexException.java

@@ -0,0 +1,13 @@
+package reviewme.highlight.domain.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.BadRequestException;
+
+@Slf4j
+public class HighlightStartIndexExceedEndIndexException extends BadRequestException {
+
+    public HighlightStartIndexExceedEndIndexException(long startIndex, long endIndex) {
+        super("하이라이트 끝 위치는 시작 위치보다 같거나 커야 해요.");
+        log.info("Highlight start index exceed end index - startIndex: {}, endIndex: {}", startIndex, endIndex);
+    }
+}

backend/src/main/java/reviewme/highlight/domain/exception/NegativeHighlightIndexException.java

@@ -0,0 +1,13 @@
+package reviewme.highlight.domain.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.BadRequestException;
+
+@Slf4j
+public class NegativeHighlightIndexException extends BadRequestException {
+
+    public NegativeHighlightIndexException(long startIndex, long endIndex) {
+        super("하이라이트 위치는 1 이상의 수이어야 해요.");
+        log.info("Highlight index is a negative number - startIndex: {}, endIndex: {}", startIndex, endIndex);
+    }
+}

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

@@ -0,0 +1,7 @@
+package reviewme.highlight.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import reviewme.highlight.domain.Highlight;
+
+public interface HighlightRepository extends JpaRepository<Highlight, Long> {
+}

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

@@ -1,12 +1,65 @@
 package reviewme.highlight.service;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+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.HighlightIndexRangeRequest;
+import reviewme.highlight.service.dto.HighlightRequest;
+import reviewme.highlight.service.dto.HighlightedLineRequest;
 import reviewme.highlight.service.dto.HighlightsRequest;
+import reviewme.highlight.service.validator.HighlightValidator;
+import reviewme.review.domain.Answer;
+import reviewme.review.repository.AnswerRepository;
+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 AnswerRepository answerRepository;
+
+    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);
+    }
+
+    private void deleteOldHighlight(long questionId, long reviewGroupId) {
+        Set<Answer> answersByReviewGroup = answerRepository.findAllByReviewGroupId(reviewGroupId);
+        List<Long> answersByReviewQuestion = answersByReviewGroup.stream()
+                .filter(answer -> answer.getQuestionId() == questionId)
+                .map(Answer::getId)
+                .toList();
+
+        highlightRepository.deleteAllById(answersByReviewQuestion);
+    }
+
+    private void saveNewHighlight(HighlightsRequest highlightsRequest) {
+        List<Highlight> highlights = new ArrayList<>();
+        for (HighlightRequest highlight : highlightsRequest.highlights()) {
+            for (HighlightedLineRequest line : highlight.lines()) {
+                for (HighlightIndexRangeRequest range : line.ranges()) {
+                    Highlight highLight = new Highlight(highlight.answerId(),
+                            line.index(), range.startIndex(), range.endIndex());
+                    highlights.add(highLight);
+                }
+            }
+        }
+        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/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/HighlightValidator.java

@@ -0,0 +1,87 @@
+package reviewme.highlight.service.validator;
+
+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.InvalidHighlightLineIndexException;
+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;
+import reviewme.reviewgroup.repository.ReviewGroupRepository;
+
+@Component
+@RequiredArgsConstructor
+public class HighlightValidator {
+
+    private final AnswerRepository answerRepository;
+    private final TextAnswerRepository textAnswerRepository;
+    private final QuestionRepository questionRepository;
+    private final ReviewGroupRepository reviewGroupRepository;
+
+    public void validate(HighlightsRequest request, long reviewGroupId) {
+        validateReviewGroupContainsQuestion(request, reviewGroupId);
+        validateReviewGroupContainsAnswer(request, reviewGroupId);
+        validateQuestionContainsAnswer(request);
+        validateLineIndex(request);
+        // TODO: 중복 요청 검증 추가 예정
+    }
+
+    private void validateReviewGroupContainsQuestion(HighlightsRequest request, long reviewGroupId) {
+        long templateId = reviewGroupRepository.findById(reviewGroupId)
+                .orElseThrow()
+                .getTemplateId();
+        Set<Long> providedQuestionIds = questionRepository.findAllQuestionIdByTemplateId(templateId);
+        long submittedQuestionId = request.questionId();
+
+        if (!providedQuestionIds.contains(submittedQuestionId)) {
+            throw new SubmittedQuestionAndProvidedQuestionMismatchException(submittedQuestionId, providedQuestionIds);
+        }
+    }
+
+    private void validateReviewGroupContainsAnswer(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 validateQuestionContainsAnswer(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);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+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 Review r
+            ON a.reviewId = r.id
+            WHERE r.reviewGroupId = :reviewGroupId
+            """)
+    Set<Long> findIdsByReviewGroupId(long reviewGroupId);
+
+    @Query(value = """
+            SELECT a FROM Answer a
+            JOIN Review r 
+            ON a.reviewId = r.id 
+            WHERE r.reviewGroupId = :reviewGroupId 
+            """)
+    Set<Answer> findAllByReviewGroupId(long reviewGroupId);
+
+    @Query(value = """
+            SELECT a.id FROM Answer a
+            JOIN Question q
+            ON a.questionId = q.id
+            WHERE q.id = :questionId
+            """)
+    Set<Long> findIdsByQuestionId(long questionId);
+}

backend/src/main/java/reviewme/review/service/exception/AnswerNotFoundByIdException.java

@@ -0,0 +1,13 @@
+package reviewme.review.service.exception;
+
+import lombok.extern.slf4j.Slf4j;
+import reviewme.global.exception.NotFoundException;
+
+@Slf4j
+public class AnswerNotFoundByIdException extends NotFoundException {
+
+    public AnswerNotFoundByIdException(long answerId) {
+        super("답변을 찾을 수 없어요.");
+        log.info("Answer not found by id - answerId: {}", answerId);
+    }
+}