[FEAT]: 투표 게시글 생성 및 투표 기능 구현 (#48)

* [Feat]: 투표 게시글 생성 기능 구현

* [Feat]: 투표 게시글 본문에 보여줄 선택지 응답 DTO 구현

* [Feat]: Post, PollVote 엔티티 @JdbcTypeCode(SqlTypes.JSON) 추가로 JSON 타입 처리

* [Feat]: 선택한 투표 번호를 입력하는 요청 DTO 추가

* [Feat]: 투표 기능 및 결과 조회 기능 구현

* [Feat]: 게시글, 댓글 인덱스 추가

* [Feat]: 투표 게시글 생성 테스트 구현

* [Feat]: 데이터베이스 제약조건 예외 추가

* [Feat]: 투표 관련 테스트 추가

* [Feat]: 투표 참여 엔티티 userHash 필드 제거 및 유니크 제약조건 삭제

* [Feat]: 잡담, 투표 게시글 및 댓글 더미데이터 추가

Author: shihan00321

back/src/main/java/com/back/domain/comment/entity/Comment.java

@@ -20,7 +20,11 @@
  * 계층형 댓글 구조를 지원합니다.
  */
 @Entity
-@Table(name = "comments")
+@Table(name = "comments",
+        indexes = {
+                @Index(name = "idx_comment_post_created", columnList = "post_id, created_date desc"),
+                @Index(name = "idx_comment_post_like", columnList = "post_id, like_count desc")
+        })
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor(access = AccessLevel.PROTECTED)

back/src/main/java/com/back/domain/poll/controller/PollVoteController.java

@@ -1,18 +1,41 @@
 package com.back.domain.poll.controller;
 
+import com.back.domain.poll.dto.PollResponse;
+import com.back.domain.poll.dto.VoteRequest;
 import com.back.domain.poll.service.PollVoteService;
+import com.back.global.security.CustomUserDetails;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
 
 /**
  * 투표 관련 API 요청을 처리하는 컨트롤러.
  */
 @RestController
-@RequestMapping("/api/v1/polls")
+@RequestMapping("/api/v1/posts/{postId}/polls")
 @RequiredArgsConstructor
 public class PollVoteController {
 
     private final PollVoteService pollVoteService;
 
+    @PostMapping
+    public ResponseEntity<Void> vote(
+            @PathVariable Long postId,
+            @RequestBody @Valid VoteRequest request,
+            @AuthenticationPrincipal CustomUserDetails cs) {
+
+        pollVoteService.vote(cs.getUser(), postId, request);
+        return ResponseEntity.ok().build();
+    }
+
+    @GetMapping
+    public ResponseEntity<PollResponse> getVote(
+            @PathVariable Long postId,
+            @AuthenticationPrincipal CustomUserDetails cs) {
+
+        PollResponse response = pollVoteService.getVote(postId);
+        return ResponseEntity.ok().body(response);
+    }
 }

back/src/main/java/com/back/domain/poll/converter/PollConverter.java

@@ -0,0 +1,80 @@
+package com.back.domain.poll.converter;
+
+import com.back.domain.poll.dto.PollOptionResponse;
+import com.back.domain.poll.dto.PollRequest;
+import com.back.domain.poll.dto.PollResponse;
+import com.back.domain.poll.dto.VoteRequest;
+import com.back.global.exception.ApiException;
+import com.back.global.exception.ErrorCode;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * PollVote, Post 필드 JSON 변환기
+ */
+@Component
+@RequiredArgsConstructor
+public class PollConverter {
+
+    private final ObjectMapper objectMapper;
+
+    // json 형태의 문자열 -> PollResponse
+    public PollResponse fromPollJson(String voteContent) {
+        if (voteContent == null) return null;
+        try {
+            return objectMapper.readValue(voteContent, PollResponse.class);
+        } catch (JsonProcessingException e) {
+            throw new ApiException(ErrorCode.POLL_VOTE_INVALID_FORMAT);
+        }
+    }
+
+    // json 형태의 문자열 -> 리스트
+    public List<Integer> fromChoiceJson(String choiceJson) {
+        if (choiceJson == null) return List.of();
+        try {
+            VoteRequest req = objectMapper.readValue(choiceJson, VoteRequest.class);
+            return req.choice();
+        } catch (JsonProcessingException e) {
+            throw new ApiException(ErrorCode.POLL_VOTE_INVALID_FORMAT);
+        }
+    }
+
+    // [1,2] => "{"choice":[1,2]} 형태로 변환
+    public String toChoiceJson(List<Integer> selectedIndexes) {
+        try {
+            Map<String, Object> map = Map.of("choice", selectedIndexes);
+            return objectMapper.writeValueAsString(map);
+        } catch (JsonProcessingException e) {
+            throw new ApiException(ErrorCode.POLL_VOTE_INVALID_FORMAT);
+        }
+    }
+
+    // {"options":[{"index":1,"text":"첫 번째 옵션"},{...}, "pollUid":"UUID"}
+    public String toPollContentJson(UUID pollUid, List<PollRequest.PollOption> options) {
+        try {
+            Map<String, Object> pollMap = new HashMap<>();
+            pollMap.put("pollUid", pollUid.toString());
+            pollMap.put("options", options);
+            return objectMapper.writeValueAsString(pollMap);
+        } catch (JsonProcessingException e) {
+            throw new ApiException(ErrorCode.POLL_VOTE_INVALID_FORMAT);
+        }
+    }
+
+    // json 형태의 문자열 -> PollOptionResponse
+    public PollOptionResponse fromPollOptionJson(String voteContent) {
+        if (voteContent == null) return null;
+        try {
+            return objectMapper.readValue(voteContent, PollOptionResponse.class);
+        } catch (JsonProcessingException e) {
+            throw new ApiException(ErrorCode.POLL_VOTE_INVALID_FORMAT);
+        }
+    }
+}

back/src/main/java/com/back/domain/poll/dto/PollOptionResponse.java

@@ -0,0 +1,15 @@
+package com.back.domain.poll.dto;
+
+import java.util.List;
+
+/**
+ * 투표 선택지 응답 DTO
+ */
+public record PollOptionResponse(
+        List<VoteOption> options
+) {
+    public record VoteOption(
+            int index,
+            String text
+    ) {}
+}

back/src/main/java/com/back/domain/poll/dto/PollRequest.java

@@ -0,0 +1,21 @@
+package com.back.domain.poll.dto;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+import java.util.List;
+
+public record PollRequest(
+        @NotNull
+        @Size(min = 2, max = 10)
+        List<PollOption> options
+) {
+    public record PollOption(
+            @Min(value = 1, message = "투표 옵션 인덱스는 1 이상이어야 합니다.")
+            int index,
+            @NotNull(message = "투표 옵션 텍스트는 필수입니다.")
+            String text
+    ) {}
+}
+

back/src/main/java/com/back/domain/poll/dto/PollResponse.java

@@ -0,0 +1,17 @@
+package com.back.domain.poll.dto;
+
+import java.util.List;
+
+/**
+ * 투표 결과를 보여주는 DTO
+ */
+public record PollResponse(
+        String pollUid,
+        List<VoteDetail> options
+) {
+    public record VoteDetail(
+            int index,
+            String text,
+            Integer voteCount
+    ) {}
+}

back/src/main/java/com/back/domain/poll/dto/VoteRequest.java

@@ -0,0 +1,15 @@
+package com.back.domain.poll.dto;
+
+import jakarta.validation.constraints.NotEmpty;
+
+import java.util.List;
+
+/**
+ * 선택한 투표 번호
+ * 다중 선택 가능 [1, 2] or [1] ...
+ */
+public record VoteRequest(
+        @NotEmpty(message = "최소 하나의 선택지는 필수입니다")
+        List<Integer> choice
+) {
+}

back/src/main/java/com/back/domain/poll/entity/PollVote.java

@@ -8,7 +8,8 @@
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import lombok.Setter;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
 
 import java.util.UUID;
 
@@ -19,14 +20,12 @@
 @Entity
 @Table(name = "poll_votes",
     uniqueConstraints = {
-        @UniqueConstraint(name = "uq_logged_in_once", columnNames = {"post_id", "pollUid", "user_id"}),
-        @UniqueConstraint(name = "uq_anonymous_once", columnNames = {"post_id", "pollUid", "userHash"})
+        @UniqueConstraint(name = "uq_logged_in_once", columnNames = {"post_id", "pollUid", "user_id"})
     }
 )
 @Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
+@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
+@AllArgsConstructor(access = lombok.AccessLevel.PROTECTED)
 @Builder
 public class PollVote extends BaseEntity {
 
@@ -41,9 +40,8 @@ public class PollVote extends BaseEntity {
     @JoinColumn(name = "user_id")
     private User user;
 
-    @Column(length = 128)
-    private String userHash;
-
+    @JdbcTypeCode(SqlTypes.JSON)
     @Column(nullable = false, columnDefinition = "jsonb")
     private String choiceJson;
+
 }

back/src/main/java/com/back/domain/poll/repository/PollVoteRepository.java

@@ -1,12 +1,20 @@
 package com.back.domain.poll.repository;
 
 import com.back.domain.poll.entity.PollVote;
+import com.back.domain.post.entity.Post;
+import com.back.domain.user.entity.User;
 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;
+import java.util.Map;
+
 /**
  * 투표 참여 엔티티에 대한 데이터베이스 접근을 담당하는 JpaRepository.
  */
 @Repository
 public interface PollVoteRepository extends JpaRepository<PollVote, Long> {
+    List<PollVote> findByPostId(@Param("postId") Long postId);
 }

back/src/main/java/com/back/domain/poll/service/PollVoteService.java

@@ -1,16 +1,92 @@
 package com.back.domain.poll.service;
 
+import com.back.domain.poll.converter.PollConverter;
+import com.back.domain.poll.dto.PollResponse;
+import com.back.domain.poll.dto.VoteRequest;
+import com.back.domain.poll.entity.PollVote;
 import com.back.domain.poll.repository.PollVoteRepository;
+import com.back.domain.post.entity.Post;
+import com.back.domain.post.repository.PostRepository;
+import com.back.domain.user.entity.User;
+import com.back.global.exception.ApiException;
+import com.back.global.exception.ErrorCode;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
 
 /**
  * 투표 관련 비즈니스 로직을 처리하는 서비스.
  */
 @Service
 @RequiredArgsConstructor
+@Transactional(readOnly = true)
 public class PollVoteService {
 
     private final PollVoteRepository pollVoteRepository;
+    private final PostRepository postRepository;
+    private final PollConverter pollConverter;
+
+    @Transactional
+    public void vote(User user, Long postId, @Valid VoteRequest request) {
+        Post post = postRepository.findById(postId)
+                .orElseThrow(() -> new ApiException(ErrorCode.POST_NOT_FOUND));
+
+        // 요청에서 투표 항목 파싱
+        PollResponse pollContent = pollConverter.fromPollJson(post.getVoteContent());
+
+        // 유효한 옵션 검증
+        validationOptions(request, pollContent);
+
+        // 선택값 JSON 변환
+        String choiceJson = pollConverter.toChoiceJson(request.choice());
+
+        PollVote pollVote = PollVote.builder()
+                .post(post)
+                .pollUid(UUID.fromString(pollContent.pollUid()))
+                .user(user)
+                .choiceJson(choiceJson)
+                .build();
+
+        pollVoteRepository.save(pollVote);
+    }
+
+    public PollResponse getVote(Long postId) {
+        Post post = postRepository.findById(postId)
+                .orElseThrow(() -> new ApiException(ErrorCode.POST_NOT_FOUND));
+
+        // PollVote 조회 후 choiceJson 필드 파싱 [1,2], [2] ...
+        // 평탄화 작업 진행 후 1, 2, 2 카운팅
+        Map<Integer, Long> countMap = pollVoteRepository.findByPostId(postId).stream()
+                .flatMap(pv -> pollConverter.fromChoiceJson(pv.getChoiceJson()).stream())
+                .collect(Collectors.groupingBy(i -> i, Collectors.counting()));
+
+        PollResponse pollContent = pollConverter.fromPollJson(post.getVoteContent());
+
+        // 옵션별 voteCount 매핑
+        List<PollResponse.VoteDetail> options = pollContent.options().stream()
+                .map(opt -> new PollResponse.VoteDetail(
+                        opt.index(),
+                        opt.text(),
+                        countMap.getOrDefault(opt.index(), 0L).intValue()
+                ))
+                .toList();
+
+        return new PollResponse(pollContent.pollUid(), options);
+    }
 
+    private static void validationOptions(VoteRequest request, PollResponse pollContent) {
+        for (Integer selectedIndex : request.choice()) {
+            boolean exists = pollContent.options().stream()
+                    .anyMatch(opt -> opt.index() == selectedIndex);
+            if (!exists) {
+                throw new ApiException(ErrorCode.POLL_VOTE_INVALID_OPTION);
+            }
+        }
+    }
 }