114 lines
4.4 KiB
TypeScript
114 lines
4.4 KiB
TypeScript
import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
|
|
import type { IRaceRegistrationRepository } from '../../domain/repositories/IRaceRegistrationRepository';
|
|
import type { IResultRepository } from '../../domain/repositories/IResultRepository';
|
|
import type { IStandingRepository } from '../../domain/repositories/IStandingRepository';
|
|
import type { DriverRatingProvider } from '../ports/DriverRatingProvider';
|
|
import { Result } from '../../domain/entities/Result';
|
|
import { Standing } from '../../domain/entities/Standing';
|
|
import { RaceResultGenerator } from '../utils/RaceResultGenerator';
|
|
import { RatingUpdateService } from '@core/identity/domain/services/RatingUpdateService';
|
|
import type { AsyncUseCase } from '@core/shared/application';
|
|
import { Result as SharedResult } from '@core/shared/application/Result';
|
|
import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
|
|
import type { CompleteRaceCommandDTO } from '../dto/CompleteRaceCommandDTO';
|
|
|
|
/**
|
|
* Enhanced CompleteRaceUseCase that includes rating updates
|
|
*/
|
|
export class CompleteRaceUseCaseWithRatings
|
|
implements AsyncUseCase<CompleteRaceCommandDTO, void, string> {
|
|
constructor(
|
|
private readonly raceRepository: IRaceRepository,
|
|
private readonly raceRegistrationRepository: IRaceRegistrationRepository,
|
|
private readonly resultRepository: IResultRepository,
|
|
private readonly standingRepository: IStandingRepository,
|
|
private readonly driverRatingProvider: DriverRatingProvider,
|
|
private readonly ratingUpdateService: RatingUpdateService,
|
|
) {}
|
|
|
|
async execute(command: CompleteRaceCommandDTO): Promise<SharedResult<void, ApplicationErrorCode<string>>> {
|
|
try {
|
|
const { raceId } = command;
|
|
|
|
const race = await this.raceRepository.findById(raceId);
|
|
if (!race) {
|
|
return SharedResult.err({ code: 'RACE_NOT_FOUND' });
|
|
}
|
|
|
|
// Get registered drivers for this race
|
|
const registeredDriverIds = await this.raceRegistrationRepository.getRegisteredDrivers(raceId);
|
|
if (registeredDriverIds.length === 0) {
|
|
return SharedResult.err({ code: 'NO_REGISTERED_DRIVERS' });
|
|
}
|
|
|
|
// Get driver ratings
|
|
const driverRatings = this.driverRatingProvider.getRatings(registeredDriverIds);
|
|
|
|
// Generate realistic race results
|
|
const results = RaceResultGenerator.generateRaceResults(raceId, registeredDriverIds, driverRatings);
|
|
|
|
// Save results
|
|
for (const result of results) {
|
|
await this.resultRepository.create(result);
|
|
}
|
|
|
|
// Update standings
|
|
await this.updateStandings(race.leagueId, results);
|
|
|
|
// Update driver ratings based on performance
|
|
await this.updateDriverRatings(results, registeredDriverIds.length);
|
|
|
|
// Complete the race
|
|
const completedRace = race.complete();
|
|
await this.raceRepository.update(completedRace);
|
|
|
|
return SharedResult.ok(undefined);
|
|
} catch {
|
|
return SharedResult.err({ code: 'UNKNOWN_ERROR' });
|
|
}
|
|
}
|
|
|
|
private async updateStandings(leagueId: string, results: Result[]): Promise<void> {
|
|
// Group results by driver
|
|
const resultsByDriver = new Map<string, Result[]>();
|
|
for (const result of results) {
|
|
const existing = resultsByDriver.get(result.driverId) || [];
|
|
existing.push(result);
|
|
resultsByDriver.set(result.driverId, existing);
|
|
}
|
|
|
|
// Update or create standings for each driver
|
|
for (const [driverId, driverResults] of resultsByDriver) {
|
|
let standing = await this.standingRepository.findByDriverIdAndLeagueId(driverId, leagueId);
|
|
|
|
if (!standing) {
|
|
standing = Standing.create({
|
|
leagueId,
|
|
driverId,
|
|
});
|
|
}
|
|
|
|
// Add all results for this driver (should be just one for this race)
|
|
for (const result of driverResults) {
|
|
standing = standing.addRaceResult(result.position, {
|
|
1: 25, 2: 18, 3: 15, 4: 12, 5: 10, 6: 8, 7: 6, 8: 4, 9: 2, 10: 1
|
|
});
|
|
}
|
|
|
|
await this.standingRepository.save(standing);
|
|
}
|
|
}
|
|
|
|
private async updateDriverRatings(results: Result[], totalDrivers: number): Promise<void> {
|
|
const driverResults = results.map(result => ({
|
|
driverId: result.driverId,
|
|
position: result.position,
|
|
totalDrivers,
|
|
incidents: result.incidents,
|
|
startPosition: result.startPosition,
|
|
}));
|
|
|
|
await this.ratingUpdateService.updateDriverRatingsAfterRace(driverResults);
|
|
}
|
|
}
|