85 lines
3.5 KiB
TypeScript
85 lines
3.5 KiB
TypeScript
import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
|
|
import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
|
|
import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
|
|
import type { IRaceRegistrationRepository } from '../../domain/repositories/IRaceRegistrationRepository';
|
|
import type { IResultRepository } from '../../domain/repositories/IResultRepository';
|
|
import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
|
|
import type { RaceDetailOutputPort } from '../ports/output/RaceDetailOutputPort';
|
|
import type { AsyncUseCase } from '@core/shared/application/AsyncUseCase';
|
|
import { Result } from '@core/shared/application/Result';
|
|
import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
|
|
|
|
/**
|
|
* Use Case: GetRaceDetailUseCase
|
|
*
|
|
* Given a race id and current driver id:
|
|
* - When the race exists, it builds a view model with race, league, entry list, registration flags and user result.
|
|
* - When the race does not exist, it presents a view model with an error and no race data.
|
|
*
|
|
* Given a completed race with a result for the driver:
|
|
* - When computing rating change, it applies the same position-based formula used in the legacy UI.
|
|
*/
|
|
export interface GetRaceDetailQueryParams {
|
|
raceId: string;
|
|
driverId: string;
|
|
}
|
|
|
|
type GetRaceDetailErrorCode = 'RACE_NOT_FOUND';
|
|
|
|
export class GetRaceDetailUseCase
|
|
implements AsyncUseCase<GetRaceDetailQueryParams, RaceDetailOutputPort, GetRaceDetailErrorCode>
|
|
{
|
|
constructor(
|
|
private readonly raceRepository: IRaceRepository,
|
|
private readonly leagueRepository: ILeagueRepository,
|
|
private readonly driverRepository: IDriverRepository,
|
|
private readonly raceRegistrationRepository: IRaceRegistrationRepository,
|
|
private readonly resultRepository: IResultRepository,
|
|
private readonly leagueMembershipRepository: ILeagueMembershipRepository,
|
|
) {}
|
|
|
|
async execute(params: GetRaceDetailQueryParams): Promise<Result<RaceDetailOutputPort, ApplicationErrorCode<GetRaceDetailErrorCode>>> {
|
|
const { raceId, driverId } = params;
|
|
|
|
const race = await this.raceRepository.findById(raceId);
|
|
if (!race) {
|
|
return Result.err({ code: 'RACE_NOT_FOUND' });
|
|
}
|
|
|
|
const [league, registrations, membership] = await Promise.all([
|
|
this.leagueRepository.findById(race.leagueId),
|
|
this.raceRegistrationRepository.findByRaceId(race.id),
|
|
this.leagueMembershipRepository.getMembership(race.leagueId, driverId),
|
|
]);
|
|
|
|
const drivers = await Promise.all(
|
|
registrations.map(registration => this.driverRepository.findById(registration.driverId.toString())),
|
|
);
|
|
|
|
const validDrivers = drivers.filter((driver): driver is NonNullable<typeof driver> => driver !== null);
|
|
|
|
const isUserRegistered = registrations.some(reg => reg.driverId.toString() === driverId);
|
|
const isUpcoming = race.status === 'scheduled' && race.scheduledAt > new Date();
|
|
const canRegister = !!membership && membership.status === 'active' && isUpcoming;
|
|
|
|
let userResult: Result | null = null;
|
|
|
|
if (race.status === 'completed') {
|
|
const results = await this.resultRepository.findByRaceId(race.id);
|
|
userResult = results.find(r => r.driverId.toString() === driverId) ?? null;
|
|
}
|
|
|
|
const outputPort: RaceDetailOutputPort = {
|
|
race,
|
|
league,
|
|
registrations,
|
|
drivers: validDrivers,
|
|
userResult,
|
|
isUserRegistered,
|
|
canRegister,
|
|
};
|
|
|
|
return Result.ok(outputPort);
|
|
}
|
|
|
|
} |