fix data flow issues

apps/website/lib/services/ServiceFactory.ts

@@ -4,6 +4,7 @@ import { TeamsApiClient } from '../api/teams/TeamsApiClient';
 import { LeaguesApiClient } from '../api/leagues/LeaguesApiClient';
 import { SponsorsApiClient } from '../api/sponsors/SponsorsApiClient';
 import { PaymentsApiClient } from '../api/payments/PaymentsApiClient';
+import { WalletsApiClient } from '../api/wallets/WalletsApiClient';
 import { AuthApiClient } from '../api/auth/AuthApiClient';
 import { AnalyticsApiClient } from '../api/analytics/AnalyticsApiClient';
 import { MediaApiClient } from '../api/media/MediaApiClient';
@@ -17,6 +18,7 @@ import { ConsoleLogger } from '../infrastructure/logging/ConsoleLogger';
 // Services
 import { RaceService } from './races/RaceService';
 import { RaceResultsService } from './races/RaceResultsService';
+import { RaceStewardingService } from './races/RaceStewardingService';
 import { DriverService } from './drivers/DriverService';
 import { DriverRegistrationService } from './drivers/DriverRegistrationService';
 import { TeamService } from './teams/TeamService';
@@ -24,6 +26,8 @@ import { TeamJoinService } from './teams/TeamJoinService';
 import { LeagueService } from './leagues/LeagueService';
 import { LeagueMembershipService } from './leagues/LeagueMembershipService';
 import { LeagueSettingsService } from './leagues/LeagueSettingsService';
+import { LeagueStewardingService } from './leagues/LeagueStewardingService';
+import { LeagueWalletService } from './leagues/LeagueWalletService';
 import { SponsorService } from './sponsors/SponsorService';
 import { SponsorshipService } from './sponsors/SponsorshipService';
 import { PaymentService } from './payments/PaymentService';
