feat: Course moderation, replace mock statistic with live

Author: hoangphuc841

apps/api/package.json

@@ -17,7 +17,8 @@
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:e2e": "jest --config ./test/jest-e2e.json"
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "seed:admin": "ts-node -r tsconfig-paths/register src/scripts/create-admin.ts"
   },
   "dependencies": {
     "@google/genai": "^1.31.0",

apps/api/src/admin/admin.module.ts

@@ -1,11 +1,14 @@
 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { AdminController } from './admin.controller';
 import { AdminService } from './admin.service';
+import { CoursesModule } from '../courses/courses.module';
+import { User } from '../users/entities/user.entity';
 import { UsersModule } from '../users/users.module';
 
 @Module({
-  imports: [UsersModule],
+  imports: [TypeOrmModule.forFeature([User]), UsersModule, CoursesModule],
   controllers: [AdminController],
   providers: [AdminService],
 })

apps/api/src/admin/admin.service.spec.ts

@@ -2,10 +2,12 @@ import { Test, type TestingModule } from '@nestjs/testing';
 
 import { AdminService } from './admin.service';
 import { UsersService } from '../users/users.service';
+import { CoursesService } from '../courses/courses.service';
 
 describe('AdminService', () => {
   let service: AdminService;
   let usersService: jest.Mocked<UsersService>;
+  let coursesService: jest.Mocked<CoursesService>;
 
   const mockUsersService: Partial<jest.Mocked<UsersService>> = {
     count: jest.fn(),
@@ -14,16 +16,23 @@ describe('AdminService', () => {
     updateStatus: jest.fn(),
   };
 
+  const mockCoursesService: Partial<jest.Mocked<CoursesService>> = {
+    count: jest.fn(),
+    countEnrollments: jest.fn(),
+  };
+
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         AdminService,
         { provide: UsersService, useValue: mockUsersService },
+        { provide: CoursesService, useValue: mockCoursesService },
       ],
     }).compile();
 
     service = module.get<AdminService>(AdminService);
     usersService = module.get(UsersService);
+    coursesService = module.get(CoursesService);
   });
 
   afterEach(() => {
@@ -35,26 +44,40 @@ describe('AdminService', () => {
   });
 
   describe('getSystemStats', () => {
-    it('should return system statistics with total users count', async () => {
-      const expectedCount = 42;
-      usersService.count.mockResolvedValue(expectedCount);
+    it('should return system statistics with counts', async () => {
+      const userCount = 42;
+      const courseCount = 10;
+      const enrollmentCount = 150;
+
+      usersService.count.mockResolvedValue(userCount);
+      coursesService.count.mockResolvedValue(courseCount);
+      coursesService.countEnrollments.mockResolvedValue(enrollmentCount);
 
       const result = await service.getSystemStats();
 
       expect(usersService.count).toHaveBeenCalledTimes(1);
+      expect(coursesService.count).toHaveBeenCalledTimes(1);
+      expect(coursesService.countEnrollments).toHaveBeenCalledTimes(1);
+
       expect(result).toEqual({
-        totalUsers: expectedCount,
-        totalCourses: 0,
-        totalEnrollments: 0,
+        totalUsers: userCount,
+        totalCourses: courseCount,
+        totalEnrollments: enrollmentCount,
       });
     });
 
-    it('should return zero users when no users exist', async () => {
+    it('should return zero counts when no data exists', async () => {
       usersService.count.mockResolvedValue(0);
+      coursesService.count.mockResolvedValue(0);
+      coursesService.countEnrollments.mockResolvedValue(0);
 
       const result = await service.getSystemStats();
 
-      expect(result.totalUsers).toBe(0);
+      expect(result).toEqual({
+        totalUsers: 0,
+        totalCourses: 0,
+        totalEnrollments: 0,
+      });
     });
   });
 });

apps/api/src/admin/admin.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@nestjs/common';
 
+import { CoursesService } from '../courses/courses.service';
 import { UsersService } from '../users/users.service';
 
 export interface SystemStats {
@@ -10,15 +11,20 @@ export interface SystemStats {
 
 @Injectable()
 export class AdminService {
-  constructor(private usersService: UsersService) {}
+  constructor(
+    private usersService: UsersService,
+    private coursesService: CoursesService,
+  ) {}
 
   async getSystemStats(): Promise<SystemStats> {
     const totalUsers = await this.usersService.count();
+    const totalCourses = await this.coursesService.count();
+    const totalEnrollments = await this.coursesService.countEnrollments();
 
     return {
       totalUsers,
-      totalCourses: 0, // Will be implemented when courses module is created
-      totalEnrollments: 0, // Will be implemented when enrollments module is created
+      totalCourses,
+      totalEnrollments,
     };
   }
 }

apps/api/src/courses/courses.controller.ts

@@ -268,4 +268,31 @@ export class CoursesController {
   ): Promise<void> {
     return this.coursesService.removeLesson(lessonId, user.id);
   }
+  @Patch(':id/submit')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(UserRole.INSTRUCTOR)
+  submit(@Param('id') id: string, @CurrentUser() user: User): Promise<Course> {
+    return this.coursesService.submitForApproval(id, user.id);
+  }
+
+  @Patch(':id/approve')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(UserRole.ADMIN)
+  approve(@Param('id') id: string): Promise<Course> {
+    return this.coursesService.approveCourse(id);
+  }
+
+  @Patch(':id/reject')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(UserRole.ADMIN)
+  reject(@Param('id') id: string): Promise<Course> {
+    return this.coursesService.rejectCourse(id);
+  }
+
+  @Get('admin/pending')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(UserRole.ADMIN)
+  findPending(): Promise<Course[]> {
+    return this.coursesService.findAllPending();
+  }
 }

apps/api/src/courses/courses.service.ts

@@ -18,6 +18,7 @@ import { CourseSection } from './entities/course-section.entity';
 import { Course } from './entities/course.entity';
 import { Enrollment } from './entities/enrollment.entity';
 import { Lesson } from './entities/lesson.entity';
+import { CourseStatus } from './enums/course-status.enum';
 import { User } from '../users/entities/user.entity';
 import { UserRole } from '../users/enums/user-role.enum';
 
@@ -97,7 +98,7 @@ export class CoursesService {
 
     // 1. UPDATED: Multi-field Search (Title, Description, Tags)
     if (search) {
-      const searchLower = `%${search.toLowerCase()}%`;
+      const searchLower = `% ${search.toLowerCase()}% `;
       queryBuilder.andWhere(
         new Brackets((qb) => {
           qb.where('LOWER(course.title) LIKE :search', { search: searchLower })
@@ -121,9 +122,9 @@ export class CoursesService {
       queryBuilder.andWhere(
         new Brackets((qb) => {
           tags.forEach((tag, index) => {
-            const paramName = `tag_${index}`;
-            qb.orWhere(`course.tags LIKE :${paramName}`, {
-              [paramName]: `%${tag}%`,
+            const paramName = `tag_${index} `;
+            qb.orWhere(`course.tags LIKE:${paramName} `, {
+              [paramName]: `% ${tag}% `,
             });
           });
         }),
@@ -442,7 +443,7 @@ export class CoursesService {
         .createQueryBuilder('course')
         .leftJoinAndSelect('course.instructor', 'instructor')
         .loadRelationCountAndMap('course.studentCount', 'course.enrollments')
-        .where('course.isPublished = :isPublished', { isPublished: true })
+        .where('course.status = :status', { status: CourseStatus.PUBLISHED })
         .andWhere('course.id NOT IN (:...enrolledIds)', {
           enrolledIds: Array.from(enrolledCourseIds),
         })
@@ -462,26 +463,26 @@ export class CoursesService {
       .createQueryBuilder('course')
       .leftJoinAndSelect('course.instructor', 'instructor')
       .loadRelationCountAndMap('course.studentCount', 'course.enrollments')
-      .where('course.isPublished = :isPublished', { isPublished: true })
+      .where('course.status = :status', { status: CourseStatus.PUBLISHED })
       .andWhere('course.id NOT IN (:...enrolledIds)', {
         enrolledIds: Array.from(enrolledCourseIds),
       });
 
     // Add tag matching conditions (OR for any tag match)
     const tagConditions = Array.from(userTags).map(
-      (_, index) => `LOWER(course.tags) LIKE :tag_${index}`,
+      (_, index) => `LOWER(course.tags) LIKE:tag_${index} `,
     );
     if (tagConditions.length > 0) {
       queryBuilder.andWhere(
         new Brackets((qb) => {
           Array.from(userTags).forEach((tag, index) => {
             if (index === 0) {
-              qb.where(`LOWER(course.tags) LIKE :tag_${index}`, {
-                [`tag_${index}`]: `%${tag}%`,
+              qb.where(`LOWER(course.tags) LIKE:tag_${index} `, {
+                [`tag_${index} `]: ` % ${tag}% `,
               });
             } else {
-              qb.orWhere(`LOWER(course.tags) LIKE :tag_${index}`, {
-                [`tag_${index}`]: `%${tag}%`,
+              qb.orWhere(`LOWER(course.tags) LIKE:tag_${index} `, {
+                [`tag_${index} `]: ` % ${tag}% `,
               });
             }
           });
@@ -516,8 +517,9 @@ export class CoursesService {
   ): Promise<Course> {
     const course = this.coursesRepository.create({
       ...createCourseDto,
-      instructorId,
-      isPublished: false,
+      instructor: { id: instructorId },
+      status: CourseStatus.DRAFT, // Default to draft
+      isPublished: false, // Legacy field
     });
     return this.coursesRepository.save(course);
   }
@@ -665,4 +667,49 @@ export class CoursesService {
 
     await this.lessonRepository.remove(lesson);
   }
+
+  // --- Statistics ---
+
+  async count(): Promise<number> {
+    return this.coursesRepository.count();
+  }
+
+  async countEnrollments(): Promise<number> {
+    return this.enrollmentRepository.count();
+  }
+
+  // --- Moderation ---
+
+  async submitForApproval(id: string, userId: string): Promise<Course> {
+    const course = await this.findOne(id, { id: userId });
+    if (course.instructorId !== userId) {
+      throw new ForbiddenException(
+        'Only the instructor can submit this course',
+      );
+    }
+    course.status = CourseStatus.PENDING;
+    return this.coursesRepository.save(course);
+  }
+
+  async approveCourse(id: string): Promise<Course> {
+    const course = await this.findOne(id, { role: UserRole.ADMIN });
+    course.status = CourseStatus.PUBLISHED;
+    course.isPublished = true;
+    return this.coursesRepository.save(course);
+  }
+
+  async rejectCourse(id: string): Promise<Course> {
+    const course = await this.findOne(id, { role: UserRole.ADMIN });
+    course.status = CourseStatus.REJECTED;
+    course.isPublished = false;
+    return this.coursesRepository.save(course);
+  }
+
+  async findAllPending(): Promise<Course[]> {
+    return this.coursesRepository.find({
+      where: { status: CourseStatus.PENDING },
+      relations: ['instructor'],
+      order: { createdAt: 'DESC' },
+    });
+  }
 }

apps/api/src/courses/entities/course.entity.ts

@@ -9,6 +9,8 @@ import {
   JoinColumn,
 } from 'typeorm';
 
+import { CourseStatus } from '../enums/course-status.enum';
+
 import type { CourseSection } from './course-section.entity';
 import type { Enrollment } from './enrollment.entity';
 import type { User } from '../../users/entities/user.entity';
@@ -43,6 +45,13 @@ export class Course {
   })
   level: CourseLevel;
 
+  @Column({
+    type: 'enum',
+    enum: CourseStatus,
+    default: CourseStatus.DRAFT,
+  })
+  status: CourseStatus;
+
   @Column({ default: false })
   isPublished: boolean;
 

apps/api/src/courses/enums/course-status.enum.ts

@@ -0,0 +1,6 @@
+export enum CourseStatus {
+  DRAFT = 'draft',
+  PENDING = 'pending',
+  PUBLISHED = 'published',
+  REJECTED = 'rejected',
+}

apps/api/src/scripts/create-admin.ts

@@ -0,0 +1,55 @@
+import { NestFactory } from '@nestjs/core';
+
+import { AppModule } from '../app.module';
+import { UserRole } from '../users/enums/user-role.enum';
+import { UsersService } from '../users/users.service';
+
+async function bootstrap(): Promise<void> {
+  const app = await NestFactory.createApplicationContext(AppModule);
+  const usersService = app.get(UsersService);
+
+  const email = 'admin@example.com';
+  const password = 'Password123!';
+  const fullName = 'Admin User';
+
+  /* eslint-disable no-console */
+  console.log(`Checking for user with email: ${email}`);
+
+  let user = await usersService.findByEmail(email);
+
+  if (!user) {
+    console.log('User not found. Creating new admin user...');
+
+    try {
+      const result = await usersService.createWithActivationToken({
+        email,
+        fullName,
+        password,
+      });
+
+      // eslint-disable-next-line prefer-destructuring
+      user = result.user;
+      console.log(`User created with ID: ${user.id}`);
+    } catch (error) {
+      console.error('Error creating user:', error);
+      process.exit(1);
+    }
+  } else {
+    console.log(`User found with ID: ${user.id}. Updating to admin...`);
+  }
+
+  await usersService.updateRole(user.id, UserRole.ADMIN);
+  console.log('Role updated to ADMIN');
+
+  await usersService.activateUser(user.id);
+  console.log('User activated');
+
+  console.log('Admin user setup complete.');
+  console.log(`Email: ${email}`);
+  console.log(`Password: ${password}`);
+
+  await app.close();
+  /* eslint-enable no-console */
+}
+
+void bootstrap();