[Feat/186] 매칭 우선순위 API 구현

src/main/java/com/gamegoo/gamegoo_v2/account/member/domain/Member.java

@@ -104,7 +104,6 @@ public class Member extends BaseDateTimeEntity {
     @OneToMany(mappedBy = "member", cascade = CascadeType.ALL)
     private List<MemberGameStyle> memberGameStyleList = new ArrayList<>();
 
-    // 회원가입용 create
     public static Member create(String email, String password, LoginType loginType, String gameName, String tag,
                                 Tier tier, int gameRank, double winRate, int gameCount, boolean isAgree) {
         int randomProfileImage = ThreadLocalRandom.current().nextInt(1, 9);
@@ -124,7 +123,6 @@ public static Member create(String email, String password, LoginType loginType,
                 .build();
     }
 
-    // 회원가입용 Builder
     @Builder
     private Member(String email, String password, int profileImage, LoginType loginType, String gameName,
                    String tag, Tier tier, int gameRank, double winRate, int gameCount, boolean isAgree) {

src/main/java/com/gamegoo/gamegoo_v2/matching/domain/MatchingRecord.java

@@ -13,10 +13,8 @@
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
-import jakarta.persistence.Index;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
-import jakarta.persistence.Table;
 import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.Getter;
@@ -25,13 +23,6 @@
 @Entity
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
-@Table(
-        indexes = {
-                @Index(name = "idx_matching_record_created_at_status_game_mode", columnList = "createdAt, status, " +
-                        "gameMode"),
-                @Index(name = "idx_matching_record_member_id", columnList = "member_id")
-        }
-)
 public class MatchingRecord extends BaseDateTimeEntity {
 
     @Id

src/main/java/com/gamegoo/gamegoo_v2/matching/dto/PriorityValue.java

@@ -2,14 +2,18 @@
 
 import lombok.Builder;
 import lombok.Getter;
+import lombok.ToString;
+
+import java.util.Objects;
 
 @Getter
 @Builder
+@ToString
 public class PriorityValue {
 
-    Long memberId;
-    String matchingUuid;
-    int priorityValue;
+    private final Long memberId;
+    private final String matchingUuid;
+    private final int priorityValue;
 
     public static PriorityValue of(Long memberId, String matchingUuid, int priorityValue) {
         return PriorityValue.builder()
@@ -19,4 +23,23 @@ public static PriorityValue of(Long memberId, String matchingUuid, int priorityV
                 .build();
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        PriorityValue that = (PriorityValue) o;
+        return priorityValue == that.priorityValue &&
+                Objects.equals(memberId, that.memberId) &&
+                Objects.equals(matchingUuid, that.matchingUuid);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(memberId, matchingUuid, priorityValue);
+    }
+
 }

src/main/java/com/gamegoo/gamegoo_v2/matching/dto/response/MatchingMemberInfoResponse.java

@@ -7,12 +7,14 @@
 import com.gamegoo.gamegoo_v2.game.dto.response.GameStyleResponse;
 import com.gamegoo.gamegoo_v2.matching.domain.GameMode;
 import lombok.Builder;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 
 import java.util.List;
 
 @Getter
 @Builder
+@EqualsAndHashCode
 public class MatchingMemberInfoResponse {
 
     Long memberId;

src/main/java/com/gamegoo/gamegoo_v2/matching/dto/response/PriorityListResponse.java

@@ -3,12 +3,14 @@
 import com.gamegoo.gamegoo_v2.account.member.domain.Member;
 import com.gamegoo.gamegoo_v2.matching.dto.PriorityValue;
 import lombok.Builder;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 
 import java.util.List;
 
 @Getter
 @Builder
+@EqualsAndHashCode
 public class PriorityListResponse {
 
     List<PriorityValue> myPriorityList;

src/main/java/com/gamegoo/gamegoo_v2/matching/repository/MatchingRecordRepository.java

@@ -2,28 +2,19 @@
 
 import com.gamegoo.gamegoo_v2.matching.domain.GameMode;
 import com.gamegoo.gamegoo_v2.matching.domain.MatchingRecord;
-import com.gamegoo.gamegoo_v2.matching.domain.MatchingStatus;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
 import java.time.LocalDateTime;
 import java.util.List;
 
-public interface MatchingRecordRepository extends JpaRepository<MatchingRecord, String> {
+public interface MatchingRecordRepository extends JpaRepository<MatchingRecord, String>,
+        MatchingRecordRepositoryCustom {
 
-    @Query(value = """
-                SELECT m
-                FROM MatchingRecord m
-                WHERE m.createdAt > :createdAt
-                  AND m.status = :status
-                  AND m.gameMode = :gameMode
-                GROUP BY m.member.id
-            """)
-    List<MatchingRecord> findMatchingRecordsWithGroupBy(
-            @Param("createdAt") LocalDateTime createdAt,
-            @Param("status") MatchingStatus status,
-            @Param("gameMode") GameMode gameMode
-    );
+    /**
+     * 5분 이내, 특정 게임 모드, PENDING 상태의 매칭 레코드 조회
+     */
+    default List<MatchingRecord> findRecentValidMatchingRecords(GameMode gameMode) {
+        return findValidMatchingRecords(LocalDateTime.now().minusMinutes(5), gameMode);
+    }
 
 }

src/main/java/com/gamegoo/gamegoo_v2/matching/repository/MatchingRecordRepositoryCustom.java

@@ -0,0 +1,29 @@
+package com.gamegoo.gamegoo_v2.matching.repository;
+
+import com.gamegoo.gamegoo_v2.account.member.domain.Member;
+import com.gamegoo.gamegoo_v2.matching.domain.GameMode;
+import com.gamegoo.gamegoo_v2.matching.domain.MatchingRecord;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public interface MatchingRecordRepositoryCustom {
+
+    /**
+     * 매칭 가능한 유효한 레코드 조회 (5분 이내, 특정 게임 모드, PENDING 상태)
+     *
+     * @param createdAt 5분 전 시간 기준
+     * @param gameMode  게임 모드
+     * @return 매칭 가능한 레코드 리스트
+     */
+    List<MatchingRecord> findValidMatchingRecords(LocalDateTime createdAt, GameMode gameMode);
+
+    /**
+     * 가장 최근 기록 불러오기
+     *
+     * @param member 사용자
+     * @return 사용자의 가장 최근 매칭 기록
+     */
+    MatchingRecord findLatestByMember(Member member);
+
+}

src/main/java/com/gamegoo/gamegoo_v2/matching/repository/MatchingRecordRepositoryCustomImpl.java

@@ -0,0 +1,143 @@
+package com.gamegoo.gamegoo_v2.matching.repository;
+
+import com.gamegoo.gamegoo_v2.account.member.domain.Member;
+import com.gamegoo.gamegoo_v2.matching.domain.GameMode;
+import com.gamegoo.gamegoo_v2.account.member.domain.Position;
+import com.gamegoo.gamegoo_v2.matching.domain.MatchingRecord;
+import com.gamegoo.gamegoo_v2.matching.domain.MatchingStatus;
+import com.gamegoo.gamegoo_v2.account.member.domain.Tier;
+import com.gamegoo.gamegoo_v2.matching.domain.QMatchingRecord;
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.core.types.dsl.EnumPath;
+import com.querydsl.core.types.dsl.Expressions;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import com.querydsl.jpa.JPAExpressions;
+import lombok.RequiredArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static com.gamegoo.gamegoo_v2.matching.domain.QMatchingRecord.matchingRecord;
+
+@RequiredArgsConstructor
+public class MatchingRecordRepositoryCustomImpl implements MatchingRecordRepositoryCustom {
+
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public List<MatchingRecord> findValidMatchingRecords(LocalDateTime createdAt, GameMode gameMode) {
+        return queryFactory.selectFrom(matchingRecord)
+                .where(
+                        matchingRecord.createdAt.gt(createdAt),    // 5분 이내
+                        matchingRecord.status.eq(MatchingStatus.PENDING),  // 상태 PENDING
+                        matchingRecord.gameMode.eq(gameMode),   // 특정 게임 모드
+                        existsValidMatchSubquery(),  // 유효한 매칭만 가져오기
+                        applyGameModeFilter(gameMode) // 게임모드별 추가 필터 적용 (SOLO, FREE)
+                )
+                .orderBy(matchingRecord.member.id.asc(), matchingRecord.createdAt.desc()) // 최신순 정렬
+                .fetch();
+    }
+
+    @Override
+    public MatchingRecord findLatestByMember(Member member) {
+        QMatchingRecord matchingRecord = QMatchingRecord.matchingRecord;
+
+        return queryFactory
+                .selectFrom(matchingRecord)
+                .where(matchingRecord.member.eq(member))
+                .orderBy(matchingRecord.createdAt.desc())
+                .limit(1)
+                .fetchOne();
+    }
+
+    /**
+     * 게임 모드에 따른 추가 필터 적용
+     */
+    private BooleanExpression applyGameModeFilter(GameMode gameMode) {
+        return switch (gameMode) {
+            case SOLO -> validateSoloRankFilter(); // 개인 랭크 티어 검증
+            case FREE -> validateFreeRankFilter(); // 자유 랭크 티어 검증
+            default -> Expressions.TRUE; // 다른 게임 모드는 필터 없음
+        };
+    }
+
+    /**
+     * SOLO 모드 - 개인 랭크 제한 검증 (validateSoloRankRange 적용)
+     */
+    private BooleanExpression validateSoloRankFilter() {
+        return validateSoloRankRange(matchingRecord.soloTier);
+    }
+
+    /**
+     * FREE 모드 - 자유 랭크 제한 검증
+     */
+    private BooleanExpression validateFreeRankFilter() {
+        return matchingRecord.freeTier.in(Tier.IRON, Tier.BRONZE, Tier.SILVER, Tier.GOLD)
+                .and(matchingRecord.freeTier.notIn(Tier.EMERALD, Tier.DIAMOND, Tier.MASTER, Tier.GRANDMASTER,
+                        Tier.CHALLENGER));
+    }
+
+
+    /**
+     * 매칭 유효성 검사 서브쿼리
+     */
+    private BooleanExpression existsValidMatchSubquery() {
+        QMatchingRecord otherRecord = new QMatchingRecord("otherRecord");
+
+        return JPAExpressions.selectOne()
+                .from(otherRecord)
+                .where(
+                        otherRecord.member.id.ne(matchingRecord.member.id), // 다른 멤버와의 매칭
+                        isValidMatchingPosition(matchingRecord, otherRecord) // 포지션 조건 체크
+                )
+                .exists();
+    }
+
+    /**
+     * 매칭 가능한 포지션 조건 ]
+     */
+    private BooleanExpression isValidMatchingPosition(QMatchingRecord myRecord, QMatchingRecord otherRecord) {
+        BooleanExpression condition1 = myRecord.mainPosition.ne(Position.ANY)
+                .and(otherRecord.subPosition.ne(Position.ANY))
+                .and(myRecord.mainPosition.eq(otherRecord.subPosition)
+                        .or(otherRecord.mainPosition.eq(myRecord.subPosition)))
+                .and(myRecord.wantPosition.eq(otherRecord.subPosition));
+
+        BooleanExpression condition2 = myRecord.subPosition.ne(Position.ANY)
+                .and(otherRecord.wantPosition.ne(Position.ANY))
+                .and(otherRecord.wantPosition.eq(myRecord.subPosition))
+                .and(otherRecord.mainPosition.eq(myRecord.subPosition)
+                        .or(myRecord.mainPosition.eq(otherRecord.subPosition)));
+
+        BooleanExpression condition3 = myRecord.mainPosition.ne(Position.ANY)
+                .and(myRecord.subPosition.ne(Position.ANY))
+                .and(otherRecord.mainPosition.ne(Position.ANY))
+                .and(otherRecord.subPosition.ne(Position.ANY))
+                .and(myRecord.mainPosition.eq(otherRecord.mainPosition)
+                        .or(myRecord.mainPosition.eq(otherRecord.subPosition)))
+                .and(myRecord.subPosition.eq(otherRecord.mainPosition)
+                        .or(myRecord.subPosition.eq(otherRecord.subPosition)))
+                .not();
+
+        return condition1.or(condition2).or(condition3);
+    }
+
+
+    /**
+     * 개인 랭크 제한 검증 (SOLO 모드 전용) - QueryDSL에서 적용 가능하도록 수정
+     */
+    private BooleanExpression validateSoloRankRange(EnumPath<Tier> tierPath) {
+        return tierPath.eq(Tier.IRON).or(tierPath.eq(Tier.BRONZE)).and(matchingRecord.soloTier.in(Tier.IRON,
+                        Tier.BRONZE, Tier.SILVER))
+                .or(tierPath.eq(Tier.SILVER).and(matchingRecord.soloTier.in(Tier.IRON, Tier.BRONZE, Tier.SILVER,
+                        Tier.GOLD)))
+                .or(tierPath.eq(Tier.GOLD).and(matchingRecord.soloTier.in(Tier.SILVER, Tier.GOLD, Tier.PLATINUM)))
+                .or(tierPath.eq(Tier.PLATINUM).and(matchingRecord.soloTier.in(Tier.GOLD, Tier.PLATINUM, Tier.EMERALD)))
+                .or(tierPath.eq(Tier.EMERALD).and(matchingRecord.soloTier.in(Tier.PLATINUM, Tier.EMERALD,
+                        Tier.DIAMOND)))
+                .or(tierPath.eq(Tier.DIAMOND).and(matchingRecord.soloTier.in(Tier.EMERALD, Tier.DIAMOND)))
+                .or(Expressions.FALSE); // 마스터 이상 필터 적용 안 함
+    }
+
+
+}

src/main/java/com/gamegoo/gamegoo_v2/matching/service/MatchingFacadeService.java

@@ -38,7 +38,11 @@ public class MatchingFacadeService {
     private final MemberGameStyleService memberGameStyleService;
 
     /**
-     * 매칭 우선순위 계산 및 기록 저장 API
+     * 매칭 우선순위 계산 및 DB 저장
+     *
+     * @param memberId 회원 ID
+     * @param request  회원 정보
+     * @return 매칭 정보
      */
     @Transactional
     public PriorityListResponse calculatePriorityAndRecording(Long memberId, InitializingMatchingRequest request) {