@@ -56,6 +60,7 @@ export class ServiceFactory {
     leagues: LeaguesApiClient;
     sponsors: SponsorsApiClient;
     payments: PaymentsApiClient;
+    wallets: WalletsApiClient;
     auth: AuthApiClient;
     analytics: AnalyticsApiClient;
     media: MediaApiClient;
@@ -73,6 +78,7 @@ export class ServiceFactory {
       leagues: new LeaguesApiClient(baseUrl, this.errorReporter, this.logger),
       sponsors: new SponsorsApiClient(baseUrl, this.errorReporter, this.logger),
       payments: new PaymentsApiClient(baseUrl, this.errorReporter, this.logger),
+      wallets: new WalletsApiClient(baseUrl, this.errorReporter, this.logger),
       auth: new AuthApiClient(baseUrl, this.errorReporter, this.logger),
       analytics: new AnalyticsApiClient(baseUrl, this.errorReporter, this.logger),
       media: new MediaApiClient(baseUrl, this.errorReporter, this.logger),
@@ -96,6 +102,17 @@ export class ServiceFactory {
     return new RaceResultsService(this.apiClients.races);
   }
 
+  /**
+   * Create RaceStewardingService instance
+   */
+  createRaceStewardingService(): RaceStewardingService {
+    return new RaceStewardingService(
+      this.apiClients.races,
+      this.apiClients.protests,
+      this.apiClients.penalties
+    );
+  }
+
   /**
    * Create DriverService instance
    */
@@ -145,6 +162,26 @@ export class ServiceFactory {
      return new LeagueSettingsService(this.apiClients.leagues, this.apiClients.drivers);
    }
 
+   /**
+    * Create LeagueStewardingService instance
+    */
+   createLeagueStewardingService(): LeagueStewardingService {
+     return new LeagueStewardingService(
+       this.createRaceService(),
+       this.createProtestService(),
+       this.createPenaltyService(),
+       this.createDriverService(),
+       this.createLeagueMembershipService()
+     );
+   }
+
+   /**
+    * Create LeagueWalletService instance
+    */
+   createLeagueWalletService(): LeagueWalletService {
+     return new LeagueWalletService(this.apiClients.wallets);
+   }
+
   /**
    * Create SponsorService instance
    */

apps/website/lib/services/ServiceProvider.tsx

@@ -6,6 +6,7 @@ import { ServiceFactory } from './ServiceFactory';
 // Import all service types
 import { RaceService } from './races/RaceService';
 import { RaceResultsService } from './races/RaceResultsService';
+import { RaceStewardingService } from './races/RaceStewardingService';
 import { DriverService } from './drivers/DriverService';
 import { DriverRegistrationService } from './drivers/DriverRegistrationService';
 import { TeamService } from './teams/TeamService';
@@ -13,6 +14,8 @@ import { TeamJoinService } from './teams/TeamJoinService';
 import { LeagueService } from './leagues/LeagueService';
 import { LeagueMembershipService } from './leagues/LeagueMembershipService';
 import { LeagueSettingsService } from './leagues/LeagueSettingsService';
+import { LeagueStewardingService } from './leagues/LeagueStewardingService';
+import { LeagueWalletService } from './leagues/LeagueWalletService';
 import { SponsorService } from './sponsors/SponsorService';
 import { SponsorshipService } from './sponsors/SponsorshipService';
 import { PaymentService } from './payments/PaymentService';
@@ -30,6 +33,7 @@ import { PenaltyService } from './penalties/PenaltyService';
 export interface Services {
   raceService: RaceService;
   raceResultsService: RaceResultsService;
+  raceStewardingService: RaceStewardingService;
   driverService: DriverService;
   driverRegistrationService: DriverRegistrationService;
   teamService: TeamService;
@@ -37,6 +41,8 @@ export interface Services {
   leagueService: LeagueService;
   leagueMembershipService: LeagueMembershipService;
   leagueSettingsService: LeagueSettingsService;
+  leagueStewardingService: LeagueStewardingService;
+  leagueWalletService: LeagueWalletService;
   sponsorService: SponsorService;
   sponsorshipService: SponsorshipService;
   paymentService: PaymentService;
@@ -65,6 +71,7 @@ export function ServiceProvider({ children }: ServiceProviderProps) {
     return {
       raceService: serviceFactory.createRaceService(),
       raceResultsService: serviceFactory.createRaceResultsService(),
+      raceStewardingService: serviceFactory.createRaceStewardingService(),
       driverService: serviceFactory.createDriverService(),
       driverRegistrationService: serviceFactory.createDriverRegistrationService(),
       teamService: serviceFactory.createTeamService(),
@@ -72,6 +79,8 @@ export function ServiceProvider({ children }: ServiceProviderProps) {
       leagueService: serviceFactory.createLeagueService(),
       leagueMembershipService: serviceFactory.createLeagueMembershipService(),
       leagueSettingsService: serviceFactory.createLeagueSettingsService(),
+      leagueStewardingService: serviceFactory.createLeagueStewardingService(),
+      leagueWalletService: serviceFactory.createLeagueWalletService(),
       sponsorService: serviceFactory.createSponsorService(),
       sponsorshipService: serviceFactory.createSponsorshipService(),
       paymentService: serviceFactory.createPaymentService(),

apps/website/lib/services/leagues/LeagueStewardingService.ts

@@ -0,0 +1,93 @@
+import { RaceService } from '../races/RaceService';
+import { ProtestService } from '../protests/ProtestService';
+import { PenaltyService } from '../penalties/PenaltyService';
+import { DriverService } from '../drivers/DriverService';
+import { LeagueMembershipService } from './LeagueMembershipService';
+import { LeagueStewardingViewModel, RaceWithProtests } from '../../view-models/LeagueStewardingViewModel';
+
+/**
+ * League Stewarding Service
+ *
+ * Orchestrates league stewarding operations by coordinating calls to race, protest, penalty, driver, and membership services.
+ * All dependencies are injected via constructor.
+ */
+export class LeagueStewardingService {
+  constructor(
+    private readonly raceService: RaceService,
+    private readonly protestService: ProtestService,
+    private readonly penaltyService: PenaltyService,
+    private readonly driverService: DriverService,
+    private readonly leagueMembershipService: LeagueMembershipService
+  ) {}
+
+  /**
+   * Get league stewarding data for all races in a league
+   */
+  async getLeagueStewardingData(leagueId: string): Promise<LeagueStewardingViewModel> {
+    // Get all races for this league
+    const leagueRaces = await this.raceService.findByLeagueId(leagueId);
+
+    // Get protests and penalties for each race
+    const protestsMap: Record<string, any[]> = {};
+    const penaltiesMap: Record<string, any[]> = {};
+    const driverIds = new Set<string>();
+
+    for (const race of leagueRaces) {
+      const raceProtests = await this.protestService.findByRaceId(race.id);
+      const racePenalties = await this.penaltyService.findByRaceId(race.id);
+
+      protestsMap[race.id] = raceProtests;
+      penaltiesMap[race.id] = racePenalties;
+
+      // Collect driver IDs
+      raceProtests.forEach((p: any) => {
+        driverIds.add(p.protestingDriverId);
+        driverIds.add(p.accusedDriverId);
+      });
+      racePenalties.forEach((p: any) => {
+        driverIds.add(p.driverId);
+      });
+    }
+
+    // Load driver info
+    const driverEntities = await this.driverService.findByIds(Array.from(driverIds));
+    const driverMap: Record<string, any> = {};
+    driverEntities.forEach((driver) => {
+      if (driver) {
+        driverMap[driver.id] = driver;
+      }
+    });
+
+    // Compute race data with protest/penalty info
+    const racesWithData: RaceWithProtests[] = leagueRaces.map(race => {
+      const protests = protestsMap[race.id] || [];
+      const penalties = penaltiesMap[race.id] || [];
+      return {
+        race: {
+          id: race.id,
+          track: race.track,
+          scheduledAt: new Date(race.scheduledAt),
+        },
+        pendingProtests: protests.filter(p => p.status === 'pending' || p.status === 'under_review'),
+        resolvedProtests: protests.filter(p => p.status === 'upheld' || p.status === 'dismissed' || p.status === 'withdrawn'),
+        penalties
+      };
+    }).sort((a, b) => b.race.scheduledAt.getTime() - a.race.scheduledAt.getTime());
+
+    return new LeagueStewardingViewModel(racesWithData, driverMap);
+  }
+
+  /**
+   * Review a protest
+   */
+  async reviewProtest(input: { protestId: string; stewardId: string; decision: string; decisionNotes: string }): Promise<void> {
+    await this.protestService.reviewProtest(input);
+  }
+
+  /**
+   * Apply a penalty
+   */
+  async applyPenalty(input: any): Promise<void> {
+    await this.penaltyService.applyPenalty(input);
+  }
+}

apps/website/lib/services/leagues/LeagueWalletService.ts

@@ -0,0 +1,71 @@
+import { WalletsApiClient, LeagueWalletDTO, WithdrawRequestDTO, WithdrawResponseDTO } from '@/lib/api/wallets/WalletsApiClient';
+import { LeagueWalletViewModel } from '@/lib/view-models/LeagueWalletViewModel';
+import { WalletTransactionViewModel } from '@/lib/view-models/WalletTransactionViewModel';
+import { SubmitBlocker, ThrottleBlocker } from '@/lib/blockers';
+
+/**
+ * League Wallet Service
+ *
+ * Orchestrates league wallet operations by coordinating API calls and view model creation.
+ * All dependencies are injected via constructor.
+ */
+export class LeagueWalletService {
+  private readonly submitBlocker = new SubmitBlocker();
+  private readonly throttle = new ThrottleBlocker(500);
+
+  constructor(
+    private readonly apiClient: WalletsApiClient
+  ) {}
+
+  /**
+   * Get wallet for a league
+   */
+  async getWalletForLeague(leagueId: string): Promise<LeagueWalletViewModel> {
+    const dto = await this.apiClient.getLeagueWallet(leagueId);
+    const transactions = dto.transactions.map(t => new WalletTransactionViewModel({
+      id: t.id,
+      type: t.type,
+      description: t.description,
+      amount: t.amount,
+      fee: t.fee,
+      netAmount: t.netAmount,
+      date: new Date(t.date),
+      status: t.status,
+      reference: t.reference,
+    }));
+    return new LeagueWalletViewModel({
+      balance: dto.balance,
+      currency: dto.currency,
+      totalRevenue: dto.totalRevenue,
+      totalFees: dto.totalFees,
+      totalWithdrawals: dto.totalWithdrawals,
+      pendingPayouts: dto.pendingPayouts,
+      transactions,
+      canWithdraw: dto.canWithdraw,
+      withdrawalBlockReason: dto.withdrawalBlockReason,
+    });
+  }
+
+  /**
+   * Withdraw from league wallet
+   */
+  async withdraw(leagueId: string, amount: number, currency: string, seasonId: string, destinationAccount: string): Promise<WithdrawResponseDTO> {
+    if (!this.submitBlocker.canExecute() || !this.throttle.canExecute()) {
+      throw new Error('Request blocked due to rate limiting');
+    }
+
+    this.submitBlocker.block();
+    this.throttle.block();
+    try {
+      const request: WithdrawRequestDTO = {
+        amount,
+        currency,
+        seasonId,
+        destinationAccount,
+      };
+      return await this.apiClient.withdrawFromLeagueWallet(leagueId, request);
+    } finally {
+      this.submitBlocker.release();
+    }
+  }
+}

apps/website/lib/services/races/RaceService.ts

@@ -43,7 +43,16 @@ export class RaceService {
    */
   async getRacesPageData(): Promise<RacesPageViewModel> {
     const dto = await this.apiClient.getPageData();
-    return new RacesPageViewModel(this.transformRacesPageData(dto));
+    return new RacesPageViewModel(dto);
+  }
+
+  /**
+   * Get all races page data with view model transformation
+   * Currently same as getRacesPageData, but can be extended for different filtering
+   */
+  async getAllRacesPageData(): Promise<RacesPageViewModel> {
+    const dto = await this.apiClient.getPageData();
+    return new RacesPageViewModel(dto);
   }
 
   /**
@@ -82,38 +91,6 @@ export class RaceService {
     await this.apiClient.complete(raceId);
   }
 
-  /**
-    * Transform API races page data to view model format
-    */
-   private transformRacesPageData(dto: RacesPageDataDto): {
-     upcomingRaces: Array<{ id: string; title: string; scheduledTime: string; status: string }>;
-     completedRaces: Array<{ id: string; title: string; scheduledTime: string; status: string }>;
-     totalCount: number;
-   } {
-     const upcomingRaces = dto.races
-       .filter(race => race.status !== 'completed')
-       .map(race => ({
-         id: race.id,
-         title: `${race.track} - ${race.car}`,
-         scheduledTime: race.scheduledAt,
-         status: race.status,
-       }));
-
-     const completedRaces = dto.races
-       .filter(race => race.status === 'completed')
-       .map(race => ({
-         id: race.id,
-         title: `${race.track} - ${race.car}`,
-         scheduledTime: race.scheduledAt,
-         status: race.status,
-       }));
-
-     return {
-       upcomingRaces,
-       completedRaces,
-       totalCount: dto.races.length,
-     };
-   }
 
   /**
    * Find races by league ID

apps/website/lib/services/races/RaceStewardingService.ts

@@ -0,0 +1,36 @@
+import { RacesApiClient } from '../../api/races/RacesApiClient';
+import { ProtestsApiClient } from '../../api/protests/ProtestsApiClient';
+import { PenaltiesApiClient } from '../../api/penalties/PenaltiesApiClient';
+import { RaceStewardingViewModel } from '../../view-models/RaceStewardingViewModel';
+
+/**
+ * Race Stewarding Service
+ *
+ * Orchestrates race stewarding operations by coordinating API calls for race details,
+ * protests, and penalties, and returning a unified view model.
+ */
+export class RaceStewardingService {
+  constructor(
+    private readonly racesApiClient: RacesApiClient,
+    private readonly protestsApiClient: ProtestsApiClient,
+    private readonly penaltiesApiClient: PenaltiesApiClient
+  ) {}
+
+  /**
+   * Get race stewarding data with view model transformation
+   */
+  async getRaceStewardingData(raceId: string, driverId: string): Promise<RaceStewardingViewModel> {
+    // Fetch all data in parallel
+    const [raceDetail, protests, penalties] = await Promise.all([
+      this.racesApiClient.getDetail(raceId, driverId),
+      this.protestsApiClient.getRaceProtests(raceId),
+      this.penaltiesApiClient.getRacePenalties(raceId),
+    ]);
+
+    return new RaceStewardingViewModel({
+      raceDetail,
+      protests,
+      penalties,
+    });
+  }
+}