120 lines
3.8 KiB
TypeScript
120 lines
3.8 KiB
TypeScript
import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
|
|
import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
|
|
import type { IResultRepository } from '../../domain/repositories/IResultRepository';
|
|
import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
|
|
import type { IPenaltyRepository } from '../../domain/repositories/IPenaltyRepository';
|
|
import type { RaceResultsDetailOutputPort } from '../ports/output/RaceResultsDetailOutputPort';
|
|
import type { AsyncUseCase } from '@core/shared/application/AsyncUseCase';
|
|
import { Result } from '@core/shared/application/Result';
|
|
import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
|
|
import type { League } from '../../domain/entities/League';
|
|
import type { Result as DomainResult } from '../../domain/entities/Result';
|
|
import type { Penalty } from '../../domain/entities/Penalty';
|
|
|
|
export interface GetRaceResultsDetailParams {
|
|
raceId: string;
|
|
driverId?: string;
|
|
}
|
|
|
|
|
|
type GetRaceResultsDetailErrorCode = 'RACE_NOT_FOUND';
|
|
|
|
export class GetRaceResultsDetailUseCase implements AsyncUseCase<GetRaceResultsDetailParams, RaceResultsDetailOutputPort, GetRaceResultsDetailErrorCode> {
|
|
constructor(
|
|
private readonly raceRepository: IRaceRepository,
|
|
private readonly leagueRepository: ILeagueRepository,
|
|
private readonly resultRepository: IResultRepository,
|
|
private readonly driverRepository: IDriverRepository,
|
|
private readonly penaltyRepository: IPenaltyRepository,
|
|
) {}
|
|
|
|
async execute(params: GetRaceResultsDetailParams): Promise<Result<RaceResultsDetailOutputPort, ApplicationErrorCode<GetRaceResultsDetailErrorCode>>> {
|
|
const { raceId, driverId } = params;
|
|
|
|
const race = await this.raceRepository.findById(raceId);
|
|
|
|
if (!race) {
|
|
return Result.err({ code: 'RACE_NOT_FOUND' });
|
|
}
|
|
|
|
const [league, results, drivers, penalties] = await Promise.all([
|
|
this.leagueRepository.findById(race.leagueId),
|
|
this.resultRepository.findByRaceId(raceId),
|
|
this.driverRepository.findAll(),
|
|
this.penaltyRepository.findByRaceId(raceId),
|
|
]);
|
|
|
|
const effectiveCurrentDriverId =
|
|
driverId ?? (drivers.length > 0 ? drivers[0]!.id : undefined);
|
|
|
|
const pointsSystem = this.buildPointsSystem(league);
|
|
const fastestLapTime = this.getFastestLapTime(results);
|
|
|
|
const outputPort: RaceResultsDetailOutputPort = {
|
|
race,
|
|
league,
|
|
results,
|
|
drivers,
|
|
penalties,
|
|
...(pointsSystem ? { pointsSystem } : {}),
|
|
...(fastestLapTime !== undefined ? { fastestLapTime } : {}),
|
|
...(effectiveCurrentDriverId ? { currentDriverId: effectiveCurrentDriverId } : {}),
|
|
};
|
|
|
|
return Result.ok(outputPort);
|
|
}
|
|
|
|
private buildPointsSystem(league: League | null): Record<number, number> | undefined {
|
|
if (!league) return undefined;
|
|
|
|
const pointsSystems: Record<string, Record<number, number>> = {
|
|
'f1-2024': {
|
|
1: 25,
|
|
2: 18,
|
|
3: 15,
|
|
4: 12,
|
|
5: 10,
|
|
6: 8,
|
|
7: 6,
|
|
8: 4,
|
|
9: 2,
|
|
10: 1,
|
|
},
|
|
indycar: {
|
|
1: 50,
|
|
2: 40,
|
|
3: 35,
|
|
4: 32,
|
|
5: 30,
|
|
6: 28,
|
|
7: 26,
|
|
8: 24,
|
|
9: 22,
|
|
10: 20,
|
|
11: 19,
|
|
12: 18,
|
|
13: 17,
|
|
14: 16,
|
|
15: 15,
|
|
},
|
|
};
|
|
|
|
const customPoints = league.settings.customPoints;
|
|
if (customPoints) {
|
|
return customPoints;
|
|
}
|
|
|
|
const preset = pointsSystems[league.settings.pointsSystem];
|
|
if (preset) {
|
|
return preset;
|
|
}
|
|
|
|
return pointsSystems['f1-2024'];
|
|
}
|
|
|
|
private getFastestLapTime(results: DomainResult[]): number | undefined {
|
|
if (results.length === 0) return undefined;
|
|
return Math.min(...results.map((r) => r.fastestLap));
|
|
}
|
|
|
|
} |