rename to core

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

@@ -0,0 +1,104 @@
+/**
+ * Use Case: AcceptSponsorshipRequestUseCase
+ * 
+ * Allows an entity owner to accept a sponsorship request.
+ * This creates an active sponsorship and notifies the sponsor.
+ */
+
+import type { ILogger } from '../../../shared/src/logging/ILogger';
+import type { ISponsorshipRequestRepository } from '../../domain/repositories/ISponsorshipRequestRepository';
+import type { ISeasonSponsorshipRepository } from '../../domain/repositories/ISeasonSponsorshipRepository';
+import type { ISeasonRepository } from '../../domain/repositories/ISeasonRepository';
+import { SeasonSponsorship } from '../../domain/entities/SeasonSponsorship';
+import type { AsyncUseCase } from '@gridpilot/shared/application';
+
+export interface AcceptSponsorshipRequestDTO {
+  requestId: string;
+  respondedBy: string; // driverId of the person accepting
+}
+
+export interface AcceptSponsorshipRequestResultDTO {
+  requestId: string;
+  sponsorshipId: string;
+  status: 'accepted';
+  acceptedAt: Date;
+  platformFee: number;
+  netAmount: number;
+}
+
+export class AcceptSponsorshipRequestUseCase
+  implements AsyncUseCase<AcceptSponsorshipRequestDTO, AcceptSponsorshipRequestResultDTO> {
+  constructor(
+    private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
+    private readonly seasonSponsorshipRepo: ISeasonSponsorshipRepository,
+    private readonly seasonRepository: ISeasonRepository,
+    private readonly logger: ILogger,
+  ) {}
+
+  async execute(dto: AcceptSponsorshipRequestDTO): Promise<AcceptSponsorshipRequestResultDTO> {
+    this.logger.debug(`Attempting to accept sponsorship request: ${dto.requestId}`, { requestId: dto.requestId, respondedBy: dto.respondedBy });
+    try {
+      // Find the request
+      const request = await this.sponsorshipRequestRepo.findById(dto.requestId);
+      if (!request) {
+        this.logger.warn(`Sponsorship request not found: ${dto.requestId}`, { requestId: dto.requestId });
+        throw new Error('Sponsorship request not found');
+      }
+
+      if (!request.isPending()) {
+        this.logger.warn(`Cannot accept a ${request.status} sponsorship request: ${dto.requestId}`, { requestId: dto.requestId, status: request.status });
+        throw new Error(`Cannot accept a ${request.status} sponsorship request`);
+      }
+
+      this.logger.info(`Sponsorship request ${dto.requestId} found and is pending. Proceeding with acceptance.`, { requestId: dto.requestId });
+
+      // Accept the request
+      const acceptedRequest = request.accept(dto.respondedBy);
+      await this.sponsorshipRequestRepo.update(acceptedRequest);
+      this.logger.debug(`Sponsorship request ${dto.requestId} accepted and updated in repository.`, { requestId: dto.requestId });
+
+      // If this is a season sponsorship, create the SeasonSponsorship record
+      let sponsorshipId = `spons_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      
+      if (request.entityType === 'season') {
+        this.logger.debug(`Sponsorship request ${dto.requestId} is for a season. Creating SeasonSponsorship record.`, { requestId: dto.requestId, entityType: request.entityType });
+        const season = await this.seasonRepository.findById(request.entityId);
+        if (!season) {
+          this.logger.warn(`Season not found for sponsorship request ${dto.requestId} and entityId ${request.entityId}`, { requestId: dto.requestId, entityId: request.entityId });
+          throw new Error('Season not found for sponsorship request');
+        }
+
+        const sponsorship = SeasonSponsorship.create({
+          id: sponsorshipId,
+          seasonId: season.id,
+          leagueId: season.leagueId,
+          sponsorId: request.sponsorId,
+          tier: request.tier,
+          pricing: request.offeredAmount,
+          status: 'active',
+        });
+        await this.seasonSponsorshipRepo.create(sponsorship);
+        this.logger.info(`Season sponsorship ${sponsorshipId} created for request ${dto.requestId}.`, { sponsorshipId, requestId: dto.requestId });
+      }
+
+      // TODO: In a real implementation, we would:
+      // 1. Create notification for the sponsor
+      // 2. Process payment
+      // 3. Update wallet balances
+
+      this.logger.info(`Sponsorship request ${acceptedRequest.id} successfully accepted.`, { requestId: acceptedRequest.id, sponsorshipId });
+
+      return {
+        requestId: acceptedRequest.id,
+        sponsorshipId,
+        status: 'accepted',
+        acceptedAt: acceptedRequest.respondedAt!,
+        platformFee: acceptedRequest.getPlatformFee().amount,
+        netAmount: acceptedRequest.getNetAmount().amount,
+      };
+    } catch (error: any) {
+      this.logger.error(`Failed to accept sponsorship request ${dto.requestId}: ${error.message}`, { requestId: dto.requestId, error: error.message, stack: error.stack });
+      throw error;
+    }
+  }
+}