Merge pull request #730 from mahajanmahesh935/ReportsFilter

mahajanmahesh935 · web-flow · commit 4fa8268c0b7a · 2026-04-28T16:24:04.000+05:30
TASK #00000 : Add status filter to transaction report API
diff --git a/src/payments/payments.controller.ts b/src/payments/payments.controller.ts
@@ -19,7 +19,6 @@ import {
 import {
   ApiTags,
   ApiOperation,
-  ApiResponse,
   ApiBody,
   ApiCreatedResponse,
   ApiOkResponse,
@@ -42,7 +41,7 @@ import { PaymentReportResponseDto } from './dtos/payment-report.dto';
 @ApiTags('Payments')
 @Controller('payments')
 export class PaymentsController {
-  constructor(private paymentService: PaymentService) {}
+  constructor(private readonly paymentService: PaymentService) {}
 
   @Post('initiate')
   @UseFilters(new AllExceptionsFilter(APIID.PAYMENT_INITIATE))
@@ -193,29 +192,55 @@ export class PaymentsController {
     );
   }
 
-  @Get('report/:contextId')
+  @Post('report/:contextId')
   @UseFilters(new AllExceptionsFilter(APIID.PAYMENT_STATUS))
-  @ApiOperation({ summary: 'Get payment report by contextId with pagination' })
-  @ApiQuery({
-    name: 'limit',
-    required: false,
-    type: Number,
-    description: 'Number of records to return (default: 50, max: 1000)',
-    example: 50,
-  })
-  @ApiQuery({
-    name: 'offset',
-    required: false,
-    type: Number,
-    description: 'Number of records to skip (default: 0)',
-    example: 0,
-  })
-  @ApiQuery({
-    name: 'search',
-    required: false,
-    type: String,
-    description: 'Free text search on firstName, lastName, and email (case-insensitive)',
-    example: 'john',
+  @ApiOperation({ summary: 'Get payment report by contextId with filters and pagination' })
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          example: 50,
+          description: 'Number of records to return (default: 50, max: 1000)',
+        },
+        offset: {
+          type: 'number',
+          example: 0,
+          description: 'Number of records to skip (default: 0)',
+        },
+        search: {
+          type: 'string',
+          example: 'john',
+          description:
+            'Free text search on firstName, lastName, and email (case-insensitive)',
+        },
+        status: {
+          oneOf: [
+            { type: 'string', example: 'SUCCESS,FAILED' },
+            {
+              type: 'array',
+              items: { type: 'string', enum: ['SUCCESS', 'INITIATED', 'FAILED'] },
+              example: ['SUCCESS', 'FAILED'],
+            },
+          ],
+          description:
+            'Filter by transaction status. Accepts SUCCESS, INITIATED, FAILED',
+        },
+        certificateGenerated: {
+          oneOf: [
+            { type: 'boolean', example: true },
+            { type: 'string', example: 'true' },
+          ],
+          description: 'Filter by certificate generation status (true/false)',
+        },
+        couponCode: {
+          type: 'string',
+          example: 'WELCOME10',
+          description: 'Filter by applied coupon code (case-insensitive exact match)',
+        },
+      },
+    },
   })
   @ApiOkResponse({
     description: 'Payment report retrieved successfully',
@@ -224,9 +249,12 @@ export class PaymentsController {
   @ApiBadRequestResponse({ description: 'Invalid pagination parameters' })
   async getPaymentReport(
     @Param('contextId', ParseUUIDPipe) contextId: string,
-    @Query('limit', new DefaultValuePipe(50), ParseIntPipe) limit: number,
-    @Query('offset', new DefaultValuePipe(0), ParseIntPipe) offset: number,
-    @Query('search') search?: string,
+    @Body('limit', new DefaultValuePipe(50), ParseIntPipe) limit: number,
+    @Body('offset', new DefaultValuePipe(0), ParseIntPipe) offset: number,
+    @Body('search') search?: string,
+    @Body('status') status?: string | string[],
+    @Body('certificateGenerated') certificateGenerated?: string | boolean,
+    @Body('couponCode') couponCode?: string,
   ): Promise<PaymentReportResponseDto> {
     // Validate pagination parameters
     if (limit < 1 || limit > 1000) {
@@ -237,12 +265,33 @@ export class PaymentsController {
     }
 
     const searchTerm = typeof search === 'string' ? search.trim() : undefined;
+    const normalizedStatuses = this.normalizeStatuses(status);
+
+    const allowedStatuses = new Set(['SUCCESS', 'INITIATED', 'FAILED']);
+    const invalidStatuses = normalizedStatuses.filter(
+      (value) => !allowedStatuses.has(value),
+    );
+    if (invalidStatuses.length > 0) {
+      throw new BadRequestException(
+        `Invalid status filter(s): ${invalidStatuses.join(', ')}. Allowed values are SUCCESS, INITIATED, FAILED`,
+      );
+    }
+
+    const certificateGeneratedFilter =
+      this.parseBooleanLikeQueryParam(certificateGenerated);
+    const couponCodeFilter =
+      typeof couponCode === 'string' && couponCode.trim().length > 0
+        ? couponCode.trim()
+        : undefined;
 
     const result = await this.paymentService.getPaymentReportByContextId(
       contextId,
       limit,
       offset,
       searchTerm,
+      normalizedStatuses.length > 0 ? normalizedStatuses : undefined,
+      certificateGeneratedFilter,
+      couponCodeFilter,
     );
 
     return {
@@ -253,4 +302,48 @@ export class PaymentsController {
       hasMore: offset + result.data.length < result.totalCount,
     };
   }
+
+  private parseBooleanLikeQueryParam(value?: string | boolean): boolean | undefined {
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value !== 'string') {
+      return undefined;
+    }
+
+    const normalized = value.trim().toLowerCase();
+    if (normalized === '') {
+      return undefined;
+    }
+
+    if (normalized === 'true') {
+      return true;
+    }
+
+    if (normalized === 'false') {
+      return false;
+    }
+
+    throw new BadRequestException(
+      'certificateGenerated must be one of: true, false',
+    );
+  }
+
+  private normalizeStatuses(status?: string | string[]): string[] {
+    if (Array.isArray(status)) {
+      return status
+        .map((value) => value.trim().toUpperCase())
+        .filter((value) => value.length > 0);
+    }
+
+    if (typeof status === 'string') {
+      return status
+        .split(',')
+        .map((value) => value.trim().toUpperCase())
+        .filter((value) => value.length > 0);
+    }
+
+    return [];
+  }
 }
diff --git a/src/payments/services/payment.service.ts b/src/payments/services/payment.service.ts
@@ -7,7 +7,7 @@ import {
   Inject,
 } from '@nestjs/common';
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
-import { DataSource, EntityManager, Repository, In } from 'typeorm';
+import { DataSource, EntityManager, Repository, In, SelectQueryBuilder } from 'typeorm';
 import { PaymentProvider } from '../interfaces/payment-provider.interface';
 import { PaymentIntentService } from './payment-intent.service';
 import { PaymentTransactionService } from './payment-transaction.service';
@@ -596,27 +596,27 @@ export class PaymentService {
     limit: number = 50,
     offset: number = 0,
     search?: string,
+    statusFilters?: string[],
+    certificateGenerated?: boolean,
+    couponCode?: string,
   ): Promise<{ data: PaymentReportItemDto[]; totalCount: number }> {
     const searchTerm =
       typeof search === 'string' && search.trim().length > 0
         ? search.trim().toLowerCase()
         : undefined;
+    const transactionStatuses =
+      this.mapReportStatusFiltersToTransactionStatuses(statusFilters);
     const countQb = this.dataSource
       .getRepository(PaymentTransaction)
-      .createQueryBuilder('transaction')
-      .innerJoin('transaction.paymentIntent', 'intent')
-      .innerJoin('intent.targets', 'target')
-      .where('target.contextId = :contextId', { contextId });
-
-    if (searchTerm) {
-      const searchPattern = `%${searchTerm}%`;
-      countQb
-        .innerJoin(User, 'user', 'user.userId = intent.userId')
-        .andWhere(
-          '(LOWER(COALESCE(user.firstName, \'\')) LIKE :searchPattern OR LOWER(COALESCE(user.lastName, \'\')) LIKE :searchPattern OR LOWER(COALESCE(user.email, \'\')) LIKE :searchPattern)',
-          { searchPattern },
-        );
-    }
+      .createQueryBuilder('transaction');
+    this.applyReportFilters(
+      countQb,
+      contextId,
+      searchTerm,
+      transactionStatuses,
+      certificateGenerated,
+      couponCode,
+    );
 
     const countResult = await countQb
       .select('COUNT(DISTINCT transaction.id)', 'cnt')
@@ -636,24 +636,19 @@ export class PaymentService {
       .getRepository(PaymentTransaction)
       .createQueryBuilder('transaction')
       .select('transaction.id', 'id')
-      .innerJoin('transaction.paymentIntent', 'intent')
-      .innerJoin('intent.targets', 'target')
-      .where('target.contextId = :contextId', { contextId })
       .groupBy('transaction.id')
       .orderBy('MAX(transaction.createdAt)', 'DESC')
       .addOrderBy('transaction.id', 'ASC')
       .offset(offset)
       .limit(limit);
-
-    if (searchTerm) {
-      const searchPattern = `%${searchTerm}%`;
-      idsQb
-        .innerJoin(User, 'user', 'user.userId = intent.userId')
-        .andWhere(
-          '(LOWER(COALESCE(user.firstName, \'\')) LIKE :searchPattern OR LOWER(COALESCE(user.lastName, \'\')) LIKE :searchPattern OR LOWER(COALESCE(user.email, \'\')) LIKE :searchPattern)',
-          { searchPattern },
-        );
-    }
+    this.applyReportFilters(
+      idsQb,
+      contextId,
+      searchTerm,
+      transactionStatuses,
+      certificateGenerated,
+      couponCode,
+    );
 
     const idRows = await idsQb.getRawMany();
     const orderedIds = idRows.map((row) => row.id as string);
@@ -752,6 +747,91 @@ export class PaymentService {
     };
   }
 
+  private applyReportFilters(
+    qb: SelectQueryBuilder<PaymentTransaction>,
+    contextId: string,
+    searchTerm?: string,
+    transactionStatuses?: PaymentTransactionStatus[],
+    certificateGenerated?: boolean,
+    couponCode?: string,
+  ): void {
+    qb
+      .innerJoin('transaction.paymentIntent', 'intent')
+      .innerJoin('intent.targets', 'target')
+      .where('target.contextId = :contextId', { contextId });
+
+    if (searchTerm) {
+      const searchPattern = `%${searchTerm}%`;
+      qb
+        .innerJoin(User, 'user', 'user.userId = intent.userId')
+        .andWhere(
+          '(LOWER(COALESCE(user.firstName, \'\')) LIKE :searchPattern OR LOWER(COALESCE(user.lastName, \'\')) LIKE :searchPattern OR LOWER(COALESCE(user.email, \'\')) LIKE :searchPattern)',
+          { searchPattern },
+        );
+    }
+
+    if (transactionStatuses && transactionStatuses.length > 0) {
+      qb.andWhere('transaction.status IN (:...transactionStatuses)', {
+        transactionStatuses,
+      });
+    }
+
+    if (typeof certificateGenerated === 'boolean') {
+      const lockedTargetSubquery = qb
+        .subQuery()
+        .select('1')
+        .from(PaymentTarget, 'target_unlock_filter')
+        .where('target_unlock_filter.paymentIntentId = intent.id')
+        .andWhere('target_unlock_filter.contextId = :contextId')
+        .andWhere('target_unlock_filter.unlockStatus != :unlockedStatus')
+        .getQuery();
+
+      if (certificateGenerated) {
+        qb.andWhere(`NOT EXISTS ${lockedTargetSubquery}`, {
+          unlockedStatus: PaymentTargetUnlockStatus.UNLOCKED,
+        });
+      } else {
+        qb.andWhere(`EXISTS ${lockedTargetSubquery}`, {
+          unlockedStatus: PaymentTargetUnlockStatus.UNLOCKED,
+        });
+      }
+    }
+
+    if (couponCode) {
+      qb.andWhere(
+        "LOWER(COALESCE(intent.metadata->>'couponCode', '')) = :couponCode",
+        { couponCode: couponCode.toLowerCase() },
+      );
+    }
+  }
+
+  private mapReportStatusFiltersToTransactionStatuses(
+    statusFilters?: string[],
+  ): PaymentTransactionStatus[] | undefined {
+    if (!statusFilters || statusFilters.length === 0) {
+      return undefined;
+    }
+
+    const statuses = new Set<PaymentTransactionStatus>();
+    statusFilters.forEach((status) => {
+      switch (status) {
+        case 'SUCCESS':
+          statuses.add(PaymentTransactionStatus.SUCCESS);
+          break;
+        case 'INITIATED':
+          statuses.add(PaymentTransactionStatus.INITIATED);
+          break;
+        case 'FAILED':
+          statuses.add(PaymentTransactionStatus.FAILED);
+          break;
+        default:
+          break;
+      }
+    });
+
+    return Array.from(statuses);
+  }
+
   private computeTargetUnlockedForContext(
     intent: PaymentIntent,
     reportContextId: string,
