[FEAT] #709: 솝탬프 파트별 랭킹 파트원 수 고려해서 계산하도록 수정

src/main/java/org/sopt/app/application/rank/AuthPartMemberCountReader.java

@@ -0,0 +1,40 @@
+package org.sopt.app.application.rank;
+
+import java.util.EnumMap;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.sopt.app.domain.enums.SoptPart;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class AuthPartMemberCountReader {
+
+    private final JdbcTemplate jdbcTemplate;
+
+    public Map<SoptPart, Long> getCurrentGenerationPartMemberCounts(Long generation) {
+        String sql = """
+            SELECT part, COUNT(*) AS member_count
+            FROM auth_prod.user_activity_histories
+            WHERE generation = ?
+              AND is_sopt = true
+              AND role = 'MEMBER'
+              AND part IN ('IOS', 'ANDROID', 'DESIGN', 'PLAN', 'SERVER', 'WEB')
+            GROUP BY part
+            """;
+
+        return jdbcTemplate.query(sql, rs -> {
+            Map<SoptPart, Long> result = new EnumMap<>(SoptPart.class);
+
+            while (rs.next()) {
+                result.put(
+                    SoptPart.valueOf(rs.getString("part")),
+                    rs.getLong("member_count")
+                );
+            }
+
+            return result;
+        }, generation);
+    }
+}

src/main/java/org/sopt/app/application/rank/SoptampPartRankCalculator.java

@@ -1,32 +1,92 @@
 package org.sopt.app.application.rank;
 
+import static java.util.Map.Entry.comparingByValue;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Comparator;
+import java.util.EnumMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
 import org.sopt.app.application.soptamp.SoptampPointInfo.PartRank;
 import org.sopt.app.application.soptamp.SoptampUserInfo;
 import org.sopt.app.domain.enums.Part;
