88 lines
3.0 KiB
TypeScript
88 lines
3.0 KiB
TypeScript
/**
|
|
* Application Query: GetRaceWithSOFQuery
|
|
*
|
|
* Returns race details enriched with calculated Strength of Field (SOF).
|
|
* SOF is calculated from participant ratings if not already stored on the race.
|
|
*/
|
|
|
|
import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
|
|
import type { IRaceRegistrationRepository } from '../../domain/repositories/IRaceRegistrationRepository';
|
|
import type { IResultRepository } from '../../domain/repositories/IResultRepository';
|
|
import type { DriverRatingProvider } from '../ports/DriverRatingProvider';
|
|
import {
|
|
AverageStrengthOfFieldCalculator,
|
|
type StrengthOfFieldCalculator,
|
|
} from '../../domain/services/StrengthOfFieldCalculator';
|
|
import type { RaceDTO } from '../dto/RaceDTO';
|
|
|
|
export interface GetRaceWithSOFQueryParams {
|
|
raceId: string;
|
|
}
|
|
|
|
export interface RaceWithSOFDTO extends Omit<RaceDTO, 'strengthOfField'> {
|
|
strengthOfField: number | null;
|
|
participantCount: number;
|
|
}
|
|
|
|
export class GetRaceWithSOFQuery {
|
|
private readonly sofCalculator: StrengthOfFieldCalculator;
|
|
|
|
constructor(
|
|
private readonly raceRepository: IRaceRepository,
|
|
private readonly registrationRepository: IRaceRegistrationRepository,
|
|
private readonly resultRepository: IResultRepository,
|
|
private readonly driverRatingProvider: DriverRatingProvider,
|
|
sofCalculator?: StrengthOfFieldCalculator,
|
|
) {
|
|
this.sofCalculator = sofCalculator ?? new AverageStrengthOfFieldCalculator();
|
|
}
|
|
|
|
async execute(params: GetRaceWithSOFQueryParams): Promise<RaceWithSOFDTO | null> {
|
|
const { raceId } = params;
|
|
|
|
const race = await this.raceRepository.findById(raceId);
|
|
if (!race) {
|
|
return null;
|
|
}
|
|
|
|
// Get participant IDs based on race status
|
|
let participantIds: string[] = [];
|
|
|
|
if (race.status === 'completed') {
|
|
// For completed races, use results
|
|
const results = await this.resultRepository.findByRaceId(raceId);
|
|
participantIds = results.map(r => r.driverId);
|
|
} else {
|
|
// For upcoming/running races, use registrations
|
|
participantIds = await this.registrationRepository.getRegisteredDrivers(raceId);
|
|
}
|
|
|
|
// Use stored SOF if available, otherwise calculate
|
|
let strengthOfField = race.strengthOfField ?? null;
|
|
|
|
if (strengthOfField === null && participantIds.length > 0) {
|
|
const ratings = this.driverRatingProvider.getRatings(participantIds);
|
|
const driverRatings = participantIds
|
|
.filter(id => ratings.has(id))
|
|
.map(id => ({ driverId: id, rating: ratings.get(id)! }));
|
|
|
|
strengthOfField = this.sofCalculator.calculate(driverRatings);
|
|
}
|
|
|
|
return {
|
|
id: race.id,
|
|
leagueId: race.leagueId,
|
|
scheduledAt: race.scheduledAt.toISOString(),
|
|
track: race.track,
|
|
trackId: race.trackId,
|
|
car: race.car,
|
|
carId: race.carId,
|
|
sessionType: race.sessionType,
|
|
status: race.status,
|
|
strengthOfField,
|
|
registeredCount: race.registeredCount ?? participantIds.length,
|
|
maxParticipants: race.maxParticipants,
|
|
participantCount: participantIds.length,
|
|
};
|
|
}
|
|
} |