Merge pull request #340 from Vvictor-commits/feat/course-filtering-and-new-fields

feat(courses): add difficulty/tags/thumbnailUrl fields and search/fil…

Author: portableDD

backend/src/certificates/certificates.module.ts

@@ -1,7 +1,6 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Certificate } from '../certificates/entities/certificate.entity';
-<<<<<<< HEAD
 import { Course } from '../courses/entities/course.entity';
 import { User } from '../users/entities/user.entity';
 import { CertificateController } from './certificates.controller';

backend/src/certificates/certificates.service.ts

@@ -21,7 +21,6 @@ import { VerifyCertificateDto } from './dto/verify-certificate.dto';
 import { NotificationsService } from '../notifications/notifications.service';
 import { NotificationType } from '../notifications/entities/notification.entity';
 import { ConfigService } from '@nestjs/config';
-<<<<<<< HEAD
 import { EmailService } from '../email/email.service';
 import { WebhooksService } from '../webhooks/webhooks.service';
 import { WebhookEvent } from '../webhooks/dto/create-webhook.dto';

backend/src/courses/courses.controller.ts

@@ -20,6 +20,7 @@ import { AuthGuard } from '@nestjs/passport';
 import { JwtAuthGuard } from '../common/guards/jwt-auth.guard';
 import { RolesGuard } from '../common/guards/roles.guard';
 import { PaginationDto } from '../common/dto/pagination.dto';
+import { CourseFilterDto } from './dto/course-filter.dto';
 import { CoursesService } from './courses.service';
 import { UserRole } from '../common/enums/user-role.enum';
 import { Roles } from '../common/decorators/roles.decorator';
@@ -113,24 +114,31 @@ export class CoursesController {
     return this.coursesService.getEnrolledCourses(req.user.id);
   }
 
+  @Get('tags')
+  @ApiOperation({ summary: 'Get unique tags from published courses' })
+  @ApiResponse({ status: 200, description: 'List of unique tags', type: [String] })
+  async getTags(): Promise<string[]> {
+    return this.coursesService.getUniqueTags();
+  }
+
   @Get()
   @UseGuards(OptionalJwtAuthGuard)
   @ApiOperation({ summary: 'Get paginated list of courses' })
   @ApiResponse({ status: 200, description: 'Courses retrieved successfully' })
   async findAll(
     @Req() req: RequestWithUser,
-    @Query() pagination: PaginationDto,
+    @Query() filters: CourseFilterDto,
   ): Promise<{
     data: CourseResponseDto[];
     total: number;
     page: number;
     limit: number;
     totalPages: number;
   }> {
-    const page = pagination.page ?? 1;
-    const limit = pagination.limit ?? 10;
+    const page = filters.page ?? 1;
+    const limit = filters.limit ?? 10;
     const userId = req.user?.id;
-    return this.coursesService.findAllPaginated(page, limit, userId);
+    return this.coursesService.findAllPaginated(page, limit, userId, filters);
   }
 
   @Get(':id/enrollment-status')

backend/src/courses/courses.service.ts

@@ -17,6 +17,7 @@ import {
 } from './dto/enrollment-response.dto';
 import { NotificationsService } from '../notifications/notifications.service';
 import { NotificationType } from '../notifications/entities/notification.entity';
