#389 [Merge] dev 변경사항을 main에 반영 (v2.0.32)

src/main/java/com/swyp/picke/domain/battle/converter/BattleConverter.java

@@ -8,6 +8,7 @@
 import com.swyp.picke.domain.battle.enums.BattleCreatorType;
 import com.swyp.picke.domain.tag.entity.Tag;
 import com.swyp.picke.domain.tag.enums.TagType;
+import com.swyp.picke.domain.user.enums.PhilosopherType;
 import com.swyp.picke.domain.user.entity.User;
 import com.swyp.picke.domain.user.enums.UserBattleStep;
 import com.swyp.picke.domain.user.enums.VoteSide;
@@ -165,6 +166,8 @@ private List<BattleTagResponse> toTagResponses(List<Tag> tags, TagType targetTyp
         if (tags == null) return List.of();
         return tags.stream()
                 .filter(tag -> targetType == null || tag.getType() == targetType)
+                .filter(tag -> tag.getType() != TagType.PHILOSOPHER
+                        || PhilosopherType.fromLabel(tag.getName()) != null)
                 .map(tag -> new BattleTagResponse(tag.getId(), tag.getName(), tag.getType()))
                 .toList();
     }

src/main/java/com/swyp/picke/domain/battle/service/BattleQueryService.java

@@ -13,6 +13,7 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import com.swyp.picke.domain.tag.enums.TagType;
+import com.swyp.picke.domain.user.enums.PhilosopherType;
 
 import java.util.List;
 import java.util.Map;
