Dating Exam Answer Personality type 추가

src/main/java/deepple/deepple/datingexam/adapter/webapi/DatingExamApi.java

@@ -5,6 +5,7 @@
 import deepple.deepple.common.enums.StatusType;
 import deepple.deepple.common.response.BaseResponse;
 import deepple.deepple.datingexam.application.dto.DatingExamInfoWithSubjectSubmissionResponse;
+import deepple.deepple.datingexam.application.dto.DominantPersonalityTypeResponse;
 import deepple.deepple.datingexam.application.provided.DatingExamFinder;
 import deepple.deepple.datingexam.application.provided.DatingExamSubmitter;
 import deepple.deepple.datingexam.domain.dto.DatingExamSubmitRequest;
@@ -52,4 +53,14 @@ public ResponseEntity<BaseResponse<DatingExamInfoWithSubjectSubmissionResponse>>
             authContext.getId());
         return ResponseEntity.ok(BaseResponse.of(StatusType.OK, optionalExamInfo));
     }
+
+    @Operation(summary = "대표 성격 유형 조회 API")
+    @GetMapping("/personality-type")
+    public ResponseEntity<BaseResponse<DominantPersonalityTypeResponse>> getDominantPersonalityType(
+        @AuthPrincipal AuthContext authContext
+    ) {
+        final DominantPersonalityTypeResponse response = datingExamFinder.findDominantPersonalityType(
+            authContext.getId());
+        return ResponseEntity.ok(BaseResponse.of(StatusType.OK, response));
+    }
 }

src/main/java/deepple/deepple/datingexam/application/DatingExamModifyService.java

@@ -4,20 +4,19 @@
 import deepple.deepple.datingexam.application.dto.AllRequiredSubjectSubmittedEvent;
 import deepple.deepple.datingexam.application.dto.DatingExamInfoResponse;
 import deepple.deepple.datingexam.application.provided.DatingExamSubmitter;
-import deepple.deepple.datingexam.application.required.DatingExamQueryRepository;
-import deepple.deepple.datingexam.application.required.DatingExamSubjectRepository;
-import deepple.deepple.datingexam.application.required.DatingExamSubmitRepository;
-import deepple.deepple.datingexam.domain.DatingExamAnswerEncoder;
-import deepple.deepple.datingexam.domain.DatingExamSubject;
-import deepple.deepple.datingexam.domain.DatingExamSubmit;
-import deepple.deepple.datingexam.domain.SubjectType;
+import deepple.deepple.datingexam.application.required.*;
+import deepple.deepple.datingexam.domain.*;
+import deepple.deepple.datingexam.domain.dto.AnswerSubmitRequest;
 import deepple.deepple.datingexam.domain.dto.DatingExamSubmitRequest;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.validation.annotation.Validated;
 
+import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 @Service
 @Transactional
@@ -28,6 +27,8 @@ public class DatingExamModifyService implements DatingExamSubmitter {
     private final DatingExamSubmitRepository datingExamSubmitRepository;
     private final DatingExamQueryRepository datingExamQueryRepository;
     private final DatingExamAnswerEncoder answerEncoder;
+    private final DatingExamAnswerRepository datingExamAnswerRepository;
+    private final DatingExamSubmitResultRepository datingExamSubmitResultRepository;
 
     @Override
     @Transactional
@@ -36,6 +37,7 @@ public void submitSubject(DatingExamSubmitRequest submitRequest, long memberId)
         validateSubmit(submitRequest, subject, memberId);
         DatingExamSubmit datingExamSubmit = DatingExamSubmit.from(submitRequest, answerEncoder, memberId);
         datingExamSubmitRepository.save(datingExamSubmit);
+        updateSubmitResult(submitRequest, memberId);
         checkAndPublishAllRequiredSubjectsSubmitted(subject, memberId);
     }
 
@@ -63,6 +65,25 @@ private void checkAndPublishAllRequiredSubjectsSubmitted(DatingExamSubject subje
         }
     }
 