+import { CourseFilterDto } from './dto/course-filter.dto';
 
 @Injectable()
 export class CoursesService {
@@ -43,24 +44,70 @@ export class CoursesService {
     page: number = 1,
     limit: number = 10,
     userId?: string,
+    filters?: CourseFilterDto,
   ): Promise<PaginatedResult<CourseResponseDto>> {
-    return this.findAllPaginated(page, limit, userId);
+    return this.findAllPaginated(page, limit, userId, filters);
   }
 
   async findAllPaginated(
     page: number,
     limit: number,
     userId?: string,
+    filters?: CourseFilterDto,
   ): Promise<PaginatedResult<CourseResponseDto>> {
-    const result = await this.paginationService.paginate<Course>(
-      this.courseRepository,
-      { page, limit },
-      { where: { published: true }, order: { createdAt: 'DESC' } },
-    );
+    const { search, difficulty, tags, sortBy = 'createdAt', sortOrder = 'desc' } = filters ?? {};
+
+    const qb = this.courseRepository
+      .createQueryBuilder('course')
+      .leftJoin('course.registrations', 'reg')
+      .addSelect('COUNT(reg.id)', 'enrollmentCount')
+      .where('course.published = :published', { published: true })
+      .groupBy('course.id')
+      .skip((page - 1) * limit)
+      .take(limit);
+
+    if (search) {
+      qb.andWhere(
+        '(LOWER(course.title) LIKE :search OR LOWER(course.description) LIKE :search)',
+        { search: `%${search.toLowerCase()}%` },
+      );
+    }
+
+    if (difficulty) {
+      qb.andWhere('LOWER(course.difficulty) = :difficulty', {
+        difficulty: difficulty.toLowerCase(),
+      });
+    }
+
+    if (tags) {
+      const tagList = tags.split(',').map((t) => t.trim()).filter(Boolean);
+      tagList.forEach((tag, i) => {
+        qb.andWhere(`course.tags LIKE :tag${i}`, { [`tag${i}`]: `%${tag}%` });
+      });
+    }
+
+    const orderCol = ['title', 'difficulty'].includes(sortBy) ? sortBy : 'createdAt';
+    qb.orderBy(`course.${orderCol}`, sortOrder.toUpperCase() as 'ASC' | 'DESC');
+
+    const [courses, total] = await qb.getManyAndCount();
+
+    // fetch enrollment counts via raw query for accuracy
+    const courseIds = courses.map((c) => c.id);
+    const countMap = new Map<string, number>();
+    if (courseIds.length > 0) {
+      const counts: { courseId: string; count: string }[] =
+        await this.courseRegistrationRepository
+          .createQueryBuilder('reg')
+          .select('reg.courseId', 'courseId')
+          .addSelect('COUNT(reg.id)', 'count')
+          .where('reg.courseId IN (:...ids)', { ids: courseIds })
+          .groupBy('reg.courseId')
+          .getRawMany();
+      counts.forEach((r) => countMap.set(r.courseId, parseInt(r.count, 10)));
+    }
 
     let enrolledIds = new Set<string>();
-    if (userId && result.data.length > 0) {
-      const courseIds = result.data.map((c) => c.id);
+    if (userId && courseIds.length > 0) {
       const regs = await this.courseRegistrationRepository.find({
         where: { userId, courseId: In(courseIds) },
         select: ['courseId'],
@@ -69,17 +116,30 @@ export class CoursesService {
     }
 
     return {
-      ...result,
-      data: result.data.map(
+      data: courses.map(
         (course) =>
           new CourseResponseDto(course, {
-            isEnrolled:
-              userId !== undefined ? enrolledIds.has(course.id) : undefined,
+            isEnrolled: userId !== undefined ? enrolledIds.has(course.id) : undefined,
+            enrollmentCount: countMap.get(course.id) ?? 0,
           }),
       ),
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
     };
   }
 
+  async getUniqueTags(): Promise<string[]> {
+    const courses = await this.courseRepository.find({
+      where: { published: true },
+      select: ['tags'],
+    });
+    const tagSet = new Set<string>();
+    courses.forEach((c) => (c.tags ?? []).forEach((t) => tagSet.add(t)));
+    return Array.from(tagSet).sort();
+  }
+
   async findOne(id: string): Promise<CourseResponseDto> {
     const course = await this.courseRepository.findOne({ where: { id } });
     if (!course) {

backend/src/courses/dto/course-filter.dto.ts

@@ -0,0 +1,30 @@
+import { IsOptional, IsString, IsIn } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+import { PaginationDto } from '../../common/dto/pagination.dto';
+
+export class CourseFilterDto extends PaginationDto {
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsString()
+  difficulty?: string;
+
+  @ApiProperty({ required: false, description: 'Comma-separated tags' })
+  @IsOptional()
+  @IsString()
+  tags?: string;
+
+  @ApiProperty({ required: false, enum: ['createdAt', 'title', 'difficulty'] })
+  @IsOptional()
+  @IsIn(['createdAt', 'title', 'difficulty'])
+  sortBy?: 'createdAt' | 'title' | 'difficulty';
+
+  @ApiProperty({ required: false, enum: ['asc', 'desc'] })
+  @IsOptional()
+  @IsIn(['asc', 'desc'])
+  sortOrder?: 'asc' | 'desc';
+}

backend/src/courses/dto/course-response.dto.ts

@@ -1,44 +1,37 @@
-import {
-  IsString,
-  IsNotEmpty,
-  IsBoolean,
-  IsDate,
-  IsOptional,
-} from 'class-validator';
 import { ApiProperty } from '@nestjs/swagger';
 
 export class CourseResponseDto {
-  @ApiProperty({ example: '123e4567-e89b-12d3-a456-426614174000', description: 'id field' })
-  @IsString()
-  @IsNotEmpty()
+  @ApiProperty()
   id: string;
 
-  @ApiProperty({ example: 'Intro to Blockchain', description: 'title field' })
-  @IsString()
-  @IsNotEmpty()
+  @ApiProperty()
   title: string;
 
-  @ApiProperty({ example: 'A concise description of the resource.', description: 'description field' })
-  @IsString()
-  @IsNotEmpty()
+  @ApiProperty()
   description: string;
 
-  @ApiProperty({ example: true, description: 'published field' })
-  @IsBoolean()
+  @ApiProperty()
   published: boolean;
 
-  @ApiProperty({ example: '2026-04-22T00:00:00.000Z', description: 'createdAt field' })
-  @IsDate()
+  @ApiProperty({ nullable: true })
+  difficulty: string | null;
+
+  @ApiProperty({ type: [String] })
+  tags: string[];
+
+  @ApiProperty({ nullable: true })
+  thumbnailUrl: string | null;
+
+  @ApiProperty()
+  enrollmentCount: number;
+
+  @ApiProperty()
   createdAt: Date;
 
-  @ApiProperty({ example: '2026-04-22T00:00:00.000Z', description: 'updatedAt field' })
-  @IsDate()
+  @ApiProperty()
   updatedAt: Date;
 
-  /** Present on GET /courses when the request includes a valid JWT */
-  @ApiProperty({ example: true, description: 'isEnrolled field', required: false })
-  @IsOptional()
-  @IsBoolean()
+  @ApiProperty({ required: false })
   isEnrolled?: boolean;
 
   constructor(
@@ -47,20 +40,27 @@ export class CourseResponseDto {
       title: string;
       description: string;
       published: boolean;
+      difficulty?: string | null;
+      tags?: string[];
+      thumbnailUrl?: string | null;
+      registrations?: { id: string }[];
       createdAt: Date;
       updatedAt: Date;
     },
-    options?: { isEnrolled?: boolean },
+    options?: { isEnrolled?: boolean; enrollmentCount?: number },
   ) {
     this.id = course.id;
     this.title = course.title;
     this.description = course.description;
     this.published = course.published;
+    this.difficulty = course.difficulty ?? null;
+    this.tags = course.tags ?? [];
+    this.thumbnailUrl = course.thumbnailUrl ?? null;
+    this.enrollmentCount = options?.enrollmentCount ?? course.registrations?.length ?? 0;
     this.createdAt = course.createdAt;
     this.updatedAt = course.updatedAt;
     if (options?.isEnrolled !== undefined) {
       this.isEnrolled = options.isEnrolled;
     }
   }
 }
-

backend/src/courses/dto/create-course.dto.ts

@@ -1,20 +1,36 @@
-import { IsString, IsNotEmpty, IsBoolean, IsOptional } from 'class-validator';
+import { IsString, IsNotEmpty, IsBoolean, IsOptional, IsArray, IsUrl } from 'class-validator';
 import { ApiProperty } from '@nestjs/swagger';
 
 export class CreateCourseDto {
-  @ApiProperty({ example: 'Intro to Blockchain', description: 'title field' })
+  @ApiProperty({ example: 'Intro to Blockchain' })
   @IsString()
   @IsNotEmpty()
   title: string;
 
-  @ApiProperty({ example: 'A concise description of the resource.', description: 'description field' })
+  @ApiProperty({ example: 'A concise description of the resource.' })
   @IsString()
   @IsNotEmpty()
   description: string;
 
-  @ApiProperty({ example: true, description: 'published field', required: false })
+  @ApiProperty({ example: true, required: false })
   @IsBoolean()
   @IsOptional()
   published?: boolean;
+
+  @ApiProperty({ example: 'Beginner', required: false })
+  @IsString()
+  @IsOptional()
+  difficulty?: string;
+
+  @ApiProperty({ example: ['bitcoin', 'defi'], required: false, type: [String] })
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  tags?: string[];
+
+  @ApiProperty({ example: 'https://example.com/thumb.jpg', required: false })
+  @IsUrl()
+  @IsOptional()
+  thumbnailUrl?: string;
 }
 

backend/src/courses/entities/course-registration.entity.ts

@@ -5,6 +5,7 @@ import {
   ManyToOne,
   CreateDateColumn,
   JoinColumn,
+  Unique,
 } from 'typeorm';
 import { User } from '../../users/entities/user.entity';
 import { Course } from './course.entity';

backend/src/courses/entities/course.entity.ts

@@ -24,6 +24,15 @@ export class Course {
   @Column({ default: false })
   published: boolean;
 
+  @Column({ nullable: true })
+  difficulty: string | null;
+
+  @Column({ type: 'simple-json', default: '[]' })
+  tags: string[];
+
+  @Column({ nullable: true })
+  thumbnailUrl: string | null;
+
   @OneToMany(() => CourseRegistration, (registration) => registration.course)
   registrations: CourseRegistration[];
 
@@ -39,3 +48,4 @@ export class Course {
   // Soft-delete field for admin restore functionality
   @DeleteDateColumn({ nullable: true })
   deletedAt: Date | null;
+}