105 lines
4.7 KiB
TypeScript
105 lines
4.7 KiB
TypeScript
/**
|
|
* 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;
|
|
}
|
|
}
|
|
}
|