rename to core

core/racing/application/use-cases/GetLeagueDriverSeasonStatsUseCase.ts

@@ -0,0 +1,109 @@
+import type { IStandingRepository } from '../../domain/repositories/IStandingRepository';
+import type { IResultRepository } from '../../domain/repositories/IResultRepository';
+import type { IPenaltyRepository } from '../../domain/repositories/IPenaltyRepository';
+import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
+import type {
+  ILeagueDriverSeasonStatsPresenter,
+  LeagueDriverSeasonStatsResultDTO,
+  LeagueDriverSeasonStatsViewModel,
+} from '../presenters/ILeagueDriverSeasonStatsPresenter';
+import type { UseCase } from '@gridpilot/shared/application/UseCase';
+
+export interface DriverRatingPort {
+  getRating(driverId: string): { rating: number | null; ratingChange: number | null };
+}
+
+export interface GetLeagueDriverSeasonStatsUseCaseParams {
+  leagueId: string;
+}
+
+/**
+ * Use Case for retrieving league driver season statistics.
+ * Orchestrates domain logic and delegates presentation to the presenter.
+ */
+export class GetLeagueDriverSeasonStatsUseCase
+  implements
+    UseCase<
+      GetLeagueDriverSeasonStatsUseCaseParams,
+      LeagueDriverSeasonStatsResultDTO,
+      LeagueDriverSeasonStatsViewModel,
+      ILeagueDriverSeasonStatsPresenter
+    >
+{
+  constructor(
+    private readonly standingRepository: IStandingRepository,
+    private readonly resultRepository: IResultRepository,
+    private readonly penaltyRepository: IPenaltyRepository,
+    private readonly raceRepository: IRaceRepository,
+    private readonly driverRatingPort: DriverRatingPort,
+  ) {}
+
+  async execute(
+    params: GetLeagueDriverSeasonStatsUseCaseParams,
+    presenter: ILeagueDriverSeasonStatsPresenter,
+  ): Promise<void> {
+    presenter.reset();
+    const { leagueId } = params;
+
+    // Get standings and races for the league
+    const [standings, races] = await Promise.all([
+      this.standingRepository.findByLeagueId(leagueId),
+      this.raceRepository.findByLeagueId(leagueId),
+    ]);
+
+    // Fetch all penalties for all races in the league
+    const penaltiesArrays = await Promise.all(
+      races.map(race => this.penaltyRepository.findByRaceId(race.id))
+    );
+    const penaltiesForLeague = penaltiesArrays.flat();
+
+    // Group penalties by driver for quick lookup
+    const penaltiesByDriver = new Map<string, { baseDelta: number; bonusDelta: number }>();
+    for (const p of penaltiesForLeague) {
+      // Only count applied penalties
+      if (p.status !== 'applied') continue;
+      
+      const current = penaltiesByDriver.get(p.driverId) ?? { baseDelta: 0, bonusDelta: 0 };
+      
+      // Convert penalty to points delta based on type
+      if (p.type === 'points_deduction' && p.value) {
+        // Points deductions are negative
+        current.baseDelta -= p.value;
+      }
+      
+      penaltiesByDriver.set(p.driverId, current);
+    }
+
+    // Collect driver ratings
+    const driverRatings = new Map<string, { rating: number | null; ratingChange: number | null }>();
+    for (const standing of standings) {
+      const ratingInfo = this.driverRatingPort.getRating(standing.driverId);
+      driverRatings.set(standing.driverId, ratingInfo);
+    }
+
+    // Collect driver results
+    const driverResults = new Map<string, Array<{ position: number }>>();
+    for (const standing of standings) {
+      const results = await this.resultRepository.findByDriverIdAndLeagueId(
+        standing.driverId,
+        leagueId,
+      );
+      driverResults.set(standing.driverId, results);
+    }
+
+    const dto: LeagueDriverSeasonStatsResultDTO = {
+      leagueId,
+      standings: standings.map(standing => ({
+        driverId: standing.driverId,
+        position: standing.position,
+        points: standing.points,
+        racesCompleted: standing.racesCompleted,
+      })),
+      penalties: penaltiesByDriver,
+      driverResults,
+      driverRatings,
+    };
+
+    presenter.present(dto);
+  }
+}