wip

packages/racing/application/use-cases/GetAllLeaguesWithCapacityAndScoringQuery.ts

@@ -3,23 +3,14 @@ import type { ILeagueMembershipRepository } from '../../domain/repositories/ILea
 import type { ISeasonRepository } from '../../domain/repositories/ISeasonRepository';
 import type { ILeagueScoringConfigRepository } from '../../domain/repositories/ILeagueScoringConfigRepository';
 import type { IGameRepository } from '../../domain/repositories/IGameRepository';
-import type {
-  LeagueScoringPresetProvider,
-  LeagueScoringPresetDTO,
-} from '../ports/LeagueScoringPresetProvider';
-import type {
-  LeagueSummaryDTO,
-  LeagueSummaryScoringDTO,
-} from '../dto/LeagueSummaryDTO';
+import type { LeagueScoringPresetProvider } from '../ports/LeagueScoringPresetProvider';
+import type { IAllLeaguesWithCapacityAndScoringPresenter, LeagueEnrichedData } from '../presenters/IAllLeaguesWithCapacityAndScoringPresenter';
 
 /**
- * Combined capacity + scoring summary query for leagues.
- *
- * Extends the behavior of GetAllLeaguesWithCapacityQuery by including
- * scoring preset and game summaries when an active season and
- * LeagueScoringConfig are available.
+ * Use Case for retrieving all leagues with capacity and scoring information.
+ * Orchestrates domain logic and delegates presentation to the presenter.
  */
-export class GetAllLeaguesWithCapacityAndScoringQuery {
+export class GetAllLeaguesWithCapacityAndScoringUseCase {
   constructor(
     private readonly leagueRepository: ILeagueRepository,
     private readonly leagueMembershipRepository: ILeagueMembershipRepository,
@@ -27,17 +18,16 @@ export class GetAllLeaguesWithCapacityAndScoringQuery {
     private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
     private readonly gameRepository: IGameRepository,
     private readonly presetProvider: LeagueScoringPresetProvider,
+    public readonly presenter: IAllLeaguesWithCapacityAndScoringPresenter,
   ) {}
 
-  async execute(): Promise<LeagueSummaryDTO[]> {
+  async execute(): Promise<void> {
     const leagues = await this.leagueRepository.findAll();
 
-    const results: LeagueSummaryDTO[] = [];
+    const enrichedLeagues: LeagueEnrichedData[] = [];
 
     for (const league of leagues) {
-      const members = await this.leagueMembershipRepository.getLeagueMembers(
-        league.id,
-      );
+      const members = await this.leagueMembershipRepository.getLeagueMembers(league.id);
 
       const usedDriverSlots = members.filter(
         (m) =>
@@ -48,116 +38,36 @@ export class GetAllLeaguesWithCapacityAndScoringQuery {
             m.role === 'member'),
       ).length;
 
-      const configuredMaxDrivers = league.settings.maxDrivers ?? usedDriverSlots;
-      const safeMaxDrivers = Math.max(configuredMaxDrivers, usedDriverSlots);
+      const seasons = await this.seasonRepository.findByLeagueId(league.id);
+      const activeSeason = seasons && seasons.length > 0
+        ? seasons.find((s) => s.status === 'active') ?? seasons[0]
+        : undefined;
 
-      const scoringSummary = await this.buildScoringSummary(league.id);
+      let scoringConfig;
+      let game;
+      let preset;
 
-      const structureSummary = `Solo • ${safeMaxDrivers} drivers`;
+      if (activeSeason) {
+        scoringConfig = await this.leagueScoringConfigRepository.findBySeasonId(activeSeason.id);
+        if (scoringConfig) {
+          game = await this.gameRepository.findById(activeSeason.gameId);
+          const presetId = scoringConfig.scoringPresetId;
+          if (presetId) {
+            preset = this.presetProvider.getPresetById(presetId);
+          }
+        }
+      }
 
-      const qualifyingMinutes = 30;
-      const mainRaceMinutes =
-        typeof league.settings.sessionDuration === 'number'
-          ? league.settings.sessionDuration
-          : 40;
-      const timingSummary = `${qualifyingMinutes} min Quali • ${mainRaceMinutes} min Race`;
-
-      const dto: LeagueSummaryDTO = {
-        id: league.id,
-        name: league.name,
-        description: league.description,
-        ownerId: league.ownerId,
-        createdAt: league.createdAt,
-        maxDrivers: safeMaxDrivers,
+      enrichedLeagues.push({
+        league,
         usedDriverSlots,
-        maxTeams: undefined,
-        usedTeamSlots: undefined,
-        structureSummary,
-        scoringPatternSummary: scoringSummary?.scoringPatternSummary,
-        timingSummary,
-        scoring: scoringSummary,
-      };
-
-      results.push(dto);
+        season: activeSeason,
+        scoringConfig,
+        game,
+        preset,
+      });
     }
 
-    return results;
-  }
-
-  private async buildScoringSummary(
-    leagueId: string,
-  ): Promise<LeagueSummaryScoringDTO | undefined> {
-    const seasons = await this.seasonRepository.findByLeagueId(leagueId);
-    if (!seasons || seasons.length === 0) {
-      return undefined;
-    }
-
-    const activeSeason =
-      seasons.find((s) => s.status === 'active') ?? seasons[0];
-
-    const scoringConfig =
-      await this.leagueScoringConfigRepository.findBySeasonId(activeSeason.id);
-    if (!scoringConfig) {
-      return undefined;
-    }
-
-    const game = await this.gameRepository.findById(activeSeason.gameId);
-    if (!game) {
-      return undefined;
-    }
-
-    const presetId = scoringConfig.scoringPresetId;
-    let preset: LeagueScoringPresetDTO | undefined;
-    if (presetId) {
-      preset = this.presetProvider.getPresetById(presetId);
-    }
-
-    const dropPolicySummary =
-      preset?.dropPolicySummary ?? this.deriveDropPolicySummary(scoringConfig);
-    const primaryChampionshipType =
-      preset?.primaryChampionshipType ??
-      (scoringConfig.championships[0]?.type ?? 'driver');
-
-    const scoringPresetName = preset?.name ?? 'Custom';
-    const scoringPatternSummary = `${scoringPresetName} • ${dropPolicySummary}`;
-
-    return {
-      gameId: game.id,
-      gameName: game.name,
-      primaryChampionshipType,
-      scoringPresetId: presetId ?? 'custom',
-      scoringPresetName,
-      dropPolicySummary,
-      scoringPatternSummary,
-    };
-  }
-
-  private deriveDropPolicySummary(config: {
-    championships: Array<{
-      dropScorePolicy: { strategy: string; count?: number; dropCount?: number };
-    }>;
-  }): string {
-    const championship = config.championships[0];
-    if (!championship) {
-      return 'All results count';
-    }
-
-    const policy = championship.dropScorePolicy;
-    if (!policy || policy.strategy === 'none') {
-      return 'All results count';
-    }
-
-    if (policy.strategy === 'bestNResults' && typeof policy.count === 'number') {
-      return `Best ${policy.count} results count`;
-    }
-
-    if (
-      policy.strategy === 'dropWorstN' &&
-      typeof policy.dropCount === 'number'
-    ) {
-      return `Worst ${policy.dropCount} results are dropped`;
-    }
-
-    return 'Custom drop score rules';
+    this.presenter.present(enrichedLeagues);
   }
 }