-
+import org.sopt.app.domain.enums.SoptPart;
 
 @RequiredArgsConstructor(access = AccessLevel.PUBLIC)
 public class SoptampPartRankCalculator {
 
-    private final List<SoptampUserInfo> userInfos;
+    private static final int POINT_SCALE = 2;
+    private static final RoundingMode POINT_ROUNDING_MODE = RoundingMode.HALF_UP;
+    private static final BigDecimal ZERO_POINT = BigDecimal.ZERO.setScale(POINT_SCALE, POINT_ROUNDING_MODE);
 
-    private final PartScores partScores = new PartScores();
+    private final List<SoptampUserInfo> userInfos;
+    private final Map<SoptPart, Long> partMemberCounts;
 
     public List<PartRank> calculatePartRank() {
-        userInfos.forEach(this::calculatePartScore);
-        return Part.getPartsByReturnOrder().stream().map(part -> PartRank.builder()
+        PartScores partScores = new PartScores();
+        userInfos.forEach(userInfo -> addPartScore(userInfo, partScores));
+
+        Map<Part, BigDecimal> averagePoints = calculateAveragePoints(partScores);
+        Map<Part, Integer> ranks = calculateRanks(averagePoints);
+
+        return Part.getPartsByReturnOrder().stream()
+            .map(part -> PartRank.builder()
                 .part(part.getPartName())
-                .rank(partScores.getRank(part))
-                .points(partScores.getPoints(part))
-                .build()).toList();
+                .rank(ranks.get(part))
+                .points(averagePoints.get(part))
+                .build())
+            .toList();
+    }
+
+    private void addPartScore(SoptampUserInfo userInfo, PartScores partScores) {
+        Part part = SoptPart.toPart(userInfo.getPart());
+        if (part == null) {
+            return;
+        }
+        partScores.addPartScore(part, userInfo.getTotalPoints());
     }
 
-    private void calculatePartScore(SoptampUserInfo userInfo) {
-        Part.getAllParts().stream()
-                .filter(part -> userInfo.getNickname().startsWith(part.getPartName()))
-                .forEach(part -> partScores.addPartScore(part, userInfo.getTotalPoints()));
+    private Map<Part, BigDecimal> calculateAveragePoints(PartScores partScores) {
+        Map<Part, BigDecimal> averagePoints = new EnumMap<>(Part.class);
+
+        for (Part part : Part.getPartsByReturnOrder()) {
+            long totalScore = partScores.getPoints(part);
+            long memberCount = partMemberCounts.getOrDefault(SoptPart.valueOf(part.name()), 0L);
+
+            BigDecimal averagePoint = memberCount == 0 ? ZERO_POINT
+                : BigDecimal.valueOf(totalScore)
+                    .divide(BigDecimal.valueOf(memberCount), POINT_SCALE, POINT_ROUNDING_MODE);
+
+            averagePoints.put(part, averagePoint);
+        }
+
+        return averagePoints;
+    }
+
+    private Map<Part, Integer> calculateRanks(Map<Part, BigDecimal> averagePoints) {
+        List<Entry<Part, BigDecimal>> sortedParts = averagePoints.entrySet().stream()
+            .sorted(comparingByValue(Comparator.reverseOrder()))
+            .toList();
+
+        Map<Part, Integer> ranks = new EnumMap<>(Part.class);
+        BigDecimal previousPoint = null;
+        int currentRank = 0;
+
+        for (int i = 0; i < sortedParts.size(); i++) {
+            Entry<Part, BigDecimal> entry = sortedParts.get(i);
+
+            if (previousPoint == null || entry.getValue().compareTo(previousPoint) != 0) {
+                currentRank = i + 1;
+                previousPoint = entry.getValue();
+            }
+
+            ranks.put(entry.getKey(), currentRank);
+        }
+
+        return ranks;
     }
 }

src/main/java/org/sopt/app/application/soptamp/SoptampPointInfo.java

@@ -1,5 +1,6 @@
 package org.sopt.app.application.soptamp;
 
+import java.math.BigDecimal;
 import lombok.*;
 
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
@@ -31,6 +32,6 @@ public static Main of(Integer rank, SoptampUserInfo soptampUserInfo) {
     public static class PartRank {
         private String part;
         private Integer rank;
-        private Long points;
+        private BigDecimal points;
     }
 }

src/main/java/org/sopt/app/application/soptamp/SoptampUserFinder.java

@@ -4,6 +4,7 @@
 
 import java.util.List;
 import java.util.Map;
+import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.sopt.app.common.exception.BadRequestException;
 import org.sopt.app.common.response.ErrorCode;
@@ -20,6 +21,7 @@ public class SoptampUserFinder {
 
     private final SoptampUserRepository soptampUserRepository;
 
+    @Getter
     @Value("${sopt.current.generation}")
     private Long currentGeneration;
 

src/main/java/org/sopt/app/facade/RankFacade.java

@@ -9,6 +9,7 @@
 import org.sopt.app.common.exception.BadRequestException;
 import org.sopt.app.common.response.ErrorCode;
 import org.sopt.app.domain.enums.Part;
+import org.sopt.app.domain.enums.SoptPart;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
 import org.springframework.stereotype.Service;
@@ -20,6 +21,7 @@ public class RankFacade {
 
     private final SoptampUserFinder soptampUserFinder;
     private final RankCacheService rankCacheService;
+    private final AuthPartMemberCountReader authPartMemberCountReader;
 
     @Value("${makers.app.soptamp.appjam-mode:false}")
     private boolean appjamMode;
@@ -102,7 +104,8 @@ public List<PartRank> findAllPartRanks() {
             throw new BadRequestException(ErrorCode.INVALID_APPJAM_SEASON_REQUEST);
         }
         List<SoptampUserInfo> soptampUserInfos = soptampUserFinder.findAllOfCurrentGeneration();
-        SoptampPartRankCalculator soptampPartRankCalculator = new SoptampPartRankCalculator(soptampUserInfos);
+        Map<SoptPart, Long> partMemberCounts = authPartMemberCountReader.getCurrentGenerationPartMemberCounts(soptampUserFinder.getCurrentGeneration());
+        SoptampPartRankCalculator soptampPartRankCalculator = new SoptampPartRankCalculator(soptampUserInfos, partMemberCounts);
         return soptampPartRankCalculator.calculatePartRank();
     }
 
@@ -112,10 +115,12 @@ public PartRank findPartRank(Part part) {
             throw new BadRequestException(ErrorCode.INVALID_APPJAM_SEASON_REQUEST);
         }
         List<SoptampUserInfo> soptampUserInfos = soptampUserFinder.findAllOfCurrentGeneration();
-        SoptampPartRankCalculator soptampPartRankCalculator = new SoptampPartRankCalculator(soptampUserInfos);
+        Map<SoptPart, Long> partMemberCounts = authPartMemberCountReader.getCurrentGenerationPartMemberCounts(soptampUserFinder.getCurrentGeneration());
+        SoptampPartRankCalculator soptampPartRankCalculator = new SoptampPartRankCalculator(soptampUserInfos, partMemberCounts);
         return soptampPartRankCalculator.calculatePartRank().stream()
-                .filter(partRank -> partRank.getPart().equals(part.getPartName()))
-                .findFirst().orElseThrow();
+            .filter(partRank -> partRank.getPart().equals(part.getPartName()))
+            .findFirst()
+            .orElseThrow();
     }
 
     @Transactional(readOnly = true)

src/test/java/org/sopt/app/common/fixtures/SoptampUserFixture.java

@@ -154,4 +154,12 @@ public static PlatformUserInfoResponse getPlatformUserInfoResponse(
          );
      }
 
+     public static final Map<SoptPart, Long> PART_MEMBER_COUNT_MAP = Map.of(
+         SoptPart.PLAN, 10L,
+         SoptPart.DESIGN, 10L,
+         SoptPart.WEB, 10L,
+         SoptPart.IOS, 10L,
+         SoptPart.ANDROID, 10L,
+         SoptPart.SERVER, 30L
+     );
  }