@@ -84,6 +85,7 @@ public Optional<String> getTopPhilosopherTagNameFromOptions(List<Long> optionIds
 
         return optionTags.stream()
                 .filter(bot -> bot.getTag().getType() == TagType.PHILOSOPHER)
+                .filter(bot -> PhilosopherType.fromLabel(bot.getTag().getName()) != null)
                 .collect(Collectors.groupingBy(
                         bot -> bot.getTag().getName(),
                         Collectors.counting()

src/main/java/com/swyp/picke/domain/battle/service/BattleServiceImpl.java

@@ -15,6 +15,7 @@
 import com.swyp.picke.domain.battle.util.BattleOptionDisplay;
 import com.swyp.picke.domain.user.dto.response.UserBattleStatusResponse;
 import com.swyp.picke.domain.user.enums.UserBattleStep;
+import com.swyp.picke.domain.user.enums.PhilosopherType;
 import com.swyp.picke.domain.battle.repository.BattleOptionRepository;
 import com.swyp.picke.domain.battle.repository.BattleOptionTagRepository;
 import com.swyp.picke.domain.battle.repository.BattleRepository;
@@ -649,6 +650,8 @@ private void saveBattleOptionTags(BattleOption option, List<Long> tagIds) {
         tagRepository.findAllById(tagIds).stream()
                 .filter(tag -> tag.getDeletedAt() == null)
                 .filter(tag -> tag.getType() == TagType.PHILOSOPHER || tag.getType() == TagType.VALUE)
+                .filter(tag -> tag.getType() != TagType.PHILOSOPHER
+                        || PhilosopherType.fromLabel(tag.getName()) != null)
                 .forEach(tag -> battleOptionTagRepository.save(
                         BattleOptionTag.builder().battleOption(option).tag(tag).build()));
     }

src/main/java/com/swyp/picke/domain/tag/service/TagServiceImpl.java

@@ -12,6 +12,7 @@
 import com.swyp.picke.domain.tag.entity.Tag;
 import com.swyp.picke.domain.tag.enums.TagType;
 import com.swyp.picke.domain.tag.repository.TagRepository;
+import com.swyp.picke.domain.user.enums.PhilosopherType;
 import com.swyp.picke.global.common.exception.CustomException;
 import com.swyp.picke.global.common.exception.ErrorCode;
 import lombok.RequiredArgsConstructor;
@@ -46,13 +47,16 @@ public TagListResponse getTags(TagType type) {
         List<Tag> tags = (type != null)
                 ? tagRepository.findAllByTypeAndDeletedAtIsNull(type)
                 : tagRepository.findAllByDeletedAtIsNull();
-        return TagConverter.toListResponse(tags);
+        return TagConverter.toListResponse(tags.stream()
+                .filter(this::isSupportedPhilosopherTag)
+                .toList());
     }
 
     @Override
     @Transactional
     @PreAuthorize("hasRole('ADMIN')")
     public TagResponse createTag(TagRequest request) {
+        validatePhilosopherTag(request.name(), request.type());
         validateDuplicateTag(request.name(), request.type());
 
         Tag newTag = TagConverter.toEntity(request);
@@ -66,6 +70,7 @@ public TagResponse createTag(TagRequest request) {
     @PreAuthorize("hasRole('ADMIN')")
     public TagResponse updateTag(Long tagId, TagRequest request) {
         Tag tag = findTagById(tagId);
+        validatePhilosopherTag(request.name(), request.type());
         boolean typeChanged = tag.getType() != request.type();
 
         if (!tag.getName().equals(request.name()) || tag.getType() != request.type()) {
@@ -105,6 +110,17 @@ private void validateDuplicateTag(String name, TagType type) {
         }
     }
 
+    private void validatePhilosopherTag(String name, TagType type) {
+        if (type == TagType.PHILOSOPHER && PhilosopherType.fromLabel(name) == null) {
+            throw new CustomException(ErrorCode.BAD_REQUEST);
+        }
+    }
+
+    private boolean isSupportedPhilosopherTag(Tag tag) {
+        return tag.getType() != TagType.PHILOSOPHER
+                || PhilosopherType.fromLabel(tag.getName()) != null;
+    }
+
     private boolean isTagInUse(Tag tag) {
         return battleTagRepository.existsByTag(tag) || battleOptionTagRepository.existsByTag(tag);
     }

src/main/java/com/swyp/picke/domain/user/entity/UserTendencyScore.java

@@ -1,5 +1,6 @@
 package com.swyp.picke.domain.user.entity;
 
+import com.swyp.picke.domain.user.enums.ValueAxis;
 import com.swyp.picke.global.common.BaseEntity;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
@@ -57,4 +58,22 @@ public void update(int principle, int reason, int individual,
         this.inner = inner;
         this.ideal = ideal;
     }
+
+    public void applyValueTag(String tagName) {
+        applyValueTag(tagName, 1);
+    }
+
+    public void applyValueTag(String tagName, int multiplier) {
+        ValueAxis.resolve(tagName).ifPresent(value -> {
+            int direction = value.direction() * multiplier;
+            switch (value.axis()) {
+                case PRINCIPLE -> principle += direction;
+                case REASON -> reason += direction;
+                case INDIVIDUAL -> individual += direction;
+                case CHANGE -> change += direction;
+                case INNER -> inner += direction;
+                case IDEAL -> ideal += direction;
+            }
+        });
+    }
 }

src/main/java/com/swyp/picke/domain/user/enums/PhilosopherType.java

@@ -52,29 +52,11 @@ public enum PhilosopherType {
             "BUDDHA", "CONFUCIUS",
             22, 38, 68, 88, 94, 70,
             "images/philosophers/laozi.png"),
-    BUDDHA("붓다", "내면형", "외부의 소음에서 벗어나 마음속 깊은 평화와 고요를 찾는 수행자",
+    BUDDHA("석가모니", "내면형", "외부의 소음에서 벗어나 마음속 깊은 평화와 고요를 찾는 수행자",
             List.of("#평화", "#내면", "#명상", "#해탈"),
             "LAOZI", "ARISTOTLE",
             35, 55, 42, 48, 96, 62,
-            "images/philosophers/buddha.png"),
-    AQUINAS("토마스 아퀴나스", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/aquinas.png"),
-    CAMUS("카뮈", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/camus.png"),
-    CHOE_HANGI("최한기", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/choe_hangi.png"),
-    DESCARTES("데카르트", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/descartes.png"),
-    EPICURUS("에피쿠로스", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/epicurus.png"),
-    FROMM("에리히 프롬", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/fromm.png"),
-    HOBBES("홉스", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/hobbes.png"),
-    HUME("흄", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/hume.png"),
-    JEONG_YAKYONG("정약용", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/jeong_yakyong.png"),
-    JUNG("융", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/jung.png"),
-    LEIBNIZ("라이프니츠", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/leibniz.png"),
-    MENCIUS("맹자", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/mencius.png"),
-    MILL("존 스튜어트 밀", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/mill.png"),
-    RAWLS("롤스", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/rawls.png"),
-    SCHOPENHAUER("쇼펜하우어", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/schopenhauer.png"),
-    XUNZI("순자", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/xunzi.png"),
-    YI_HWANG("이황", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/yi_hwang.png"),
-    YI_I("이이", null, null, null, null, 0, 0, 0, 0, 0, 0, "images/philosophers/yi_i.png");
+            "images/philosophers/buddha.png");
 
     private final String label;
     private final String typeName;
@@ -111,16 +93,6 @@ public enum PhilosopherType {
         this.imageKey = imageKey;
     }
 
-    PhilosopherType(String label, String typeName, String description,
-                    String bestMatchName, String worstMatchName,
-                    int principle, int reason, int individual,
-                    int change, int inner, int ideal,
-                    String imageKey) {
-        this(label, typeName, description, List.of(),
-                bestMatchName, worstMatchName,
-                principle, reason, individual, change, inner, ideal, imageKey);
-    }
-
     public PhilosopherType getBestMatch() {
         return bestMatchName != null ? valueOf(bestMatchName) : null;
     }

src/main/java/com/swyp/picke/domain/user/enums/ValueAxis.java

@@ -0,0 +1,34 @@
+package com.swyp.picke.domain.user.enums;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+public enum ValueAxis {
+    PRINCIPLE("원칙", "결과"),
+    REASON("이성", "감성"),
+    INDIVIDUAL("개인", "관계"),
+    CHANGE("변화", "전통"),
+    INNER("내면", "구조"),
+    IDEAL("이상", "현실");
+
+    private final String positiveTag;
+    private final String negativeTag;
+
+    ValueAxis(String positiveTag, String negativeTag) {
+        this.positiveTag = positiveTag;
+        this.negativeTag = negativeTag;
+    }
+
+    public static Optional<ValueDirection> resolve(String tagName) {
+        return Arrays.stream(values())
+                .filter(axis -> axis.positiveTag.equals(tagName) || axis.negativeTag.equals(tagName))
+                .findFirst()
+                .map(axis -> new ValueDirection(
+                        axis,
+                        axis.positiveTag.equals(tagName) ? 1 : -1
+                ));
+    }
+
+    public record ValueDirection(ValueAxis axis, int direction) {
+    }
+}

src/main/java/com/swyp/picke/domain/vote/service/BattleVoteServiceImpl.java

@@ -3,12 +3,16 @@
 import com.swyp.picke.domain.battle.entity.Battle;
 import com.swyp.picke.domain.battle.entity.BattleOption;
 import com.swyp.picke.domain.battle.repository.BattleOptionRepository;
+import com.swyp.picke.domain.battle.repository.BattleOptionTagRepository;
 import com.swyp.picke.domain.battle.service.BattleService;
+import com.swyp.picke.domain.tag.enums.TagType;
 import com.swyp.picke.domain.user.dto.response.UserBattleStatusResponse;
 import com.swyp.picke.domain.user.entity.User;
+import com.swyp.picke.domain.user.entity.UserTendencyScore;
 import com.swyp.picke.domain.user.enums.CreditType;
 import com.swyp.picke.domain.user.enums.UserBattleStep;
 import com.swyp.picke.domain.user.repository.UserRepository;
+import com.swyp.picke.domain.user.repository.UserTendencyScoreRepository;
 import com.swyp.picke.domain.user.service.CreditService;
 import com.swyp.picke.domain.user.service.UserBattleService;
 import com.swyp.picke.domain.vote.converter.VoteConverter;
@@ -43,7 +47,9 @@ public class BattleVoteServiceImpl implements BattleVoteService {
     private final BattleVoteRepository battleVoteRepository;
     private final BattleService battleService;
     private final BattleOptionRepository battleOptionRepository;
+    private final BattleOptionTagRepository battleOptionTagRepository;
     private final UserRepository userRepository;
+    private final UserTendencyScoreRepository userTendencyScoreRepository;
     private final UserBattleService userBattleService;
     private final CreditService creditService;
     private final ApplicationEventPublisher eventPublisher;
@@ -165,13 +171,27 @@ public VoteResultResponse postVote(Long battleId, Long userId, VoteRequest reque
             throw new CustomException(ErrorCode.PRE_VOTE_REQUIRED);
         }
 
+        BattleOption previousOption = vote.getPostVoteOption();
         vote.doPostVote(option);
+        userTendencyScoreRepository.findByUserId(userId).ifPresent(score -> {
+            if (previousOption != null) {
+                applyValueTags(score, previousOption, -1);
+            }
+            applyValueTags(score, option, 1);
+        });
         userBattleService.upsertStep(user, battle, UserBattleStep.COMPLETED);
         eventPublisher.publishEvent(new VoteUpdatedEvent(battleId));
 
         return new VoteResultResponse(vote.getId(), UserBattleStep.COMPLETED);
     }
 
+    private void applyValueTags(UserTendencyScore score, BattleOption option, int multiplier) {
+        battleOptionTagRepository.findByBattleOption(option).stream()
+                .map(optionTag -> optionTag.getTag())
+                .filter(tag -> tag.getType() == TagType.VALUE)
+                .forEach(tag -> score.applyValueTag(tag.getName(), multiplier));
+    }
+
     @Override
     @Transactional
     public void deleteVotesByBattleId(Long battleId) {

src/test/java/com/swyp/picke/domain/battle/service/BattleQueryServiceTest.java

@@ -0,0 +1,54 @@
+package com.swyp.picke.domain.battle.service;
+
+import com.swyp.picke.domain.battle.entity.BattleOptionTag;
+import com.swyp.picke.domain.battle.repository.BattleOptionRepository;
+import com.swyp.picke.domain.battle.repository.BattleOptionTagRepository;
+import com.swyp.picke.domain.battle.repository.BattleRepository;
+import com.swyp.picke.domain.battle.repository.BattleTagRepository;
+import com.swyp.picke.domain.tag.entity.Tag;
+import com.swyp.picke.domain.tag.enums.TagType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class BattleQueryServiceTest {
+
+    @Mock
+    private BattleRepository battleRepository;
+    @Mock
+    private BattleOptionRepository battleOptionRepository;
+    @Mock
+    private BattleTagRepository battleTagRepository;
+    @Mock
+    private BattleOptionTagRepository battleOptionTagRepository;
+
+    @InjectMocks
+    private BattleQueryService battleQueryService;
+
+    @Test
+    @DisplayName("철학자 유형 집계에서 제거된 철학자 태그를 처리하지 않는다")
+    void getTopPhilosopher_ignoresUnsupportedTags() {
+        BattleOptionTag supported = optionTag("플라톤");
+        BattleOptionTag removed = optionTag("데카르트");
+        when(battleOptionTagRepository.findByBattleOptionIdIn(List.of(1L)))
+                .thenReturn(List.of(removed, removed, supported));
+
+        assertThat(battleQueryService.getTopPhilosopherTagNameFromOptions(List.of(1L)))
+                .contains("플라톤");
+    }
+
+    private BattleOptionTag optionTag(String name) {
+        return BattleOptionTag.builder()
+                .tag(Tag.builder().name(name).type(TagType.PHILOSOPHER).build())
+                .build();
+    }
+}

src/test/java/com/swyp/picke/domain/tag/service/TagServiceImplTest.java

@@ -0,0 +1,65 @@
+package com.swyp.picke.domain.tag.service;
+
+import com.swyp.picke.domain.admin.dto.tag.request.TagRequest;
+import com.swyp.picke.domain.battle.repository.BattleOptionTagRepository;
+import com.swyp.picke.domain.battle.repository.BattleRepository;
+import com.swyp.picke.domain.battle.repository.BattleTagRepository;
+import com.swyp.picke.domain.tag.dto.response.TagListResponse;
+import com.swyp.picke.domain.tag.entity.Tag;
+import com.swyp.picke.domain.tag.enums.TagType;
+import com.swyp.picke.domain.tag.repository.TagRepository;
+import com.swyp.picke.global.common.exception.CustomException;
+import com.swyp.picke.global.common.exception.ErrorCode;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class TagServiceImplTest {
+
+    @Mock
+    private TagRepository tagRepository;
+    @Mock
+    private BattleTagRepository battleTagRepository;
+    @Mock
+    private BattleOptionTagRepository battleOptionTagRepository;
+    @Mock
+    private BattleRepository battleRepository;
+
+    @InjectMocks
+    private TagServiceImpl tagService;
+
+    @Test
+    @DisplayName("철학자 태그 목록에서 지원하지 않는 철학자를 제외한다")
+    void getTags_filtersUnsupportedPhilosophers() {
+        Tag supported = Tag.builder().name("소크라테스").type(TagType.PHILOSOPHER).build();
+        Tag removed = Tag.builder().name("데카르트").type(TagType.PHILOSOPHER).build();
+        when(tagRepository.findAllByTypeAndDeletedAtIsNull(TagType.PHILOSOPHER))
+                .thenReturn(List.of(supported, removed));
+
+        TagListResponse response = tagService.getTags(TagType.PHILOSOPHER);
+
+        assertThat(response.items()).extracting("name").containsExactly("소크라테스");
+        assertThat(response.totalCount()).isEqualTo(1);
+    }
+
+    @Test
+    @DisplayName("지원하지 않는 철학자 태그는 생성할 수 없다")
+    void createTag_rejectsUnsupportedPhilosopher() {
+        TagRequest request = new TagRequest("데카르트", TagType.PHILOSOPHER);
+
+        assertThatThrownBy(() -> tagService.createTag(request))
+                .isInstanceOf(CustomException.class)
+                .extracting("errorCode")
+                .isEqualTo(ErrorCode.BAD_REQUEST);
+    }
+}