86 lines
3.4 KiB
TypeScript
86 lines
3.4 KiB
TypeScript
import type { UseCase } from '@gridpilot/shared/application/UseCase';
|
|
import type { IRaceEventRepository } from '../../domain/repositories/IRaceEventRepository';
|
|
import type { IDomainEventPublisher } from '@gridpilot/shared/domain';
|
|
import type { RaceEventStewardingClosedEvent } from '../../domain/events/RaceEventStewardingClosed';
|
|
|
|
/**
|
|
* Use Case: CloseRaceEventStewardingUseCase
|
|
*
|
|
* Scheduled job that checks for race events with expired stewarding windows
|
|
* and closes them, triggering final results notifications.
|
|
*
|
|
* This would typically be run by a scheduled job (e.g., every 5 minutes)
|
|
* to automatically close stewarding windows based on league configuration.
|
|
*/
|
|
export interface CloseRaceEventStewardingCommand {
|
|
// No parameters needed - finds all expired events automatically
|
|
}
|
|
|
|
export class CloseRaceEventStewardingUseCase
|
|
implements UseCase<CloseRaceEventStewardingCommand, void, void, void>
|
|
{
|
|
constructor(
|
|
private readonly raceEventRepository: IRaceEventRepository,
|
|
private readonly domainEventPublisher: IDomainEventPublisher,
|
|
) {}
|
|
|
|
async execute(command: CloseRaceEventStewardingCommand): Promise<void> {
|
|
// Find all race events awaiting stewarding that have expired windows
|
|
const expiredEvents = await this.raceEventRepository.findAwaitingStewardingClose();
|
|
|
|
for (const raceEvent of expiredEvents) {
|
|
await this.closeStewardingForRaceEvent(raceEvent);
|
|
}
|
|
}
|
|
|
|
private async closeStewardingForRaceEvent(raceEvent: any): Promise<void> {
|
|
try {
|
|
// Close the stewarding window
|
|
const closedRaceEvent = raceEvent.closeStewarding();
|
|
await this.raceEventRepository.update(closedRaceEvent);
|
|
|
|
// Get list of participating drivers (would need to be implemented)
|
|
const driverIds = await this.getParticipatingDriverIds(raceEvent);
|
|
|
|
// Check if any penalties were applied during stewarding
|
|
const hadPenaltiesApplied = await this.checkForAppliedPenalties(raceEvent);
|
|
|
|
// Publish domain event to trigger final results notifications
|
|
const event = new RaceEventStewardingClosedEvent({
|
|
raceEventId: raceEvent.id,
|
|
leagueId: raceEvent.leagueId,
|
|
seasonId: raceEvent.seasonId,
|
|
closedAt: new Date(),
|
|
driverIds,
|
|
hadPenaltiesApplied,
|
|
});
|
|
|
|
await this.domainEventPublisher.publish(event);
|
|
|
|
} catch (error) {
|
|
console.error(`Failed to close stewarding for race event ${raceEvent.id}:`, error);
|
|
// In production, this would trigger alerts/monitoring
|
|
}
|
|
}
|
|
|
|
private async getParticipatingDriverIds(raceEvent: any): Promise<string[]> {
|
|
// In a real implementation, this would query race registrations
|
|
// For the prototype, we'll return a mock list
|
|
// This would typically involve:
|
|
// 1. Get all sessions in the race event
|
|
// 2. For each session, get registered drivers
|
|
// 3. Return unique driver IDs across all sessions
|
|
|
|
// Mock implementation for prototype
|
|
return ['driver-1', 'driver-2', 'driver-3']; // Would be dynamic in real implementation
|
|
}
|
|
|
|
private async checkForAppliedPenalties(raceEvent: any): Promise<boolean> {
|
|
// In a real implementation, this would check if any penalties were issued
|
|
// during the stewarding window for this race event
|
|
// This would query the penalty repository for penalties related to this race event
|
|
|
|
// Mock implementation for prototype - randomly simulate penalties
|
|
return Math.random() > 0.7; // 30% chance of penalties being applied
|
|
}
|
|
} |