+    private void updateSubmitResult(DatingExamSubmitRequest submitRequest, long memberId) {
+        List<Long> answerIds = submitRequest.answers().stream()
+            .map(AnswerSubmitRequest::answerId)
+            .toList();
+
+        List<DatingExamAnswer> answers = datingExamAnswerRepository.findAllByIdIn(answerIds);
+
+        Map<AnswerPersonalityType, Integer> counts = answers.stream()
+            .collect(Collectors.groupingBy(
+                DatingExamAnswer::getPersonalityType,
+                Collectors.summingInt(e -> 1)
+            ));
+
+        DatingExamSubmitResult result = datingExamSubmitResultRepository.findByMemberIdForUpdate(memberId)
+            .orElseGet(() -> DatingExamSubmitResult.create(memberId));
+        result.addCounts(counts);
+        datingExamSubmitResultRepository.save(result);
+    }
+
     private boolean isAllRequiredSubjectsSubmitted(Long memberId) {
         Set<DatingExamSubject> requiredSubjects = datingExamSubjectRepository.findAllByType(
             SubjectType.REQUIRED);

src/main/java/deepple/deepple/datingexam/application/DatingExamQueryService.java

@@ -2,10 +2,13 @@
 
 import deepple.deepple.datingexam.application.dto.DatingExamInfoResponse;
 import deepple.deepple.datingexam.application.dto.DatingExamInfoWithSubjectSubmissionResponse;
+import deepple.deepple.datingexam.application.dto.DominantPersonalityTypeResponse;
 import deepple.deepple.datingexam.application.provided.DatingExamFinder;
 import deepple.deepple.datingexam.application.required.DatingExamQueryRepository;
 import deepple.deepple.datingexam.application.required.DatingExamSubmitRepository;
+import deepple.deepple.datingexam.application.required.DatingExamSubmitResultRepository;
 import deepple.deepple.datingexam.domain.DatingExamSubmit;
+import deepple.deepple.datingexam.domain.DatingExamSubmitResult;
 import deepple.deepple.datingexam.domain.SubjectType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -21,6 +24,7 @@
 public class DatingExamQueryService implements DatingExamFinder {
     private final DatingExamSubmitRepository datingExamSubmitRepository;
     private final DatingExamQueryRepository datingExamQueryRepository;
+    private final DatingExamSubmitResultRepository datingExamSubmitResultRepository;
 
     @Override
     public DatingExamInfoWithSubjectSubmissionResponse findRequiredExamInfo(Long memberId) {
@@ -35,4 +39,11 @@ public DatingExamInfoWithSubjectSubmissionResponse findOptionalExamInfo(Long mem
         Set<DatingExamSubmit> submittedExams = datingExamSubmitRepository.findAllByMemberId(memberId);
         return new DatingExamInfoWithSubjectSubmissionResponse(datingExamInfo, submittedExams);
     }
+
+    @Override
+    public DominantPersonalityTypeResponse findDominantPersonalityType(Long memberId) {
+        DatingExamSubmitResult result = datingExamSubmitResultRepository.findByMemberId(memberId)
+            .orElseThrow(() -> new IllegalStateException("연애고사 제출 결과가 없습니다. memberId: " + memberId));
+        return DominantPersonalityTypeResponse.from(result);
+    }
 }

src/main/java/deepple/deepple/datingexam/application/dto/DominantPersonalityTypeResponse.java

@@ -0,0 +1,24 @@
+package deepple.deepple.datingexam.application.dto;
+
+import deepple.deepple.datingexam.domain.AnswerPersonalityType;
+import deepple.deepple.datingexam.domain.DatingExamSubmitResult;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public record DominantPersonalityTypeResponse(
+    @Schema(implementation = AnswerPersonalityType.class)
+    String personalityType,
+    int decisiveIndependentCount,
+    int growingRunningMateCount,
+    int devotedRomanticCount,
+    int realisticShelterCount
+) {
+    public static DominantPersonalityTypeResponse from(DatingExamSubmitResult result) {
+        return new DominantPersonalityTypeResponse(
+            result.getDominantPersonalityType().name(),
+            result.getDecisiveIndependentCount(),
+            result.getGrowingRunningMateCount(),
+            result.getDevotedRomanticCount(),
+            result.getRealisticShelterCount()
+        );
+    }
+}

src/main/java/deepple/deepple/datingexam/application/provided/DatingExamFinder.java

@@ -1,9 +1,12 @@
 package deepple.deepple.datingexam.application.provided;
 
 import deepple.deepple.datingexam.application.dto.DatingExamInfoWithSubjectSubmissionResponse;
+import deepple.deepple.datingexam.application.dto.DominantPersonalityTypeResponse;
 
 public interface DatingExamFinder {
     DatingExamInfoWithSubjectSubmissionResponse findRequiredExamInfo(Long memberId);
 
     DatingExamInfoWithSubjectSubmissionResponse findOptionalExamInfo(Long memberId);
+
+    DominantPersonalityTypeResponse findDominantPersonalityType(Long memberId);
 }

src/main/java/deepple/deepple/datingexam/application/required/DatingExamAnswerRepository.java

@@ -0,0 +1,11 @@
+package deepple.deepple.datingexam.application.required;
+
+import deepple.deepple.datingexam.domain.DatingExamAnswer;
+import org.springframework.data.repository.Repository;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface DatingExamAnswerRepository extends Repository<DatingExamAnswer, Long> {
+    List<DatingExamAnswer> findAllByIdIn(Collection<Long> ids);
+}

src/main/java/deepple/deepple/datingexam/application/required/DatingExamSubmitResultRepository.java

@@ -0,0 +1,20 @@
+package deepple.deepple.datingexam.application.required;
+
+import deepple.deepple.datingexam.domain.DatingExamSubmitResult;
+import jakarta.persistence.LockModeType;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.Repository;
+import org.springframework.data.repository.query.Param;
+
+import java.util.Optional;
+
+public interface DatingExamSubmitResultRepository extends Repository<DatingExamSubmitResult, Long> {
+    Optional<DatingExamSubmitResult> findByMemberId(Long memberId);
+
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT r FROM DatingExamSubmitResult r WHERE r.memberId = :memberId")
+    Optional<DatingExamSubmitResult> findByMemberIdForUpdate(@Param("memberId") Long memberId);
+
+    DatingExamSubmitResult save(DatingExamSubmitResult result);
+}

src/main/java/deepple/deepple/datingexam/domain/AnswerPersonalityType.java

@@ -0,0 +1,8 @@
+package deepple.deepple.datingexam.domain;
+
+public enum AnswerPersonalityType {
+    DECISIVE_INDEPENDENT,    // (A) 단호한 독립주의자
+    GROWING_RUNNING_MATE,    // (B) 성장하는 러닝메이트
+    DEVOTED_ROMANTIC,        // (C) 헌신적인 로맨티스트
+    REALISTIC_SHELTER        // (D) 현실적인 안식처
+}

src/main/java/deepple/deepple/datingexam/domain/DatingExamAnswer.java

@@ -2,10 +2,7 @@
 
 import deepple.deepple.common.entity.BaseEntity;
 import deepple.deepple.datingexam.domain.exception.InvalidDatingExamAnswerContentException;
-import jakarta.persistence.Column;
-import jakarta.persistence.Entity;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.Id;
+import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.NonNull;
@@ -27,13 +24,18 @@ public class DatingExamAnswer extends BaseEntity {
     @Column(nullable = false)
     private String content;
 
-    private DatingExamAnswer(Long questionId, String content) {
+    @Enumerated(EnumType.STRING)
+    @Column(columnDefinition = "varchar(50)", nullable = false)
+    private AnswerPersonalityType personalityType;
+
+    private DatingExamAnswer(Long questionId, String content, AnswerPersonalityType personalityType) {
         setQuestionId(questionId);
         setContent(content);
+        setPersonalityType(personalityType);
     }
 
-    public static DatingExamAnswer create(Long questionId, String content) {
-        return new DatingExamAnswer(questionId, content);
+    public static DatingExamAnswer create(Long questionId, String content, AnswerPersonalityType personalityType) {
+        return new DatingExamAnswer(questionId, content, personalityType);
     }
 
     private void setQuestionId(@NonNull Long questionId) {
@@ -46,4 +48,8 @@ private void setContent(@NonNull String content) {
         }
         this.content = content;
     }
+
+    private void setPersonalityType(@NonNull AnswerPersonalityType personalityType) {
+        this.personalityType = personalityType;
+    }
 }

src/main/java/deepple/deepple/datingexam/domain/DatingExamSubmitResult.java

@@ -0,0 +1,86 @@
+package deepple.deepple.datingexam.domain;
+
+import deepple.deepple.common.entity.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+
+import java.util.Map;
+
+import static jakarta.persistence.GenerationType.IDENTITY;
+import static lombok.AccessLevel.PROTECTED;
+
+@Entity
+@NoArgsConstructor(access = PROTECTED)
+@Getter
+@Table(
+    uniqueConstraints = @UniqueConstraint(
+        name = "uk_dating_exam_submit_result_member",
+        columnNames = {"memberId"}
+    )
+)
+public class DatingExamSubmitResult extends BaseEntity {
+    @Id
+    @GeneratedValue(strategy = IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long memberId;
+
+    @Column(nullable = false)
+    private int decisiveIndependentCount;
+
+    @Column(nullable = false)
+    private int growingRunningMateCount;
+
+    @Column(nullable = false)
+    private int devotedRomanticCount;
+
+    @Column(nullable = false)
+    private int realisticShelterCount;
+
+    @Enumerated(EnumType.STRING)
+    @Column(columnDefinition = "varchar(50)", nullable = false)
+    private AnswerPersonalityType dominantPersonalityType;
+
+    private DatingExamSubmitResult(@NonNull Long memberId) {
+        this.memberId = memberId;
+        this.decisiveIndependentCount = 0;
+        this.growingRunningMateCount = 0;
+        this.devotedRomanticCount = 0;
+        this.realisticShelterCount = 0;
+        this.dominantPersonalityType = AnswerPersonalityType.DECISIVE_INDEPENDENT;
+    }
+
+    public static DatingExamSubmitResult create(Long memberId) {
+        return new DatingExamSubmitResult(memberId);
+    }
+
+    public void addCounts(Map<AnswerPersonalityType, Integer> counts) {
+        this.decisiveIndependentCount += counts.getOrDefault(AnswerPersonalityType.DECISIVE_INDEPENDENT, 0);
+        this.growingRunningMateCount += counts.getOrDefault(AnswerPersonalityType.GROWING_RUNNING_MATE, 0);
+        this.devotedRomanticCount += counts.getOrDefault(AnswerPersonalityType.DEVOTED_ROMANTIC, 0);
+        this.realisticShelterCount += counts.getOrDefault(AnswerPersonalityType.REALISTIC_SHELTER, 0);
+        recalculateDominant();
+    }
+
+    private void recalculateDominant() {
+        AnswerPersonalityType dominant = AnswerPersonalityType.DECISIVE_INDEPENDENT;
+        int maxCount = this.decisiveIndependentCount;
+
+        if (this.growingRunningMateCount > maxCount) {
+            dominant = AnswerPersonalityType.GROWING_RUNNING_MATE;
+            maxCount = this.growingRunningMateCount;
+        }
+        if (this.devotedRomanticCount > maxCount) {
+            dominant = AnswerPersonalityType.DEVOTED_ROMANTIC;
+            maxCount = this.devotedRomanticCount;
+        }
+        if (this.realisticShelterCount > maxCount) {
+            dominant = AnswerPersonalityType.REALISTIC_SHELTER;
+        }
+
+        this.dominantPersonalityType = dominant;
+    }
+}

src/main/resources/db/migration/V11__reset_dating_exams.sql

@@ -0,0 +1,13 @@
+-- 기존 데이터 삭제 (submit → answer → question → subject 순서)
+DELETE
+FROM dating_exam_submit;
+DELETE
+FROM dating_exam_answer;
+DELETE
+FROM dating_exam_question;
+DELETE
+FROM dating_exam_subject;
+
+-- members 테이블의 is_dating_exam_submitted를 전체 false로 초기화
+UPDATE members
+SET is_dating_exam_submitted = FALSE;

src/main/resources/db/migration/V12__add_personality_type_column.sql

@@ -0,0 +1,2 @@
+ALTER TABLE dating_exam_answer
+    ADD COLUMN personality_type VARCHAR(50) NOT NULL;