view models

apps/website/lib/services/payments/PaymentService.ts

@@ -1,10 +1,10 @@
 import type { PaymentsApiClient } from '../../api/payments/PaymentsApiClient';
-import type { PaymentListPresenter } from '../../presenters/PaymentListPresenter';
-import type {
-  CreatePaymentInputDto,
-  CreatePaymentOutputDto,
-} from '../../dtos';
-import type {
+import type { PaymentDto, MembershipFeeDto, PrizeDto } from '../../types/generated';
+
+// TODO: Move these types to apps/website/lib/types/generated when available
+type CreatePaymentInputDto = { amount: number; leagueId: string; driverId: string; description: string };
+type CreatePaymentOutputDto = { id: string; success: boolean };
+import {
   PaymentViewModel,
   MembershipFeeViewModel,
   PrizeViewModel,
@@ -14,114 +14,77 @@ import type {
 /**
  * Payment Service
  *
- * Orchestrates payment operations by coordinating API calls and presentation logic.
+ * Orchestrates payment operations by coordinating API calls and view model creation.
  * All dependencies are injected via constructor.
  */
 export class PaymentService {
   constructor(
-    private readonly apiClient: PaymentsApiClient,
-    private readonly paymentListPresenter: PaymentListPresenter,
-    private readonly presentPayment: (dto: any) => PaymentViewModel,
-    private readonly presentMembershipFee: (dto: any) => MembershipFeeViewModel,
-    private readonly presentPrize: (dto: any) => PrizeViewModel,
-    private readonly presentWallet: (dto: any) => WalletViewModel
+    private readonly apiClient: PaymentsApiClient
   ) {}
 
   /**
    * Get all payments with optional filters
    */
   async getPayments(leagueId?: string, driverId?: string): Promise<PaymentViewModel[]> {
-    try {
-      const dto = await this.apiClient.getPayments(leagueId, driverId);
-      return this.paymentListPresenter.present(dto);
-    } catch (error) {
-      throw error;
-    }
+    const dto = await this.apiClient.getPayments(leagueId, driverId);
+    return dto.payments.map((payment: PaymentDto) => new PaymentViewModel(payment));
   }
 
   /**
    * Get single payment by ID
    */
   async getPayment(paymentId: string): Promise<PaymentViewModel> {
-    try {
-      // Note: Assuming the API returns a single payment from the list
-      const dto = await this.apiClient.getPayments();
-      const payment = dto.payments.find(p => p.id === paymentId);
-      if (!payment) {
-        throw new Error(`Payment with ID ${paymentId} not found`);
-      }
-      return this.presentPayment(payment);
-    } catch (error) {
-      throw error;
+    // Note: Assuming the API returns a single payment from the list
+    const dto = await this.apiClient.getPayments();
+    const payment = dto.payments.find((p: PaymentDto) => p.id === paymentId);
+    if (!payment) {
+      throw new Error(`Payment with ID ${paymentId} not found`);
     }
+    return new PaymentViewModel(payment);
   }
 
   /**
    * Create a new payment
    */
   async createPayment(input: CreatePaymentInputDto): Promise<CreatePaymentOutputDto> {
-    try {
-      return await this.apiClient.createPayment(input);
-    } catch (error) {
-      throw error;
-    }
+    return await this.apiClient.createPayment(input);
   }
 
   /**
    * Get membership fees for a league
    */
   async getMembershipFees(leagueId: string): Promise<MembershipFeeViewModel[]> {
-    try {
-      const dto = await this.apiClient.getMembershipFees(leagueId);
-      return dto.fees.map(fee => this.presentMembershipFee(fee));
-    } catch (error) {
-      throw error;
-    }
+    const dto = await this.apiClient.getMembershipFees(leagueId);
+    return dto.fees.map((fee: MembershipFeeDto) => new MembershipFeeViewModel(fee));
   }
 
   /**
    * Get prizes with optional filters
    */
   async getPrizes(leagueId?: string, seasonId?: string): Promise<PrizeViewModel[]> {
-    try {
-      const dto = await this.apiClient.getPrizes(leagueId, seasonId);
-      return dto.prizes.map(prize => this.presentPrize(prize));
-    } catch (error) {
-      throw error;
-    }
+    const dto = await this.apiClient.getPrizes(leagueId, seasonId);
+    return dto.prizes.map((prize: PrizeDto) => new PrizeViewModel(prize));
   }
 
   /**
    * Get wallet for a driver
    */
   async getWallet(driverId: string): Promise<WalletViewModel> {
-    try {
-      const dto = await this.apiClient.getWallet(driverId);
-      return this.presentWallet(dto);
-    } catch (error) {
-      throw error;
-    }
+    const dto = await this.apiClient.getWallet(driverId);
+    return new WalletViewModel(dto);
   }
 
   /**
    * Process a payment (alias for createPayment)
    */
   async processPayment(input: CreatePaymentInputDto): Promise<CreatePaymentOutputDto> {
-    try {
-      return await this.createPayment(input);
-    } catch (error) {
-      throw error;
-    }
+    return await this.createPayment(input);
   }
 
   /**
    * Get payment history for a user (driver)
    */
   async getPaymentHistory(driverId: string): Promise<PaymentViewModel[]> {
-    try {
-      return await this.getPayments(undefined, driverId);
-    } catch (error) {
-      throw error;
-    }
+    return await this.getPayments(undefined, driverId);
   }
 }