[Feat] #660 앱잼팀 랭킹 API 구현

src/main/java/org/sopt/app/application/appjamrank/AppjamRankCalculator.java

@@ -0,0 +1,150 @@
+package org.sopt.app.application.appjamrank;
+
+import java.time.LocalDateTime;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.sopt.app.application.playground.dto.PlaygroundProfileInfo;
+import org.sopt.app.common.exception.BadRequestException;
+import org.sopt.app.common.response.ErrorCode;
+import org.sopt.app.domain.entity.AppjamUser;
+import org.sopt.app.domain.entity.soptamp.Stamp;
+import org.sopt.app.domain.enums.TeamNumber;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(access = AccessLevel.PUBLIC)
+public class AppjamRankCalculator {
+
+	private static final int TODAY_TEAM_RANK_LIMIT = 10;
+
+	private final List<Stamp> latestStamps;
+	private final Map<Long, AppjamUser> uploaderAppjamUserByUserId;
+	private final Map<Long, PlaygroundProfileInfo.PlaygroundProfile> playgroundProfileByUserId;
+
+	public List<AppjamRankInfo.TeamRank> calculateRecentTeamRanks() {
+		return latestStamps.stream()
+			.map(stamp -> {
+				AppjamUser uploaderAppjamUser = Optional.ofNullable(uploaderAppjamUserByUserId.get(stamp.getUserId()))
+					.orElseThrow(() -> new BadRequestException(ErrorCode.USER_NOT_FOUND));
+
+				PlaygroundProfileInfo.PlaygroundProfile playgroundProfile =
+					Optional.ofNullable(playgroundProfileByUserId.get(stamp.getUserId()))
+						.orElseThrow(() -> new BadRequestException(ErrorCode.USER_NOT_FOUND));
+
+				TeamNumber teamNumber = uploaderAppjamUser.getTeamNumber();
+
+				String firstImageUrl = Optional.ofNullable(stamp.getImages())
+					.filter(images -> !images.isEmpty())
+					.map(List::getFirst)
+					.orElse("");
+
+				return AppjamRankInfo.TeamRank.of(
+					stamp,
+					firstImageUrl,
+					uploaderAppjamUser,
+					teamNumber,
+					playgroundProfile
+				);
+			})
+			.toList();
+	}
+
+	public AppjamRankInfo.TodayTeamRankList calculateTodayTeamRanksTop10(
+		List<AppjamRankInfo.TodayRank> todayUserRanks,
+		Map<Long, Long> totalPointsByUserId,
+		List<AppjamUser> allAppjamUsers
+	) {
+		Map<Long, AppjamRankInfo.TodayRank> todayRankByUserId = todayUserRanks.stream()
+			.collect(Collectors.toMap(
+				AppjamRankInfo.TodayRank::getUserId,
+				Function.identity(),
+				(existing, replacement) -> existing
+			));
+
+		Map<TeamNumber, String> teamNameByTeamNumber = allAppjamUsers.stream()
+			.collect(Collectors.toMap(
+				AppjamUser::getTeamNumber,
+				AppjamUser::getTeamName,
+				(existing, replacement) -> existing
+			));
+
+		Map<TeamNumber, List<AppjamUser>> membersByTeamNumber = allAppjamUsers.stream()
+			.collect(Collectors.groupingBy(
+				AppjamUser::getTeamNumber
+			));
+
+		List<TeamAggregate> teamAggregates = membersByTeamNumber.entrySet().stream()
+			.map(entry -> aggregateTeam(
+				entry.getKey(),
+				entry.getValue(),
+				teamNameByTeamNumber.getOrDefault(entry.getKey(), ""),
+				todayRankByUserId,
+				totalPointsByUserId
+			))
+			.sorted(Comparator
+				.comparingLong(TeamAggregate::todayPoints).reversed()
+				.thenComparing(TeamAggregate::firstCertifiedAtToday, Comparator.nullsLast(Comparator.naturalOrder()))
+				.thenComparing(TeamAggregate::teamNumber)
+			)
+			.limit(TODAY_TEAM_RANK_LIMIT)
+			.toList();
+
+		AtomicInteger rankCounter = new AtomicInteger(1);
+		List<AppjamRankInfo.TodayTeamRank> ranks = teamAggregates.stream()
+			.map(teamAggregate -> AppjamRankInfo.TodayTeamRank.of(
+				rankCounter.getAndIncrement(),
+				teamAggregate.teamNumber(),
+				teamAggregate.teamName(),
+				teamAggregate.todayPoints(),
+				teamAggregate.totalPoints()
+			))
+			.toList();
+
+		return AppjamRankInfo.TodayTeamRankList.of(ranks);
+	}
+
+	private TeamAggregate aggregateTeam(
+		TeamNumber teamNumber,
+		List<AppjamUser> teamMembers,
+		String teamName,
+		Map<Long, AppjamRankInfo.TodayRank> todayRankByUserId,
+		Map<Long, Long> totalPointsByUserId
+	) {
+		long todayPointsSum = 0L;
+		long totalPointsSum = 0L;
+		LocalDateTime firstCertifiedAtToday = null;
+
+		for (AppjamUser teamMember : teamMembers) {
+			Long userId = teamMember.getUserId();
+
+			AppjamRankInfo.TodayRank todayRank = todayRankByUserId.get(userId);
+			if (todayRank != null) {
+				todayPointsSum += todayRank.getTodayPoints();
+
+				LocalDateTime certifiedAt = todayRank.getFirstCertifiedAtToday();
+				if (certifiedAt != null && (firstCertifiedAtToday == null || certifiedAt.isBefore(firstCertifiedAtToday))) {
+					firstCertifiedAtToday = certifiedAt;
+				}
+			}
+
+			totalPointsSum += totalPointsByUserId.getOrDefault(userId, 0L);
+		}
+
+		return new TeamAggregate(teamNumber, teamName, todayPointsSum, totalPointsSum, firstCertifiedAtToday);
+	}
+
+	private record TeamAggregate(
+		TeamNumber teamNumber,
+		String teamName,
+		long todayPoints,
+		long totalPoints,
+		LocalDateTime firstCertifiedAtToday
+	) {}
+}

