rename to core

core/racing/application/use-cases/CloseRaceEventStewardingUseCase.ts

@@ -0,0 +1,86 @@
+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
+  }
+}