rename to core

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

@@ -0,0 +1,161 @@
+/**
+ * Application Use Case: GetEntitySponsorshipPricingUseCase
+ *
+ * Retrieves sponsorship pricing configuration for any entity.
+ * Used by sponsors to see available slots and prices.
+ */
+
+import type { ISponsorshipPricingRepository } from '../../domain/repositories/ISponsorshipPricingRepository';
+import type { ISponsorshipRequestRepository } from '../../domain/repositories/ISponsorshipRequestRepository';
+import type { ISeasonSponsorshipRepository } from '../../domain/repositories/ISeasonSponsorshipRepository';
+import type { SponsorableEntityType } from '../../domain/entities/SponsorshipRequest';
+import type { SponsorshipTier } from '../../domain/entities/SeasonSponsorship';
+import type { IEntitySponsorshipPricingPresenter } from '../presenters/IEntitySponsorshipPricingPresenter';
+import type { AsyncUseCase } from '@gridpilot/shared/application';
+import type { ILogger } from '../../../shared/src/logging/ILogger';
+
+export interface GetEntitySponsorshipPricingDTO {
+  entityType: SponsorableEntityType;
+  entityId: string;
+}
+
+export interface SponsorshipSlotDTO {
+  tier: SponsorshipTier;
+  price: number;
+  currency: string;
+  formattedPrice: string;
+  benefits: string[];
+  available: boolean;
+  maxSlots: number;
+  filledSlots: number;
+  pendingRequests: number;
+}
+
+export interface GetEntitySponsorshipPricingResultDTO {
+  entityType: SponsorableEntityType;
+  entityId: string;
+  acceptingApplications: boolean;
+  customRequirements?: string;
+  mainSlot?: SponsorshipSlotDTO;
+  secondarySlot?: SponsorshipSlotDTO;
+}
+
+export class GetEntitySponsorshipPricingUseCase
+  implements AsyncUseCase<GetEntitySponsorshipPricingDTO, void> {
+  constructor(
+    private readonly sponsorshipPricingRepo: ISponsorshipPricingRepository,
+    private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
+    private readonly seasonSponsorshipRepo: ISeasonSponsorshipRepository,
+    private readonly presenter: IEntitySponsorshipPricingPresenter,
+    private readonly logger: ILogger,
+  ) {}
+
+  async execute(dto: GetEntitySponsorshipPricingDTO): Promise<void> {
+    this.logger.debug(
+      `Executing GetEntitySponsorshipPricingUseCase for entityType: ${dto.entityType}, entityId: ${dto.entityId}`,
+      { dto },
+    );
+
+    try {
+      const pricing = await this.sponsorshipPricingRepo.findByEntity(dto.entityType, dto.entityId);
+
+      if (!pricing) {
+        this.logger.warn(
+          `No pricing found for entityType: ${dto.entityType}, entityId: ${dto.entityId}. Presenting null.`,
+          { dto },
+        );
+        this.presenter.present(null);
+        return;
+      }
+
+      this.logger.debug(`Found pricing for entityType: ${dto.entityType}, entityId: ${dto.entityId}`, { pricing });
+
+      // Count pending requests by tier
+      const pendingRequests = await this.sponsorshipRequestRepo.findPendingByEntity(
+        dto.entityType,
+        dto.entityId,
+      );
+      const pendingMainCount = pendingRequests.filter(r => r.tier === 'main').length;
+      const pendingSecondaryCount = pendingRequests.filter(r => r.tier === 'secondary').length;
+
+      this.logger.debug(
+        `Pending requests counts: main=${pendingMainCount}, secondary=${pendingSecondaryCount}`,
+      );
+
+      // Count filled slots (for seasons, check SeasonSponsorship table)
+      let filledMainSlots = 0;
+      let filledSecondarySlots = 0;
+
+      if (dto.entityType === 'season') {
+        const sponsorships = await this.seasonSponsorshipRepo.findBySeasonId(dto.entityId);
+        const activeSponsorships = sponsorships.filter(s => s.isActive());
+        filledMainSlots = activeSponsorships.filter(s => s.tier === 'main').length;
+        filledSecondarySlots = activeSponsorships.filter(s => s.tier === 'secondary').length;
+        this.logger.debug(
+          `Filled slots for season: main=${filledMainSlots}, secondary=${filledSecondarySlots}`,
+        );
+      }
+
+      const result: GetEntitySponsorshipPricingResultDTO = {
+        entityType: dto.entityType,
+        entityId: dto.entityId,
+        acceptingApplications: pricing.acceptingApplications,
+        ...(pricing.customRequirements !== undefined
+          ? { customRequirements: pricing.customRequirements }
+          : {}),
+      };
+
+      if (pricing.mainSlot) {
+        const mainMaxSlots = pricing.mainSlot.maxSlots;
+        result.mainSlot = {
+          tier: 'main',
+          price: pricing.mainSlot.price.amount,
+          currency: pricing.mainSlot.price.currency,
+          formattedPrice: pricing.mainSlot.price.format(),
+          benefits: pricing.mainSlot.benefits,
+          available: pricing.mainSlot.available && filledMainSlots < mainMaxSlots,
+          maxSlots: mainMaxSlots,
+          filledSlots: filledMainSlots,
+          pendingRequests: pendingMainCount,
+        };
+        this.logger.debug(`Main slot pricing information processed`, { mainSlot: result.mainSlot });
+      }
+
+      if (pricing.secondarySlots) {
+        const secondaryMaxSlots = pricing.secondarySlots.maxSlots;
+        result.secondarySlot = {
+          tier: 'secondary',
+          price: pricing.secondarySlots.price.amount,
+          currency: pricing.secondarySlots.price.currency,
+          formattedPrice: pricing.secondarySlots.price.format(),
+          benefits: pricing.secondarySlots.benefits,
+          available:
+            pricing.secondarySlots.available && filledSecondarySlots < secondaryMaxSlots,
+          maxSlots: secondaryMaxSlots,
+          filledSlots: filledSecondarySlots,
+          pendingRequests: pendingSecondaryCount,
+        };
+        this.logger.debug(`Secondary slot pricing information processed`, {
+          secondarySlot: result.secondarySlot,
+        });
+      }
+
+      this.logger.info(
+        `Successfully retrieved and processed entity sponsorship pricing for entityType: ${dto.entityType}, entityId: ${dto.entityId}`,
+        { result },
+      );
+      this.presenter.present(result);
+    } catch (error: unknown) {
+      let errorMessage = 'An unknown error occurred';
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      }
+      this.logger.error(
+        `Failed to get entity sponsorship pricing for entityType: ${dto.entityType}, entityId: ${dto.entityId}. Error: ${errorMessage}`,
+        { error, dto },
+      );
+      // Re-throw the error or present an error state if the presenter supports it
+      throw error;
+    }
+  }
+}