[FEAT] 매니저가 생성한 리그 전체 조회

src/docs/asciidoc/api.adoc

@@ -94,9 +94,9 @@ operation::league-team-controller-test/리그팀을_삭제한다[snippets='http-
 
 operation::league-query-controller-test/리그를_하나_조회한다[snippets='http-request,path-parameters,http-response,response-fields']
 
-=== 리그팀 상세 조회
+=== 매니저가 생성한 리그 전체 조회
 
-operation::league-query-controller-test/리그팀을_상세_조회한다[snippets='http-request,path-parameters,http-response,response-fields']
+operation::league-query-controller-test/매니저가_생성한_모든_리그를_조회한다[snippets='http-request,http-response,response-fields']
 
 == 타임라인 API
 

src/main/java/com/sports/server/auth/config/SecurityConfig.java

@@ -47,7 +47,8 @@ SecurityFilterChain filterChain(HttpSecurity http, MvcRequestMatcher.Builder mvc
                                 mvc.pattern(HttpMethod.PUT, "/leagues/{leagueId}/teams/{teamId}"),
                                 mvc.pattern(HttpMethod.DELETE, "/leagues/{leagueId}/teams/{teamId}"),
                                 mvc.pattern(HttpMethod.POST, "/leagues/{leagueId}/teams/{teamId}/delete-logo"),
-                                mvc.pattern(HttpMethod.POST, "/games/*/timelines/**")
+                                mvc.pattern(HttpMethod.POST, "/games/*/timelines/**"),
+                                mvc.pattern(HttpMethod.POST, "/games/{gameId}/lineup-players/{lineupPlayerId}/**")
                         )
                         .authenticated()
                         .anyRequest().permitAll()

src/main/java/com/sports/server/command/game/domain/Game.java

@@ -5,6 +5,7 @@
 import com.sports.server.command.member.domain.Member;
 import com.sports.server.command.sport.domain.Sport;
 import com.sports.server.common.domain.BaseEntity;
+import jakarta.persistence.CascadeType;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
@@ -40,7 +41,7 @@ public class Game extends BaseEntity<Game> {
     @JoinColumn(name = "league_id")
     private League league;
 
-    @OneToMany(mappedBy = "game")
+    @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<GameTeam> teams = new ArrayList<>();
 
     @Column(name = "name", nullable = false)

src/main/java/com/sports/server/command/league/domain/League.java

@@ -1,15 +1,20 @@
 package com.sports.server.command.league.domain;
 
+import com.sports.server.command.leagueteam.domain.LeagueTeam;
 import com.sports.server.command.member.domain.Member;
 import com.sports.server.command.organization.domain.Organization;
 import com.sports.server.common.domain.BaseEntity;
+import jakarta.persistence.CascadeType;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.FetchType;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
 import jakarta.persistence.Table;
 import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -48,25 +53,28 @@ public class League extends BaseEntity<League> {
     @Column(name = "is_deleted", nullable = false)
     private boolean isDeleted;
 
-	public League(
-		final Member manager,
-		final Organization organization,
-		final String name,
-		final LocalDateTime startAt,
-		final LocalDateTime endAt,
-		final Round maxRound
-	) {
-		this.manager = manager;
-		this.organization = organization;
-		this.name = name;
-		this.startAt = startAt;
-		this.endAt = endAt;
-		this.maxRound = maxRound;
-		this.inProgressRound = maxRound;
-		this.isDeleted = false;
-	}
+    @OneToMany(mappedBy = "league", cascade = CascadeType.ALL, orphanRemoval = true)
+    List<LeagueTeam> leagueTeams = new ArrayList<>();
 
-	public boolean isManagedBy(Member manager) {
-		return this.manager.equals(manager);
-	}
+    public League(
+            final Member manager,
+            final Organization organization,
+            final String name,
+            final LocalDateTime startAt,
+            final LocalDateTime endAt,
+            final Round maxRound
+    ) {
+        this.manager = manager;
+        this.organization = organization;
+        this.name = name;
+        this.startAt = startAt;
+        this.endAt = endAt;
+        this.maxRound = maxRound;
+        this.inProgressRound = maxRound;
+        this.isDeleted = false;
+    }
+
+    public boolean isManagedBy(Member manager) {
+        return this.manager.equals(manager);
+    }
 }

src/main/java/com/sports/server/command/leagueteam/domain/LeagueTeam.java

@@ -1,6 +1,7 @@
 package com.sports.server.command.leagueteam.domain;
 
 import com.sports.server.auth.exception.AuthorizationErrorMessages;
+import com.sports.server.command.game.domain.GameTeam;
 import com.sports.server.command.league.domain.League;
 import com.sports.server.command.member.domain.Member;
 import com.sports.server.command.organization.domain.Organization;
@@ -47,6 +48,9 @@ public class LeagueTeam extends BaseEntity<LeagueTeam> {
     @OneToMany(mappedBy = "leagueTeam", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<LeagueTeamPlayer> leagueTeamPlayers = new ArrayList<>();
 
+    @OneToMany(mappedBy = "leagueTeam", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<GameTeam> gameTeams = new ArrayList<>();
+
     public void addPlayer(LeagueTeamPlayer leagueTeamPlayer) {
         leagueTeamPlayers.add(leagueTeamPlayer);
     }

src/main/java/com/sports/server/query/application/LeagueQueryService.java

@@ -1,21 +1,30 @@
 package com.sports.server.query.application;
 
+import static java.util.stream.Collectors.toMap;
+
+import com.sports.server.command.game.domain.Game;
 import com.sports.server.command.league.domain.League;
+import com.sports.server.command.league.domain.LeagueProgress;
 import com.sports.server.command.leagueteam.domain.LeagueTeam;
 import com.sports.server.command.leagueteam.domain.LeagueTeamPlayer;
+import com.sports.server.command.member.domain.Member;
 import com.sports.server.common.application.EntityUtils;
 import com.sports.server.common.exception.NotFoundException;
 import com.sports.server.query.dto.response.LeagueDetailResponse;
 import com.sports.server.query.dto.response.LeagueResponse;
+import com.sports.server.query.dto.response.LeagueResponseWithInProgressGames;
 import com.sports.server.query.dto.response.LeagueSportResponse;
 import com.sports.server.query.dto.response.LeagueTeamDetailResponse;
 import com.sports.server.query.dto.response.LeagueTeamPlayerResponse;
 import com.sports.server.query.dto.response.LeagueTeamResponse;
+import com.sports.server.query.repository.GameQueryRepository;
 import com.sports.server.query.repository.LeagueQueryRepository;
 import com.sports.server.query.repository.LeagueSportQueryRepository;
 import com.sports.server.query.repository.LeagueTeamDynamicRepository;
 import com.sports.server.query.repository.LeagueTeamPlayerQueryRepository;
+import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Map;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -29,6 +38,7 @@ public class LeagueQueryService {
     private final LeagueSportQueryRepository leagueSportQueryRepository;
     private final LeagueTeamDynamicRepository leagueTeamDynamicRepository;
     private final LeagueTeamPlayerQueryRepository leagueTeamPlayerQueryRepository;
+    private final GameQueryRepository gameQueryRepository;
     private final EntityUtils entityUtils;
 
     public List<LeagueResponse> findLeagues(Integer year) {
@@ -70,9 +80,28 @@ public List<LeagueTeamPlayerResponse> findPlayersByLeagueTeam(Long leagueTeamId)
                 .toList();
     }
 
+    public List<LeagueResponseWithInProgressGames> findLeaguesByManager(final Member member) {
+        List<League> leagues = leagueQueryRepository.findByManager(member);
+        Map<League, List<Game>> gamesForLeagues = getGamesForLeague(leagues);
+
+        return leagues.stream()
+                .map(league -> LeagueResponseWithInProgressGames.of(
+                        league,
+                        LeagueProgress.getProgressDescription(LocalDateTime.now(), league),
+                        gamesForLeagues.get(league)))
+                .toList();
+    }
+
+    private Map<League, List<Game>> getGamesForLeague(List<League> leagues) {
+        return leagues.stream()
+                .collect(toMap(league -> league, league -> gameQueryRepository.findByLeagueWithGameTeams(league)));
+    }
+
+
     public LeagueTeamDetailResponse findLeagueTeam(final Long leagueTeamId) {
         LeagueTeam leagueTeam = entityUtils.getEntity(leagueTeamId, LeagueTeam.class);
-        List<LeagueTeamPlayer> leagueTeamPlayers = leagueTeamPlayerQueryRepository.findByLeagueTeamId(leagueTeam.getId());
+        List<LeagueTeamPlayer> leagueTeamPlayers = leagueTeamPlayerQueryRepository.findByLeagueTeamId(
+                leagueTeam.getId());
         return LeagueTeamDetailResponse.of(leagueTeam, leagueTeamPlayers);
     }
 }

src/main/java/com/sports/server/query/dto/response/LeagueResponseWithInProgressGames.java

@@ -0,0 +1,64 @@
+package com.sports.server.query.dto.response;
+
+import com.sports.server.command.game.domain.Game;
+import com.sports.server.command.game.domain.GameTeam;
+import com.sports.server.command.league.domain.League;
+import java.time.LocalDateTime;
+import java.util.List;
+
+public record LeagueResponseWithInProgressGames(
+
+        Long id,
+        String name,
+        String state,
+        int sizeOfLeagueTeams,
+        String maxRound,
+        LocalDateTime startAt,
+        LocalDateTime endAt,
+        List<GameDetailResponse> inProgressGames
+
+) {
+    public static LeagueResponseWithInProgressGames of(League league, String state, List<Game> games) {
+        return new LeagueResponseWithInProgressGames(
+                league.getId(), league.getName(), state, league.getLeagueTeams().size(),
+                league.getMaxRound().getDescription(), league.getStartAt(), league.getEndAt(),
+                games.stream()
+                        .map(GameDetailResponse::of)
+                        .toList()
+        );
+    }
+
+    public record GameDetailResponse(
+            Long id,
+            String state,
+            LocalDateTime startTime,
+            List<GameTeamResponse> gameTeams
+    ) {
+        public record GameTeamResponse(
+                Long gameTeamId,
+                String gameTeamName,
+                String logoImageUrl,
+                Integer score
+        ) {
+            public static GameTeamResponse of(GameTeam gameTeam) {
+                return new GameTeamResponse(
+                        gameTeam.getId(),
+                        gameTeam.getLeagueTeam().getName(),
+                        gameTeam.getLeagueTeam().getLogoImageUrl(),
+                        gameTeam.getScore()
+                );
+            }
+        }
+
+        public static GameDetailResponse of(final Game game) {
+            return new GameDetailResponse(
+                    game.getId(), game.getState().name(), game.getStartTime(),
+                    game.getTeams().stream()
+                            .map(GameTeamResponse::of)
+                            .toList()
+            );
+        }
+
+    }
+}
+

src/main/java/com/sports/server/query/presentation/GameQueryController.java

@@ -1,16 +1,23 @@
 package com.sports.server.query.presentation;
 
-import com.sports.server.query.dto.request.GamesQueryRequestDto;
 import com.sports.server.common.dto.PageRequestDto;
 import com.sports.server.query.application.GameQueryService;
-import com.sports.server.query.application.LineupPlayerQueryService;
 import com.sports.server.query.application.GameTeamQueryService;
-import com.sports.server.query.dto.response.*;
+import com.sports.server.query.application.LineupPlayerQueryService;
+import com.sports.server.query.dto.request.GamesQueryRequestDto;
+import com.sports.server.query.dto.response.GameDetailResponse;
+import com.sports.server.query.dto.response.GameResponseDto;
+import com.sports.server.query.dto.response.GameTeamCheerResponseDto;
+import com.sports.server.query.dto.response.LineupPlayerResponse;
+import com.sports.server.query.dto.response.VideoResponse;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.ModelAttribute;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
 @RestController
 @RequiredArgsConstructor

src/main/java/com/sports/server/query/presentation/LeagueQueryController.java

@@ -1,8 +1,10 @@
 package com.sports.server.query.presentation;
 
+import com.sports.server.command.member.domain.Member;
 import com.sports.server.query.application.LeagueQueryService;
 import com.sports.server.query.dto.response.LeagueDetailResponse;
 import com.sports.server.query.dto.response.LeagueResponse;
+import com.sports.server.query.dto.response.LeagueResponseWithInProgressGames;
 import com.sports.server.query.dto.response.LeagueSportResponse;
 import com.sports.server.query.dto.response.LeagueTeamDetailResponse;
 import com.sports.server.query.dto.response.LeagueTeamPlayerResponse;
@@ -50,6 +52,11 @@ public ResponseEntity<List<LeagueTeamPlayerResponse>> findPlayersByLeagueTeam(@P
         return ResponseEntity.ok(leagueQueryService.findPlayersByLeagueTeam(leagueTeamId));
     }
 
+    @GetMapping("/manager")
+    public ResponseEntity<List<LeagueResponseWithInProgressGames>> findLeaguesByManager(final Member member) {
+        return ResponseEntity.ok(leagueQueryService.findLeaguesByManager(member));
+    }
+
     @GetMapping("/teams/{leagueTeamId}")
     public ResponseEntity<LeagueTeamDetailResponse> findLeagueTeam(@PathVariable final Long leagueTeamId) {
         return ResponseEntity.ok(leagueQueryService.findLeagueTeam(leagueTeamId));

src/main/java/com/sports/server/query/repository/GameQueryRepository.java

@@ -0,0 +1,18 @@
+package com.sports.server.query.repository;
+
+import com.sports.server.command.game.domain.Game;
+import com.sports.server.command.league.domain.League;
+import java.util.List;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.Repository;
+import org.springframework.data.repository.query.Param;
+
+public interface GameQueryRepository extends Repository<Game, Long> {
+    @Query(
+            "SELECT g FROM Game g "
+                    + "JOIN FETCH g.teams "
+                    + "WHERE g.league =:league "
+                    + "AND g.state = 'PLAYING'"
+    )
+    List<Game> findByLeagueWithGameTeams(@Param("league") League league);
+}

src/main/java/com/sports/server/query/repository/LeagueQueryRepository.java

@@ -1,11 +1,20 @@
 package com.sports.server.query.repository;
 
 import com.sports.server.command.league.domain.League;
-import org.springframework.data.repository.Repository;
-
+import com.sports.server.command.member.domain.Member;
+import java.util.List;
 import java.util.Optional;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.Repository;
 
 public interface LeagueQueryRepository extends Repository<League, Long>, LeagueQueryDynamicRepository {
 
     Optional<League> findById(Long id);
+
+    @Query(
+            "SELECT l FROM League l "
+                    + "JOIN FETCH l.leagueTeams "
+                    + "WHERE l.manager =:member"
+    )
+    List<League> findByManager(Member member);
 }