src/main/java/org/sopt/app/application/appjamrank/AppjamRankInfo.java

@@ -0,0 +1,147 @@
+package org.sopt.app.application.appjamrank;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.sopt.app.application.playground.dto.PlaygroundProfileInfo;
+import org.sopt.app.domain.entity.AppjamUser;
+import org.sopt.app.domain.entity.soptamp.Stamp;
+import org.sopt.app.domain.enums.TeamNumber;
+
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class AppjamRankInfo {
+
+	@Getter
+	@Builder
+	public static class RankAggregate {
+
+		private final List<Stamp> latestStamps;
+		private final List<Long> uploaderUserIds;
+		private final Map<Long, AppjamUser> uploaderAppjamUserByUserId;
+
+		public static RankAggregate of(
+			List<Stamp> latestStamps,
+			List<Long> uploaderUserIds,
+			Map<Long, AppjamUser> uploaderAppjamUserByUserId
+		) {
+			return RankAggregate.builder()
+				.latestStamps(latestStamps)
+				.uploaderUserIds(uploaderUserIds)
+				.uploaderAppjamUserByUserId(uploaderAppjamUserByUserId)
+				.build();
+		}
+
+		public static RankAggregate empty() {
+			return RankAggregate.builder()
+				.latestStamps(List.of())
+				.uploaderUserIds(List.of())
+				.uploaderAppjamUserByUserId(Map.of())
+				.build();
+		}
+	}
+
+	@Getter
+	@Builder
+	public static class TeamRank {
+		private final Long stampId;
+		private final Long missionId;
+		private final Long userId;
+		private final String imageUrl;
+		private final LocalDateTime createdAt;
+		private final String userName;
+		private final String userProfileImage;
+		private final String teamName;
+		private final TeamNumber teamNumber;
+
+		public static TeamRank of(
+			Stamp stamp,
+			String firstImageUrl,
+			AppjamUser uploaderAppjamUser,
+			TeamNumber teamNumber,
+			PlaygroundProfileInfo.PlaygroundProfile playgroundProfile
+		) {
+			return TeamRank.builder()
+				.stampId(stamp.getId())
+				.missionId(stamp.getMissionId())
+				.userId(stamp.getUserId())
+				.imageUrl(firstImageUrl)
+				.createdAt(stamp.getCreatedAt())
+				.userName(playgroundProfile.getName())
+				.userProfileImage(Optional.ofNullable(playgroundProfile.getProfileImage()).orElse(""))
+				.teamName(uploaderAppjamUser.getTeamName())
+				.teamNumber(teamNumber)
+				.build();
+		}
+	}
+
+	@Getter
+	@Builder
+	@ToString
+	public static class TodayRank {
+		private final Long userId;
+		private final long todayPoints;
+		private final LocalDateTime firstCertifiedAtToday;
+
+		public static TodayRank of(Long userId, long todayPoints, LocalDateTime firstCertifiedAtToday) {
+			return TodayRank.builder()
+				.userId(userId)
+				.todayPoints(todayPoints)
+				.firstCertifiedAtToday(firstCertifiedAtToday)
+				.build();
+		}
+	}
+
+	@Getter
+	@Builder
+	public static class RankList {
+		private final List<TeamRank> ranks;
+
+		public static RankList of(List<TeamRank> ranks) {
+			return RankList.builder().ranks(ranks).build();
+		}
+	}
+
+	@Getter
+	@Builder
+	public static class TodayTeamRank {
+		private final int rank;
+		private final TeamNumber teamNumber;
+		private final String teamName;
+		private final long todayPoints;
+		private final long totalPoints;
+
+		public static TodayTeamRank of(
+			int rank,
+			TeamNumber teamNumber,
+			String teamName,
+			long todayPoints,
+			long totalPoints
+		) {
+			return TodayTeamRank.builder()
+				.rank(rank)
+				.teamNumber(teamNumber)
+				.teamName(teamName)
+				.todayPoints(todayPoints)
+				.totalPoints(totalPoints)
+				.build();
+		}
+	}
+
+	@Getter
+	@Builder
+	public static class TodayTeamRankList {
+		private final List<TodayTeamRank> ranks;
+
+		public static TodayTeamRankList of(List<TodayTeamRank> ranks) {
+			return TodayTeamRankList.builder().ranks(ranks).build();
+		}
+	}
+}

