PM-1099 - implement withdraw payments

Author: vas3a

src/api/api.module.ts

@@ -15,6 +15,7 @@ import { AdminModule } from './admin/admin.module';
 import { WinningsModule } from './winnings/winnings.module';
 import { UserModule } from './user/user.module';
 import { WalletModule } from './wallet/wallet.module';
+import { WithdrawalModule } from './withdrawal/withdrawal.module';
 
 @Module({
   imports: [
@@ -26,6 +27,7 @@ import { WalletModule } from './wallet/wallet.module';
     WinningsModule,
     UserModule,
     WalletModule,
+    WithdrawalModule,
   ],
   controllers: [HealthCheckController],
   providers: [

src/api/repository/paymentMethod.repo.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { payment_method_status } from '@prisma/client';
+import { payment_method_status, user_payment_methods } from '@prisma/client';
 import { PrismaService } from 'src/shared/global/prisma.service';
 
 @Injectable()
@@ -12,7 +12,9 @@ export class PaymentMethodRepository {
    * @param userId user id
    * @param tx transaction
    */
-  async hasVerifiedPaymentMethod(userId: string): Promise<boolean> {
+  async hasVerifiedPaymentMethod(
+    userId: string,
+  ): Promise<user_payment_methods | null> {
     const connectedUserPaymentMethod =
       await this.prisma.user_payment_methods.findFirst({
         where: {
@@ -21,6 +23,6 @@ export class PaymentMethodRepository {
         },
       });
 
-    return !!connectedUserPaymentMethod;
+    return connectedUserPaymentMethod;
   }
 }

src/api/webhooks/trolley/handlers/payment.handler.ts

@@ -1,11 +1,63 @@
 import { Injectable } from '@nestjs/common';
-// import { WebhookEvent } from '../../webhooks.decorators';
+import {
+  PaymentProcessedEventData,
+  PaymentWebhookEvent,
+} from './payment.types';
+import { WebhookEvent } from '../../webhooks.decorators';
+import { PaymentsService } from 'src/shared/payments';
+import { payment_status } from '@prisma/client';
+import { PrismaService } from 'src/shared/global/prisma.service';
 
 @Injectable()
 export class PaymentHandler {
-  // @WebhookEvent(TrolleyWebhookEvent.paymentCreated)
-  // async handlePaymentCreated(payload: any): Promise<any> {
-  //   // TODO: Build out logic for payment.created event
-  //   console.log('handling', TrolleyWebhookEvent.paymentCreated);
-  // }
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly paymentsService: PaymentsService,
+  ) {}
+
+  @WebhookEvent(
+    PaymentWebhookEvent.processed,
+    PaymentWebhookEvent.failed,
+    PaymentWebhookEvent.returned,
+  )
+  async handlePaymentProcessed(
+    payload: PaymentProcessedEventData,
+  ): Promise<any> {
+    // TODO: remove slice-1
+    const winningIds = (payload.externalId ?? '').split(',').slice(0, -1);
+
+    if (!winningIds.length) {
+      console.error(
+        `No matching payments in our db to process for incoming payment.processed with memo '${payload.memo}'.`,
+      );
+    }
+
+    if (payload.status !== 'processed') {
+      await this.prisma.$transaction(async (tx) => {
+        await this.paymentsService.updatePaymentProcessingState(
+          winningIds,
+          payment_status.PROCESSING,
+          tx,
+        );
+
+        await this.paymentsService.updatePaymentReleaseState(
+          payload.id,
+          'FAILED',
+        );
+      });
+    }
+
+    await this.prisma.$transaction(async (tx) => {
+      await this.paymentsService.updatePaymentProcessingState(
+        winningIds,
+        payment_status.PAID,
+        tx,
+      );
+
+      await this.paymentsService.updatePaymentReleaseState(
+        payload.id,
+        'PROCESSED',
+      );
+    });
+  }
 }

src/api/webhooks/trolley/handlers/payment.types.ts

@@ -0,0 +1,21 @@
+export enum PaymentWebhookEvent {
+  processed = 'payment.processed',
+  failed = 'payment.failed',
+  returned = 'payment.returned',
+}
+
+export interface PaymentProcessedEventData {
+  id: string;
+  recipient: {
+    id: string;
+    referenceId: string;
+    email: string;
+  };
+  status: 'processed' | 'failed' | 'returned';
+  externalId?: string;
+  sourceAmount: string; // gross amount
+  fees: string;
+  targetAmount: string; // net amount
+  failureMessage: string | null;
+  memo: string | null;
+}

src/api/withdrawal/dto/withdraw.dto.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayNotEmpty, IsArray, IsNotEmpty, IsString } from 'class-validator';
+
+export class WithdrawRequestDto {
+  @ApiProperty({
+    description: 'The ID of the winnings to withdraw',
+    example: ['3fa85f64-5717-4562-b3fc-2c963f66afa6'],
+  })
+  @IsArray()
+  @ArrayNotEmpty()
+  @IsString({ each: true })
+  @IsNotEmpty({ each: true })
+  paymentIds: string[];
+}

src/api/withdrawal/withdrawal.controller.ts

@@ -0,0 +1,65 @@
+import {
+  Controller,
+  Post,
+  HttpCode,
+  HttpStatus,
+  Body,
+  BadRequestException,
+} from '@nestjs/common';
+import {
+  ApiOperation,
+  ApiTags,
+  ApiResponse,
+  ApiBearerAuth,
+  ApiBody,
+} from '@nestjs/swagger';
+
+import { Role } from 'src/core/auth/auth.constants';
+import { Roles, User } from 'src/core/auth/decorators';
+import { UserInfo } from 'src/dto/user.type';
+import { ResponseDto, ResponseStatusType } from 'src/dto/api-response.dto';
+
+import { WithdrawalService } from './withdrawal.service';
+import { WithdrawRequestDto } from './dto/withdraw.dto';
+
+@ApiTags('Withdrawal')
+@Controller('/withdraw')
+@ApiBearerAuth()
+export class WithdrawalController {
+  constructor(private readonly withdrawalService: WithdrawalService) {}
+
+  @Post()
+  @Roles(Role.User)
+  @ApiOperation({
+    summary: 'User call this operation to process withdrawal.',
+    description: 'jwt required.',
+  })
+  @ApiBody({
+    description: 'Request body',
+    type: WithdrawRequestDto,
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Get wallet detail successfully.',
+    type: ResponseDto<string>,
+  })
+  @HttpCode(HttpStatus.OK)
+  async doWithdraw(
+    @User() user: UserInfo,
+    @Body() body: WithdrawRequestDto,
+  ): Promise<ResponseDto<string>> {
+    const result = new ResponseDto<string>();
+
+    try {
+      await this.withdrawalService.withdraw(
+        user.id,
+        user.handle,
+        body.paymentIds,
+      );
+      result.status = ResponseStatusType.SUCCESS;
+      return result;
+    } catch (e) {
+      throw new BadRequestException(e.message);
+    }
+  }
+}

src/api/withdrawal/withdrawal.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { PaymentsModule } from 'src/shared/payments';
+import { WithdrawalController } from './withdrawal.controller';
+import { WithdrawalService } from './withdrawal.service';
+import { TaxFormRepository } from '../repository/taxForm.repo';
+import { PaymentMethodRepository } from '../repository/paymentMethod.repo';
+
+@Module({
+  imports: [PaymentsModule],
+  controllers: [WithdrawalController],
+  providers: [WithdrawalService, TaxFormRepository, PaymentMethodRepository],
+})
+export class WithdrawalModule {}