feat: refactor statistic maodule

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

@@ -315,6 +315,7 @@ export class CoursesService {
 
     if (!course) throw new NotFoundException("Course not found");
 
+    // TODO: to remove and start use getLessonsDetails form lessonsRepository
     const courseLessonList = await this.db
       .select({
         id: lessons.id,

apps/api/src/lessons/repositories/lessons.repository.ts

@@ -1,5 +1,5 @@
 import { Inject, Injectable } from "@nestjs/common";
-import { and, count, eq, inArray, sql } from "drizzle-orm";
+import { and, count, desc, eq, inArray, isNotNull, sql } from "drizzle-orm";
 
 import { DatabasePg, type UUIDType } from "src/common";
 import { STATES } from "src/common/states";
@@ -22,6 +22,7 @@ import { LESSON_TYPE } from "../lesson.type";
 
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import type * as schema from "src/storage/schema";
+import { LessonProgress } from "../schemas/lesson.types";
 
 @Injectable()
 export class LessonsRepository {
@@ -328,6 +329,78 @@ export class LessonsRepository {
     return quizScore.quizScore;
   }
 
+  async getLessonsDetails(userId: UUIDType, courseId: UUIDType, lessonId?: UUIDType) {
+    const conditions = [
+      eq(courseLessons.courseId, courseId),
+      eq(lessons.archived, false),
+      eq(lessons.state, STATES.published),
+      isNotNull(lessons.id),
+      isNotNull(lessons.title),
+      isNotNull(lessons.description),
+      isNotNull(lessons.imageUrl),
+    ];
+    if (lessonId) conditions.push(eq(lessons.id, lessonId));
+
+    return await this.db
+      .select({
+        id: lessons.id,
+        title: lessons.title,
+        type: lessons.type,
+        isSubmitted: sql<boolean>`
+          EXISTS (
+            SELECT 1
+            FROM ${studentLessonsProgress}
+            WHERE ${studentLessonsProgress.lessonId} = ${lessons.id}
+              AND ${studentLessonsProgress.courseId} = ${courseId}
+              AND ${studentLessonsProgress.studentId} = ${userId}
+              AND ${studentLessonsProgress.quizCompleted}
+          )::BOOLEAN`,
+        description: sql<string>`${lessons.description}`,
+        imageUrl: sql<string>`${lessons.imageUrl}`,
+        itemsCount: sql<number>`
+          (SELECT COUNT(*)
+          FROM ${lessonItems}
+          WHERE ${lessonItems.lessonId} = ${lessons.id}
+            AND ${lessonItems.lessonItemType} != 'text_block')::INTEGER`,
+        itemsCompletedCount: sql<number>`
+          (SELECT COUNT(*)
+          FROM ${studentCompletedLessonItems}
+          WHERE ${studentCompletedLessonItems.lessonId} = ${lessons.id}
+            AND ${studentCompletedLessonItems.courseId} = ${courseId}
+            AND ${studentCompletedLessonItems.studentId} = ${userId})::INTEGER`,
+        lessonProgress: sql<"completed" | "in_progress" | "not_started">`
+          (CASE
+            WHEN (
+              SELECT COUNT(*)
+              FROM ${lessonItems}
+              WHERE ${lessonItems.lessonId} = ${lessons.id}
+                AND ${lessonItems.lessonItemType} != 'text_block'
+            ) = (
+              SELECT COUNT(*)
+              FROM ${studentCompletedLessonItems}
+              WHERE ${studentCompletedLessonItems.lessonId} = ${lessons.id}
+                AND ${studentCompletedLessonItems.courseId} = ${courseId}
+                AND ${studentCompletedLessonItems.studentId} = ${userId}
+            )
+            THEN ${LessonProgress.completed}
+            WHEN (
+              SELECT COUNT(*)
+              FROM ${studentCompletedLessonItems}
+              WHERE ${studentCompletedLessonItems.lessonId} = ${lessons.id}
+                AND ${studentCompletedLessonItems.courseId} = ${courseId}
+                AND ${studentCompletedLessonItems.studentId} = ${userId}
+            ) > 0
+            THEN ${LessonProgress.inProgress}
+            ELSE ${LessonProgress.notStarted}
+          END)
+        `,
+        isFree: courseLessons.isFree,
+      })
+      .from(courseLessons)
+      .innerJoin(lessons, eq(courseLessons.lessonId, lessons.id))
+      .where(and(...conditions));
+  }
+
   async completeQuiz(
     courseId: UUIDType,
     lessonId: UUIDType,
@@ -452,6 +525,21 @@ export class LessonsRepository {
       .limit(1);
   }
 
+  async getLastLessonItemForUser(userId: UUIDType) {
+    const [lastLessonItem] = await this.db
+      .select({
+        id: studentCompletedLessonItems.lessonItemId,
+        lessonId: studentCompletedLessonItems.lessonId,
+        courseId: studentCompletedLessonItems.courseId,
+      })
+      .from(studentCompletedLessonItems)
+      .where(eq(studentCompletedLessonItems.studentId, userId))
+      .orderBy(desc(studentCompletedLessonItems.updatedAt))
+      .limit(1);
+
+    return lastLessonItem;
+  }
+
   async removeQuestionsAnswer(
     courseId: UUIDType,
     lessonId: UUIDType,

apps/api/src/statistics/api/statistics.controller.ts

@@ -1,16 +1,23 @@
 import { Controller, Get } from "@nestjs/common";
 
-import { BaseResponse, UUIDType } from "src/common";
+import { baseResponse, BaseResponse, UUIDType } from "src/common";
 import { CurrentUser } from "src/common/decorators/user.decorator";
 
 import { StatisticsService } from "../statistics.service";
+import { Validate } from "nestjs-typebox";
+import { UserStats, UserStatsSchema } from "../schemas/userStats.schema";
 
 @Controller("statistics")
 export class StatisticsController {
   constructor(private statisticsService: StatisticsService) {}
 
   @Get()
-  async getUserStatistics(@CurrentUser("userId") currentUserId: UUIDType) {
+  @Validate({
+    response: baseResponse(UserStatsSchema),
+  })
+  async getUserStatistics(
+    @CurrentUser("userId") currentUserId: UUIDType,
+  ): Promise<BaseResponse<UserStats>> {
     return new BaseResponse(await this.statisticsService.getUserStats(currentUserId));
   }
 }

apps/api/src/statistics/handlers/statistics.handler.ts

@@ -7,13 +7,17 @@ import { QuizCompletedEvent, UserActivityEvent, CourseStartedEvent } from "src/e
 import { StatisticsRepository } from "../repositories/statistics.repository";
 
 import type { IEventHandler } from "@nestjs/cqrs";
+import { StatisticsService } from "../statistics.service";
 
 type StatisticsEvent = QuizCompletedEvent | UserActivityEvent | CourseStartedEvent;
 
 @Injectable()
 @EventsHandler(QuizCompletedEvent, UserActivityEvent, CourseStartedEvent)
 export class StatisticsHandler implements IEventHandler<QuizCompletedEvent | UserActivityEvent> {
-  constructor(private readonly statisticsRepository: StatisticsRepository) {}
+  constructor(
+    private readonly statisticsRepository: StatisticsRepository,
+    private readonly statisticsService: StatisticsService,
+  ) {}
 
   async handle(event: StatisticsEvent) {
     try {
@@ -50,6 +54,6 @@ export class StatisticsHandler implements IEventHandler<QuizCompletedEvent | Use
   }
 
   private async handleUserActivity(event: UserActivityEvent) {
-    await this.statisticsRepository.updateUserActivity(event.userId);
+    await this.statisticsService.updateUserActivity(event.userId);
   }
 }