src/main/java/org/sopt/app/application/appjamrank/AppjamRankService.java

@@ -0,0 +1,68 @@
+package org.sopt.app.application.appjamrank;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.sopt.app.domain.entity.AppjamUser;
+import org.sopt.app.domain.entity.soptamp.Stamp;
+import org.sopt.app.interfaces.postgres.AppjamUserRepository;
+import org.sopt.app.interfaces.postgres.StampRepository;
+import org.sopt.app.interfaces.postgres.StampRepositoryCustom;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class AppjamRankService {
+
+	private static final int RECENT_RANK_LIMIT = 3;
+
+	private final StampRepository stampRepository;
+	private final AppjamUserRepository appjamUserRepository;
+
+	public AppjamRankInfo.RankAggregate findRecentTeamRanks() {
+		Pageable latestStampPageable = PageRequest.of(0, RECENT_RANK_LIMIT);
+
+		List<Stamp> latestStamps = stampRepository.findLatestStamps(latestStampPageable);
+		if (latestStamps.isEmpty()) {
+			return AppjamRankInfo.RankAggregate.empty();
+		}
+
+		List<Long> uploaderUserIds = latestStamps.stream()
+			.map(Stamp::getUserId)
+			.distinct()
+			.toList();
+
+		List<AppjamUser> uploaderAppjamUsers = appjamUserRepository.findAllByUserIdIn(uploaderUserIds);
+
+		Map<Long, AppjamUser> uploaderAppjamUserByUserId = uploaderAppjamUsers.stream()
+			.collect(Collectors.toMap(
+				AppjamUser::getUserId,
+				Function.identity(),
+				(existing, replacement) -> existing
+			));
+
+		return AppjamRankInfo.RankAggregate.of(
+			latestStamps,
+			uploaderUserIds,
+			uploaderAppjamUserByUserId
+		);
+	}
+
+	public List<StampRepositoryCustom.AppjamTodayRankSource> findTodayUserRankSources(
+		LocalDateTime todayStart,
+		LocalDateTime tomorrowStart
+	) {
+		return stampRepository.findTodayUserRankSources(todayStart, tomorrowStart);
+	}
+
+	public List<AppjamUser> findAllAppjamUsers() {
+		return appjamUserRepository.findAll();
+	}
+}

src/main/java/org/sopt/app/application/app_service/AppServiceBadgeManager.java → src/main/java/org/sopt/app/application/appservice/AppServiceBadgeManager.java

@@ -1,6 +1,6 @@
-package org.sopt.app.application.app_service;
+package org.sopt.app.application.appservice;
 
-import org.sopt.app.application.app_service.dto.AppServiceBadgeInfo;
+import org.sopt.app.application.appservice.dto.AppServiceBadgeInfo;
 
 public interface AppServiceBadgeManager {
 

src/main/java/org/sopt/app/application/app_service/AppServiceBadgeService.java → src/main/java/org/sopt/app/application/appservice/AppServiceBadgeService.java

@@ -1,10 +1,10 @@
-package org.sopt.app.application.app_service;
+package org.sopt.app.application.appservice;
 
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
-import org.sopt.app.application.app_service.dto.AppServiceBadgeInfo;
-import org.sopt.app.application.app_service.dto.AppServiceEntryStatusResponse;
-import org.sopt.app.application.app_service.dto.AppServiceInfo;
+import org.sopt.app.application.appservice.dto.AppServiceBadgeInfo;
+import org.sopt.app.application.appservice.dto.AppServiceEntryStatusResponse;
+import org.sopt.app.application.appservice.dto.AppServiceInfo;
 import org.springframework.stereotype.Service;
 
 @Service

src/main/java/org/sopt/app/application/app_service/AppServiceName.java → src/main/java/org/sopt/app/application/appservice/AppServiceName.java

@@ -1,4 +1,4 @@
-package org.sopt.app.application.app_service;
+package org.sopt.app.application.appservice;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;