mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor

Browse Source
This commit is contained in:
Marc Mintel
2025-12-21 22:35:38 +01:00
parent 3c64f328e2
commit 9bd2e630e6
38 changed files with 736 additions and 684 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
apps/api/src/domain/payments/PaymentsController.ts
View File

@@ -12,8 +12,7 @@ export class PaymentsController {
@ApiOperation({ summary: 'Get payments based on filters' })
@ApiResponse({ status: 200, description: 'List of payments', type: GetPaymentsOutput })
async getPayments(@Query() query: GetPaymentsQuery): Promise<GetPaymentsOutput> {
const presenter = await this.paymentsService.getPayments(query);
return presenter.viewModel;
return this.paymentsService.getPayments(query);
}
@Post()
@@ -21,16 +20,14 @@ export class PaymentsController {
@ApiOperation({ summary: 'Create a new payment' })
@ApiResponse({ status: 201, description: 'Payment created', type: CreatePaymentOutput })
async createPayment(@Body() input: CreatePaymentInput): Promise<CreatePaymentOutput> {
const presenter = await this.paymentsService.createPayment(input);
return presenter.viewModel;
return this.paymentsService.createPayment(input);
}
@Patch('status')
@ApiOperation({ summary: 'Update the status of a payment' })
@ApiResponse({ status: 200, description: 'Payment status updated', type: UpdatePaymentStatusOutput })
async updatePaymentStatus(@Body() input: UpdatePaymentStatusInput): Promise<UpdatePaymentStatusOutput> {
const presenter = await this.paymentsService.updatePaymentStatus(input);
return presenter.viewModel;
return this.paymentsService.updatePaymentStatus(input);
}
@Get('membership-fees')

150
apps/api/src/domain/payments/PaymentsProviders.ts
View File

@@ -6,7 +6,7 @@ import type { IPaymentRepository } from '@core/payments/domain/repositories/IPay
import type { IMembershipFeeRepository, IMemberPaymentRepository } from '@core/payments/domain/repositories/IMembershipFeeRepository';
import type { IPrizeRepository } from '@core/payments/domain/repositories/IPrizeRepository';
import type { IWalletRepository, ITransactionRepository } from '@core/payments/domain/repositories/IWalletRepository';
import type { Logger } from '@core/shared/application/Logger';
import type { Logger, UseCaseOutputPort } from '@core/shared/application';
// Import use cases
import { GetPaymentsUseCase } from '@core/payments/application/use-cases/GetPaymentsUseCase';
@@ -29,6 +29,20 @@ import { InMemoryPrizeRepository } from '@adapters/payments/persistence/inmemory
import { InMemoryWalletRepository, InMemoryTransactionRepository } from '@adapters/payments/persistence/inmemory/InMemoryWalletRepository';
import { ConsoleLogger } from '@adapters/logging/ConsoleLogger';
// Presenters
import { GetPaymentsPresenter } from './presenters/GetPaymentsPresenter';
import { CreatePaymentPresenter } from './presenters/CreatePaymentPresenter';
import { UpdatePaymentStatusPresenter } from './presenters/UpdatePaymentStatusPresenter';
import { GetMembershipFeesPresenter } from './presenters/GetMembershipFeesPresenter';
import { UpsertMembershipFeePresenter } from './presenters/UpsertMembershipFeePresenter';
import { UpdateMemberPaymentPresenter } from './presenters/UpdateMemberPaymentPresenter';
import { GetPrizesPresenter } from './presenters/GetPrizesPresenter';
import { CreatePrizePresenter } from './presenters/CreatePrizePresenter';
import { AwardPrizePresenter } from './presenters/AwardPrizePresenter';
import { DeletePrizePresenter } from './presenters/DeletePrizePresenter';
import { GetWalletPresenter } from './presenters/GetWalletPresenter';
import { ProcessWalletTransactionPresenter } from './presenters/ProcessWalletTransactionPresenter';
// Repository injection tokens
export const PAYMENT_REPOSITORY_TOKEN = 'IPaymentRepository';
export const MEMBERSHIP_FEE_REPOSITORY_TOKEN = 'IMembershipFeeRepository';
@@ -52,9 +66,87 @@ export const DELETE_PRIZE_USE_CASE_TOKEN = 'DeletePrizeUseCase';
export const GET_WALLET_USE_CASE_TOKEN = 'GetWalletUseCase';
export const PROCESS_WALLET_TRANSACTION_USE_CASE_TOKEN = 'ProcessWalletTransactionUseCase';
// Output port tokens
export const GET_PAYMENTS_OUTPUT_PORT_TOKEN = 'GetPaymentsOutputPort_TOKEN';
export const CREATE_PAYMENT_OUTPUT_PORT_TOKEN = 'CreatePaymentOutputPort_TOKEN';
export const UPDATE_PAYMENT_STATUS_OUTPUT_PORT_TOKEN = 'UpdatePaymentStatusOutputPort_TOKEN';
export const GET_MEMBERSHIP_FEES_OUTPUT_PORT_TOKEN = 'GetMembershipFeesOutputPort_TOKEN';
export const UPSERT_MEMBERSHIP_FEE_OUTPUT_PORT_TOKEN = 'UpsertMembershipFeeOutputPort_TOKEN';
export const UPDATE_MEMBER_PAYMENT_OUTPUT_PORT_TOKEN = 'UpdateMemberPaymentOutputPort_TOKEN';
export const GET_PRIZES_OUTPUT_PORT_TOKEN = 'GetPrizesOutputPort_TOKEN';
export const CREATE_PRIZE_OUTPUT_PORT_TOKEN = 'CreatePrizeOutputPort_TOKEN';
export const AWARD_PRIZE_OUTPUT_PORT_TOKEN = 'AwardPrizeOutputPort_TOKEN';
export const DELETE_PRIZE_OUTPUT_PORT_TOKEN = 'DeletePrizeOutputPort_TOKEN';
export const GET_WALLET_OUTPUT_PORT_TOKEN = 'GetWalletOutputPort_TOKEN';
export const PROCESS_WALLET_TRANSACTION_OUTPUT_PORT_TOKEN = 'ProcessWalletTransactionOutputPort_TOKEN';
export const PaymentsProviders: Provider[] = [
PaymentsService,
// Presenters
GetPaymentsPresenter,
CreatePaymentPresenter,
UpdatePaymentStatusPresenter,
GetMembershipFeesPresenter,
UpsertMembershipFeePresenter,
UpdateMemberPaymentPresenter,
GetPrizesPresenter,
CreatePrizePresenter,
AwardPrizePresenter,
DeletePrizePresenter,
GetWalletPresenter,
ProcessWalletTransactionPresenter,
// Output ports
{
provide: GET_PAYMENTS_OUTPUT_PORT_TOKEN,
useExisting: GetPaymentsPresenter,
},
{
provide: CREATE_PAYMENT_OUTPUT_PORT_TOKEN,
useExisting: CreatePaymentPresenter,
},
{
provide: UPDATE_PAYMENT_STATUS_OUTPUT_PORT_TOKEN,
useExisting: UpdatePaymentStatusPresenter,
},
{
provide: GET_MEMBERSHIP_FEES_OUTPUT_PORT_TOKEN,
useExisting: GetMembershipFeesPresenter,
},
{
provide: UPSERT_MEMBERSHIP_FEE_OUTPUT_PORT_TOKEN,
useExisting: UpsertMembershipFeePresenter,
},
{
provide: UPDATE_MEMBER_PAYMENT_OUTPUT_PORT_TOKEN,
useExisting: UpdateMemberPaymentPresenter,
},
{
provide: GET_PRIZES_OUTPUT_PORT_TOKEN,
useExisting: GetPrizesPresenter,
},
{
provide: CREATE_PRIZE_OUTPUT_PORT_TOKEN,
useExisting: CreatePrizePresenter,
},
{
provide: AWARD_PRIZE_OUTPUT_PORT_TOKEN,
useExisting: AwardPrizePresenter,
},
{
provide: DELETE_PRIZE_OUTPUT_PORT_TOKEN,
useExisting: DeletePrizePresenter,
},
{
provide: GET_WALLET_OUTPUT_PORT_TOKEN,
useExisting: GetWalletPresenter,
},
{
provide: PROCESS_WALLET_TRANSACTION_OUTPUT_PORT_TOKEN,
useExisting: ProcessWalletTransactionPresenter,
},
// Logger
{
provide: LOGGER_TOKEN,
@@ -96,66 +188,66 @@ export const PaymentsProviders: Provider[] = [
// Use cases (use cases receive repositories, services receive use cases)
{
provide: GET_PAYMENTS_USE_CASE_TOKEN,
useFactory: (paymentRepo: IPaymentRepository) => new GetPaymentsUseCase(paymentRepo),
inject: [PAYMENT_REPOSITORY_TOKEN],
useFactory: (paymentRepo: IPaymentRepository, output: UseCaseOutputPort<any>) => new GetPaymentsUseCase(paymentRepo, output),
inject: [PAYMENT_REPOSITORY_TOKEN, GET_PAYMENTS_OUTPUT_PORT_TOKEN],
},
{
provide: CREATE_PAYMENT_USE_CASE_TOKEN,
useFactory: (paymentRepo: IPaymentRepository) => new CreatePaymentUseCase(paymentRepo),
inject: [PAYMENT_REPOSITORY_TOKEN],
useFactory: (paymentRepo: IPaymentRepository, output: UseCaseOutputPort<any>) => new CreatePaymentUseCase(paymentRepo, output),
inject: [PAYMENT_REPOSITORY_TOKEN, CREATE_PAYMENT_OUTPUT_PORT_TOKEN],
},
{
provide: UPDATE_PAYMENT_STATUS_USE_CASE_TOKEN,
useFactory: (paymentRepo: IPaymentRepository) => new UpdatePaymentStatusUseCase(paymentRepo),
inject: [PAYMENT_REPOSITORY_TOKEN],
useFactory: (paymentRepo: IPaymentRepository, output: UseCaseOutputPort<any>) => new UpdatePaymentStatusUseCase(paymentRepo, output),
inject: [PAYMENT_REPOSITORY_TOKEN, UPDATE_PAYMENT_STATUS_OUTPUT_PORT_TOKEN],
},
{
provide: GET_MEMBERSHIP_FEES_USE_CASE_TOKEN,
useFactory: (membershipFeeRepo: IMembershipFeeRepository, memberPaymentRepo: IMemberPaymentRepository) =>
new GetMembershipFeesUseCase(membershipFeeRepo, memberPaymentRepo),
inject: [MEMBERSHIP_FEE_REPOSITORY_TOKEN, MEMBER_PAYMENT_REPOSITORY_TOKEN],
useFactory: (membershipFeeRepo: IMembershipFeeRepository, memberPaymentRepo: IMemberPaymentRepository, output: UseCaseOutputPort<any>) =>
new GetMembershipFeesUseCase(membershipFeeRepo, memberPaymentRepo, output),
inject: [MEMBERSHIP_FEE_REPOSITORY_TOKEN, MEMBER_PAYMENT_REPOSITORY_TOKEN, GET_MEMBERSHIP_FEES_OUTPUT_PORT_TOKEN],
},
{
provide: UPSERT_MEMBERSHIP_FEE_USE_CASE_TOKEN,
useFactory: (membershipFeeRepo: IMembershipFeeRepository) => new UpsertMembershipFeeUseCase(membershipFeeRepo),
inject: [MEMBERSHIP_FEE_REPOSITORY_TOKEN],
useFactory: (membershipFeeRepo: IMembershipFeeRepository, output: UseCaseOutputPort<any>) => new UpsertMembershipFeeUseCase(membershipFeeRepo, output),
inject: [MEMBERSHIP_FEE_REPOSITORY_TOKEN, UPSERT_MEMBERSHIP_FEE_OUTPUT_PORT_TOKEN],
},
{
provide: UPDATE_MEMBER_PAYMENT_USE_CASE_TOKEN,
useFactory: (membershipFeeRepo: IMembershipFeeRepository, memberPaymentRepo: IMemberPaymentRepository) =>
new UpdateMemberPaymentUseCase(membershipFeeRepo, memberPaymentRepo),
inject: [MEMBERSHIP_FEE_REPOSITORY_TOKEN, MEMBER_PAYMENT_REPOSITORY_TOKEN],
useFactory: (membershipFeeRepo: IMembershipFeeRepository, memberPaymentRepo: IMemberPaymentRepository, output: UseCaseOutputPort<any>) =>
new UpdateMemberPaymentUseCase(membershipFeeRepo, memberPaymentRepo, output),
inject: [MEMBERSHIP_FEE_REPOSITORY_TOKEN, MEMBER_PAYMENT_REPOSITORY_TOKEN, UPDATE_MEMBER_PAYMENT_OUTPUT_PORT_TOKEN],
},
{
provide: GET_PRIZES_USE_CASE_TOKEN,
useFactory: (prizeRepo: IPrizeRepository) => new GetPrizesUseCase(prizeRepo),
inject: [PRIZE_REPOSITORY_TOKEN],
useFactory: (prizeRepo: IPrizeRepository, output: UseCaseOutputPort<any>) => new GetPrizesUseCase(prizeRepo, output),
inject: [PRIZE_REPOSITORY_TOKEN, GET_PRIZES_OUTPUT_PORT_TOKEN],
},
{
provide: CREATE_PRIZE_USE_CASE_TOKEN,
useFactory: (prizeRepo: IPrizeRepository) => new CreatePrizeUseCase(prizeRepo),
inject: [PRIZE_REPOSITORY_TOKEN],
useFactory: (prizeRepo: IPrizeRepository, output: UseCaseOutputPort<any>) => new CreatePrizeUseCase(prizeRepo, output),
inject: [PRIZE_REPOSITORY_TOKEN, CREATE_PRIZE_OUTPUT_PORT_TOKEN],
},
{
provide: AWARD_PRIZE_USE_CASE_TOKEN,
useFactory: (prizeRepo: IPrizeRepository) => new AwardPrizeUseCase(prizeRepo),
inject: [PRIZE_REPOSITORY_TOKEN],
useFactory: (prizeRepo: IPrizeRepository, output: UseCaseOutputPort<any>) => new AwardPrizeUseCase(prizeRepo, output),
inject: [PRIZE_REPOSITORY_TOKEN, AWARD_PRIZE_OUTPUT_PORT_TOKEN],
},
{
provide: DELETE_PRIZE_USE_CASE_TOKEN,
useFactory: (prizeRepo: IPrizeRepository) => new DeletePrizeUseCase(prizeRepo),
inject: [PRIZE_REPOSITORY_TOKEN],
useFactory: (prizeRepo: IPrizeRepository, output: UseCaseOutputPort<any>) => new DeletePrizeUseCase(prizeRepo, output),
inject: [PRIZE_REPOSITORY_TOKEN, DELETE_PRIZE_OUTPUT_PORT_TOKEN],
},
{
provide: GET_WALLET_USE_CASE_TOKEN,
useFactory: (walletRepo: IWalletRepository, transactionRepo: ITransactionRepository) =>
new GetWalletUseCase(walletRepo, transactionRepo),
inject: [WALLET_REPOSITORY_TOKEN, TRANSACTION_REPOSITORY_TOKEN],
useFactory: (walletRepo: IWalletRepository, transactionRepo: ITransactionRepository, output: UseCaseOutputPort<any>) =>
new GetWalletUseCase(walletRepo, transactionRepo, output),
inject: [WALLET_REPOSITORY_TOKEN, TRANSACTION_REPOSITORY_TOKEN, GET_WALLET_OUTPUT_PORT_TOKEN],
},
{
provide: PROCESS_WALLET_TRANSACTION_USE_CASE_TOKEN,
useFactory: (walletRepo: IWalletRepository, transactionRepo: ITransactionRepository) =>
new ProcessWalletTransactionUseCase(walletRepo, transactionRepo),
inject: [WALLET_REPOSITORY_TOKEN, TRANSACTION_REPOSITORY_TOKEN],
useFactory: (walletRepo: IWalletRepository, transactionRepo: ITransactionRepository, output: UseCaseOutputPort<any>) =>
new ProcessWalletTransactionUseCase(walletRepo, transactionRepo, output),
inject: [WALLET_REPOSITORY_TOKEN, TRANSACTION_REPOSITORY_TOKEN, PROCESS_WALLET_TRANSACTION_OUTPUT_PORT_TOKEN],
},
];

72
apps/api/src/domain/payments/PaymentsService.ts
View File

@@ -90,54 +90,78 @@ export class PaymentsService {
@Inject(GET_WALLET_USE_CASE_TOKEN) private readonly getWalletUseCase: GetWalletUseCase,
@Inject(PROCESS_WALLET_TRANSACTION_USE_CASE_TOKEN) private readonly processWalletTransactionUseCase: ProcessWalletTransactionUseCase,
@Inject(LOGGER_TOKEN) private readonly logger: Logger,
private readonly getPaymentsPresenter: GetPaymentsPresenter,
private readonly createPaymentPresenter: CreatePaymentPresenter,
private readonly updatePaymentStatusPresenter: UpdatePaymentStatusPresenter,
private readonly getMembershipFeesPresenter: GetMembershipFeesPresenter,
private readonly upsertMembershipFeePresenter: UpsertMembershipFeePresenter,
private readonly updateMemberPaymentPresenter: UpdateMemberPaymentPresenter,
private readonly getPrizesPresenter: GetPrizesPresenter,
private readonly createPrizePresenter: CreatePrizePresenter,
private readonly awardPrizePresenter: AwardPrizePresenter,
private readonly deletePrizePresenter: DeletePrizePresenter,
private readonly getWalletPresenter: GetWalletPresenter,
private readonly processWalletTransactionPresenter: ProcessWalletTransactionPresenter,
) {}
async getPayments(query: GetPaymentsQuery): Promise<GetPaymentsPresenter> {
async getPayments(query: GetPaymentsQuery): Promise<GetPaymentsOutput> {
this.logger.debug('[PaymentsService] Getting payments', { query });
const presenter = new GetPaymentsPresenter();
await this.getPaymentsUseCase.execute(query, presenter);
return presenter;
const result = await this.getPaymentsUseCase.execute(query);
if (result.isErr()) {
throw new Error(result.unwrapErr().details?.message ?? 'Failed to get payments');
}
return this.getPaymentsPresenter.getResponseModel();
}
async createPayment(input: CreatePaymentInput): Promise<CreatePaymentPresenter> {
async createPayment(input: CreatePaymentInput): Promise<CreatePaymentOutput> {
this.logger.debug('[PaymentsService] Creating payment', { input });
const presenter = new CreatePaymentPresenter();
await this.createPaymentUseCase.execute(input, presenter);
return presenter;
const result = await this.createPaymentUseCase.execute(input);
if (result.isErr()) {
throw new Error(result.unwrapErr().details?.message ?? 'Failed to create payment');
}
return this.createPaymentPresenter.getResponseModel();
}
async updatePaymentStatus(input: UpdatePaymentStatusInput): Promise<UpdatePaymentStatusPresenter> {
async updatePaymentStatus(input: UpdatePaymentStatusInput): Promise<UpdatePaymentStatusOutput> {
this.logger.debug('[PaymentsService] Updating payment status', { input });
const presenter = new UpdatePaymentStatusPresenter();
await this.updatePaymentStatusUseCase.execute(input, presenter);
return presenter;
const result = await this.updatePaymentStatusUseCase.execute(input);
if (result.isErr()) {
throw new Error(result.unwrapErr().details?.message ?? 'Failed to update payment status');
}
return this.updatePaymentStatusPresenter.getResponseModel();
}
async getMembershipFees(query: GetMembershipFeesQuery): Promise<GetMembershipFeesPresenter> {
async getMembershipFees(query: GetMembershipFeesQuery): Promise<GetMembershipFeesOutput> {
this.logger.debug('[PaymentsService] Getting membership fees', { query });
const presenter = new GetMembershipFeesPresenter();
await this.getMembershipFeesUseCase.execute(query, presenter);
return presenter;
const result = await this.getMembershipFeesUseCase.execute(query);
if (result.isErr()) {
throw new Error(result.unwrapErr().details?.message ?? 'Failed to get membership fees');
}
return this.getMembershipFeesPresenter.getResponseModel();
}
async upsertMembershipFee(input: UpsertMembershipFeeInput): Promise<UpsertMembershipFeePresenter> {
async upsertMembershipFee(input: UpsertMembershipFeeInput): Promise<UpsertMembershipFeeOutput> {
this.logger.debug('[PaymentsService] Upserting membership fee', { input });
const presenter = new UpsertMembershipFeePresenter();
await this.upsertMembershipFeeUseCase.execute(input, presenter);
return presenter;
const result = await this.upsertMembershipFeeUseCase.execute(input);
if (result.isErr()) {
throw new Error(result.unwrapErr().details?.message ?? 'Failed to upsert membership fee');
}
return this.upsertMembershipFeePresenter.getResponseModel();
}
async updateMemberPayment(input: UpdateMemberPaymentInput): Promise<UpdateMemberPaymentPresenter> {
async updateMemberPayment(input: UpdateMemberPaymentInput): Promise<UpdateMemberPaymentOutput> {
this.logger.debug('[PaymentsService] Updating member payment', { input });
const presenter = new UpdateMemberPaymentPresenter();
await this.updateMemberPaymentUseCase.execute(input, presenter);
return presenter;
const result = await this.updateMemberPaymentUseCase.execute(input);
if (result.isErr()) {
throw new Error(result.unwrapErr().details?.message ?? 'Failed to update member payment');
}
return this.updateMemberPaymentPresenter.getResponseModel();
}
async getPrizes(query: GetPrizesQuery): Promise<GetPrizesPresenter> {

37
apps/api/src/domain/payments/presenters/CreatePaymentPresenter.ts
View File

@@ -1,25 +1,34 @@
import type {
ICreatePaymentPresenter,
CreatePaymentResultDTO,
CreatePaymentViewModel,
} from '@core/payments/application/presenters/ICreatePaymentPresenter';
import type { UseCaseOutputPort } from '@core/shared/application';
import type { CreatePaymentResult } from '@core/payments/application/use-cases/CreatePaymentUseCase';
import type { CreatePaymentOutput } from '../dtos/PaymentsDto';
export class CreatePaymentPresenter implements ICreatePaymentPresenter {
private responseModel: CreatePaymentViewModel | null = null;
export class CreatePaymentPresenter implements UseCaseOutputPort<CreatePaymentResult> {
private responseModel: CreatePaymentOutput | null = null;
reset() {
this.responseModel = null;
}
present(dto: CreatePaymentResultDTO) {
this.responseModel = dto;
present(result: CreatePaymentResult): void {
this.responseModel = {
payment: {
id: result.payment.id,
type: result.payment.type,
amount: result.payment.amount,
platformFee: result.payment.platformFee,
netAmount: result.payment.netAmount,
payerId: result.payment.payerId,
payerType: result.payment.payerType,
leagueId: result.payment.leagueId,
...(result.payment.seasonId !== undefined ? { seasonId: result.payment.seasonId } : {}),
status: result.payment.status,
createdAt: result.payment.createdAt,
...(result.payment.completedAt !== undefined ? { completedAt: result.payment.completedAt } : {}),
},
};
}
getResponseModel(): CreatePaymentViewModel | null {
return this.responseModel;
}
get responseModel(): CreatePaymentViewModel {
getResponseModel(): CreatePaymentOutput {
if (!this.responseModel) throw new Error('Presenter not presented');
return this.responseModel;
}

43
apps/api/src/domain/payments/presenters/GetPaymentsPresenter.ts
View File

@@ -1,26 +1,35 @@
import type {
IGetPaymentsPresenter,
GetPaymentsResultDTO,
GetPaymentsViewModel,
} from '@core/payments/application/presenters/IGetPaymentsPresenter';
import type { UseCaseOutputPort } from '@core/shared/application';
import type { GetPaymentsResult } from '@core/payments/application/use-cases/GetPaymentsUseCase';
import type { GetPaymentsOutput } from '../dtos/PaymentsDto';
export class GetPaymentsPresenter implements IGetPaymentsPresenter {
private result: GetPaymentsViewModel | null = null;
export class GetPaymentsPresenter implements UseCaseOutputPort<GetPaymentsResult> {
private responseModel: GetPaymentsOutput | null = null;
reset() {
this.result = null;
this.responseModel = null;
}
present(dto: GetPaymentsResultDTO) {
this.result = dto;
present(result: GetPaymentsResult): void {
this.responseModel = {
payments: result.payments.map(payment => ({
id: payment.id,
type: payment.type,
amount: payment.amount,
platformFee: payment.platformFee,
netAmount: payment.netAmount,
payerId: payment.payerId,
payerType: payment.payerType,
leagueId: payment.leagueId,
...(payment.seasonId !== undefined ? { seasonId: payment.seasonId } : {}),
status: payment.status,
createdAt: payment.createdAt,
...(payment.completedAt !== undefined ? { completedAt: payment.completedAt } : {}),
})),
};
}
getViewModel(): GetPaymentsViewModel | null {
return this.result;
}
get viewModel(): GetPaymentsViewModel {
if (!this.result) throw new Error('Presenter not presented');
return this.result;
getResponseModel(): GetPaymentsOutput {
if (!this.responseModel) throw new Error('Presenter not presented');
return this.responseModel;
}
}

43
apps/api/src/domain/payments/presenters/UpdatePaymentStatusPresenter.ts
View File

@@ -1,26 +1,35 @@
import type {
IUpdatePaymentStatusPresenter,
UpdatePaymentStatusResultDTO,
UpdatePaymentStatusViewModel,
} from '@core/payments/application/presenters/IUpdatePaymentStatusPresenter';
import type { UseCaseOutputPort } from '@core/shared/application';
import type { UpdatePaymentStatusResult } from '@core/payments/application/use-cases/UpdatePaymentStatusUseCase';
import type { UpdatePaymentStatusOutput } from '../dtos/PaymentsDto';
export class UpdatePaymentStatusPresenter implements IUpdatePaymentStatusPresenter {
private result: UpdatePaymentStatusViewModel | null = null;
export class UpdatePaymentStatusPresenter implements UseCaseOutputPort<UpdatePaymentStatusResult> {
private responseModel: UpdatePaymentStatusOutput | null = null;
reset() {
this.result = null;
this.responseModel = null;
}
present(dto: UpdatePaymentStatusResultDTO) {
this.result = dto;
present(result: UpdatePaymentStatusResult): void {
this.responseModel = {
payment: {
id: result.payment.id,
type: result.payment.type,
amount: result.payment.amount,
platformFee: result.payment.platformFee,
netAmount: result.payment.netAmount,
payerId: result.payment.payerId,
payerType: result.payment.payerType,
leagueId: result.payment.leagueId,
...(result.payment.seasonId !== undefined ? { seasonId: result.payment.seasonId } : {}),
status: result.payment.status,
createdAt: result.payment.createdAt,
...(result.payment.completedAt !== undefined ? { completedAt: result.payment.completedAt } : {}),
},
};
}
getViewModel(): UpdatePaymentStatusViewModel | null {
return this.result;
}
get viewModel(): UpdatePaymentStatusViewModel {
if (!this.result) throw new Error('Presenter not presented');
return this.result;
getResponseModel(): UpdatePaymentStatusOutput {
if (!this.responseModel) throw new Error('Presenter not presented');
return this.responseModel;
}
}