fic(PM-1585): Search scorecard modifications

.gitignore

@@ -42,6 +42,9 @@ lerna-debug.log*
 .env.production.local
 .env.local
 
+# Prisma score cards
+/prisma/Scorecards
+
 # temp directory
 .temp
 .tmp

src/api/api.module.ts

@@ -16,6 +16,7 @@ import { ChallengeApiService } from 'src/shared/modules/global/challenge.service
 import { WebhookController } from './webhook/webhook.controller';
 import { WebhookService } from './webhook/webhook.service';
 import { GiteaWebhookAuthGuard } from '../shared/guards/gitea-webhook-auth.guard';
+import { ScoreCardService } from './scorecard/scorecard.service';
 
 @Module({
   imports: [HttpModule, GlobalProvidersModule],
@@ -37,6 +38,7 @@ import { GiteaWebhookAuthGuard } from '../shared/guards/gitea-webhook-auth.guard
     ChallengeApiService,
     WebhookService,
     GiteaWebhookAuthGuard,
+    ScoreCardService,
   ],
 })
 export class ApiModule {}

src/api/scorecard/scorecard.controller.ts

@@ -9,6 +9,8 @@ import {
   Query,
   NotFoundException,
   InternalServerErrorException,
+  Res,
+  UseInterceptors,
 } from '@nestjs/common';
 import {
   ApiTags,
@@ -24,18 +26,24 @@ import { UserRole } from 'src/shared/enums/userRole.enum';
 import { Scopes } from 'src/shared/decorators/scopes.decorator';
 import { Scope } from 'src/shared/enums/scopes.enum';
 import {
+  ScorecardPaginatedResponseDto,
   ScorecardRequestDto,
   ScorecardResponseDto,
+  ScorecardWithGroupResponseDto,
   mapScorecardRequestToDto,
 } from 'src/dto/scorecard.dto';
 import { ChallengeTrack } from 'src/shared/enums/challengeTrack.enum';
 import { PrismaService } from '../../shared/modules/global/prisma.service';
+import { ScoreCardService } from './scorecard.service';
+import { OkResponse } from 'src/dto/common.dto';
+import { Response } from 'express';
+import { PaginationHeaderInterceptor } from 'src/interceptors/PaginationHeaderInterceptor';
 
 @ApiTags('Scorecard')
 @ApiBearerAuth()
 @Controller('/scorecards')
 export class ScorecardController {
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(private readonly prisma: PrismaService, private readonly scorecardService: ScoreCardService) {}
 
   @Post()
   @Roles(UserRole.Admin)
@@ -48,12 +56,12 @@ export class ScorecardController {
   @ApiResponse({
     status: 201,
     description: 'Scorecard added successfully.',
-    type: ScorecardResponseDto,
+    type: ScorecardWithGroupResponseDto,
   })
   @ApiResponse({ status: 403, description: 'Forbidden.' })
   async addScorecard(
     @Body() body: ScorecardRequestDto,
-  ): Promise<ScorecardResponseDto> {
+  ): Promise<ScorecardWithGroupResponseDto> {
     const data = await this.prisma.scorecard.create({
       data: mapScorecardRequestToDto(body),
       include: {
@@ -68,7 +76,7 @@ export class ScorecardController {
         },
       },
     });
-    return data as ScorecardResponseDto;
+    return data as ScorecardWithGroupResponseDto;
   }
 
   @Put('/:id')
@@ -87,14 +95,14 @@ export class ScorecardController {
   @ApiResponse({
     status: 200,
     description: 'Scorecard updated successfully.',
-    type: ScorecardResponseDto,
+    type: ScorecardWithGroupResponseDto,
   })
   @ApiResponse({ status: 403, description: 'Forbidden.' })
   @ApiResponse({ status: 404, description: 'Scorecard not found.' })
   async editScorecard(
     @Param('id') id: string,
-    @Body() body: ScorecardRequestDto,
-  ): Promise<ScorecardResponseDto> {
+    @Body() body: ScorecardWithGroupResponseDto,
+  ): Promise<ScorecardWithGroupResponseDto> {
     console.log(JSON.stringify(body));
 
     const data = await this.prisma.scorecard
@@ -121,7 +129,7 @@ export class ScorecardController {
           message: `Error: ${error.code}`,
         });
       });
-    return data as ScorecardResponseDto;
+    return data as ScorecardWithGroupResponseDto;
   }
 
   @Delete(':id')
@@ -139,7 +147,7 @@ export class ScorecardController {
   @ApiResponse({
     status: 200,
     description: 'Scorecard deleted successfully.',
-    type: ScorecardResponseDto,
+    type: ScorecardWithGroupResponseDto,
   })
   @ApiResponse({ status: 403, description: 'Forbidden.' })
   @ApiResponse({ status: 404, description: 'Scorecard not found.' })
@@ -173,10 +181,10 @@ export class ScorecardController {
   @ApiResponse({
     status: 200,
     description: 'Scorecard retrieved successfully.',
-    type: ScorecardResponseDto,
+    type: ScorecardWithGroupResponseDto,
   })
   @ApiResponse({ status: 404, description: 'Scorecard not found.' })
-  async viewScorecard(@Param('id') id: string): Promise<ScorecardResponseDto> {
+  async viewScorecard(@Param('id') id: string): Promise<ScorecardWithGroupResponseDto> {
     const data = await this.prisma.scorecard
       .findUniqueOrThrow({
         where: { id },
@@ -200,11 +208,11 @@ export class ScorecardController {
           message: `Error: ${error.code}`,
         });
       });
-    return data as ScorecardResponseDto;
+    return data as ScorecardWithGroupResponseDto;
   }
 
   @Get()
-  @Roles(UserRole.Admin, UserRole.Copilot)
+  @Roles(UserRole.Admin)
   @Scopes(Scope.ReadScorecard)
   @ApiOperation({
     summary: 'Search scorecards',
@@ -249,34 +257,31 @@ export class ScorecardController {
     description: 'List of matching scorecards',
     type: [ScorecardResponseDto],
   })
+  @UseInterceptors(PaginationHeaderInterceptor)
   async searchScorecards(
-    @Query('challengeTrack') challengeTrack?: ChallengeTrack,
-    @Query('challengeType') challengeType?: string,
+    @Query('challengeTrack') challengeTrack?: ChallengeTrack | ChallengeTrack[],
+    @Query('challengeType') challengeType?: string | string[],
     @Query('name') name?: string,
     @Query('page') page: number = 1,
     @Query('perPage') perPage: number = 10,
-  ) {
-    const skip = (page - 1) * perPage;
-    const data = await this.prisma.scorecard.findMany({
-      where: {
-        ...(challengeTrack && { challengeTrack }),
-        ...(challengeType && { challengeType }),
-        ...(name && { name: { contains: name, mode: 'insensitive' } }),
-      },
-      include: {
-        scorecardGroups: {
-          include: {
-            sections: {
-              include: {
-                questions: true,
-              },
-            },
-          },
-        },
-      },
-      skip,
-      take: perPage,
+  ): Promise<ScorecardPaginatedResponseDto> {
+    const challengeTrackArray = Array.isArray(challengeTrack)
+    ? challengeTrack
+    : challengeTrack
+    ? [challengeTrack]
+    : [];
+    const challengeTypeArray = Array.isArray(challengeType)
+    ? challengeType
+    : challengeType
+    ? [challengeType]
+    : [];
+    const result = await this.scorecardService.getScoreCards({
+      challengeTrack: challengeTrackArray,
+      challengeType: challengeTypeArray,
+      name,
+      page,
+      perPage,
     });
-    return data as ScorecardResponseDto[];
+    return result;
   }
 }

src/api/scorecard/scorecard.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from "@nestjs/common";
+import { Prisma } from "@prisma/client";
+import { ScorecardPaginatedResponseDto, ScorecardQueryDto, ScorecardResponseDto } from "src/dto/scorecard.dto";
+import { PrismaService } from "src/shared/modules/global/prisma.service";
+
+@Injectable()
+export class ScoreCardService {
+  constructor(
+    private readonly prisma: PrismaService,
+  ) {}
+
+  /**
+   * Get list of score cards and send it in paginated way
+   * @param query query params
+   * @returns response dto
+   */
+  async getScoreCards(
+    query: ScorecardQueryDto
+  ): Promise<ScorecardPaginatedResponseDto> {
+    const { page = 1, perPage = 10, challengeTrack, challengeType, name } = query;
+    const skip = (page - 1) * perPage;
+    const where: Prisma.scorecardWhereInput = {
+      ...(challengeTrack?.length && {
+        challengeTrack: {
+          in: challengeTrack,
+        },
+      }),
+      ...(challengeType?.length && {
+        challengeType: {
+          in: challengeType,
+        },
+      }),
+      ...(name && { name: { contains: name, mode: 'insensitive' } }),
+    };
+    const data = await this.prisma.scorecard.findMany({
+      where,
+      skip,
+      take: perPage,
+      orderBy: {
+        name: 'asc',
+      },
+    });
+
+    const totalCount = await this.prisma.scorecard.count({
+      where,
+    });
+
+    return {
+      metadata: {
+        total: totalCount,
+        page,
+        perPage,
+        totalPages: Math.ceil(totalCount/perPage),
+      },
+      scoreCards: data as ScorecardResponseDto[],
+    };
+  }
+}

src/dto/scorecard.dto.ts

@@ -203,11 +203,13 @@ export class ScorecardBaseDto {
     example: 'user456',
   })
   updatedBy: string;
+}
 
+export class ScorecardBaseWithGroupsDto extends ScorecardBaseDto {
   scorecardGroups: any[];
 }
 
-export class ScorecardRequestDto extends ScorecardBaseDto {
+export class ScorecardRequestDto extends ScorecardBaseWithGroupsDto {
   @ApiProperty({ description: 'The ID of the scorecard', example: 'abc123' })
   id: string;
 
@@ -221,6 +223,11 @@ export class ScorecardRequestDto extends ScorecardBaseDto {
 export class ScorecardResponseDto extends ScorecardBaseDto {
   @ApiProperty({ description: 'The ID of the scorecard', example: 'abc123' })
   id: string;
+}
+
+export class ScorecardWithGroupResponseDto extends ScorecardBaseDto {
+  @ApiProperty({ description: 'The ID of the scorecard', example: 'abc123' })
+  id: string;
 
   @ApiProperty({
     description: 'The list of groups associated with the scorecard',
@@ -229,6 +236,39 @@ export class ScorecardResponseDto extends ScorecardBaseDto {
   scorecardGroups: ScorecardGroupResponseDto[];
 }
 
+export class PaginationMetaDto {
+  @ApiProperty({ example: 100 })
+  total: number;
+
+  @ApiProperty({ example: 1 })
+  page: number;
+
+  @ApiProperty({ example: 10 })
+  perPage: number;
+
+  @ApiProperty({ example: 10 })
+  totalPages: number;
+}
+
+export class ScorecardPaginatedResponseDto {
+  @ApiProperty({ description: 'This contains pagination metadata' })
+  metadata: PaginationMetaDto;
+
+  @ApiProperty({
+    description: 'The list of score cards',
+    type: [ScorecardGroupResponseDto],
+  })
+  scoreCards: ScorecardResponseDto[];
+}
+
+export class ScorecardQueryDto {
+  challengeTrack?: ChallengeTrack[];
+  challengeType?: string[];
+  name?: string;
+  page?: number;
+  perPage?: number;
+}
+
 export function mapScorecardRequestToDto(request: ScorecardRequestDto) {
   const userFields = {
     createdBy: request.createdBy,

src/interceptors/PaginationHeaderInterceptor.ts

@@ -0,0 +1,21 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from "@nestjs/common";
+import { Observable, tap } from "rxjs";
+import { Response } from "express";
+
+@Injectable()
+export class PaginationHeaderInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const res = context.switchToHttp().getResponse<Response>();
+    return next.handle().pipe(
+      tap((response) => {
+        if (response?.metadata) {
+          const { total, page, perPage, totalPages } = response.metadata;
+          res.setHeader('X-Total-Count', total);
+          res.setHeader('X-Page', page);
+          res.setHeader('X-Per-Page', perPage);
+          res.setHeader('X-Total-Pages', totalPages);
+        }
+      }),
+    );
+  }
+}