@hed-hog/lms 0.0.355 → 0.0.358

package/src/enterprise/training/training-student.service.ts

@@ -5,6 +5,8 @@ import { BadRequestException, Injectable, NotFoundException } from '@nestjs/comm
 export class TrainingStudentService {
   constructor(private readonly prisma: PrismaService) {}
 
+  private readonly courseCardsLimit = 4;
+
   async registerStreakActivity(
     userId: number,
     payload?: { activityType?: string; source?: string; activityDateKey?: string },
@@ -68,6 +70,150 @@ export class TrainingStudentService {
     };
   }
 
+  async getPublishedCourses(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    category?: string;
+    sort?: string;
+  }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {
+      status: 'published',
+      is_listed: true,
+    };
+
+    const search = params.search?.trim();
+    const category = params.category?.trim();
+    const sort = params.sort?.trim();
+
+    if (search) {
+      where.OR = [
+        { title: { contains: search, mode: 'insensitive' } },
+        { description: { contains: search, mode: 'insensitive' } },
+        { slug: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+
+    if (category && category !== 'all') {
+      where.course_category = {
+        some: {
+          category: {
+            slug: category,
+          },
+        },
+      };
+    }
+
+    const orderBy = this.resolvePublishedCourseOrder(sort);
+
+    const [rows, total, categories] = await Promise.all([
+      this.prisma.course.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy,
+        select: {
+          id: true,
+          slug: true,
+          title: true,
+          description: true,
+          duration_hours: true,
+          level: true,
+          updated_at: true,
+          course_category: {
+            select: {
+              category: {
+                select: {
+                  slug: true,
+                },
+              },
+            },
+          },
+          course_image: {
+            where: { image_type: { slug: { in: ['course-banner', 'course-logo'] } } },
+            orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+            select: {
+              image_type: { select: { slug: true } },
+              file: { select: { location: true } },
+            },
+          },
+          course_module: {
+            select: {
+              _count: {
+                select: {
+                  course_lesson: true,
+                },
+              },
+            },
+          },
+          _count: {
+            select: {
+              course_enrollment: true,
+            },
+          },
+        },
+      }),
+      this.prisma.course.count({ where }),
+      this.prisma.category.findMany({
+        where: {
+          course_category: {
+            some: {
+              course: {
+                status: 'published',
+                is_listed: true,
+              },
+            },
+          },
+        },
+        select: {
+          slug: true,
+        },
+        orderBy: {
+          slug: 'asc',
+        },
+      }),
+    ]);
+
+    return {
+      data: rows.map((row) => {
+        const banner = row.course_image.find((image) => image.image_type?.slug === 'course-banner');
+        const logo = row.course_image.find((image) => image.image_type?.slug === 'course-logo');
+        const lessons = (row.course_module ?? []).reduce(
+          (sum, module) => sum + (module._count?.course_lesson ?? 0),
+          0,
+        );
+        const categorySlug = row.course_category[0]?.category?.slug ?? null;
+
+        return {
+          id: row.id,
+          slug: row.slug,
+          title: row.title,
+          description: row.description ?? '',
+          durationHours: row.duration_hours ?? 0,
+          level: row.level,
+          lessons,
+          image: banner?.file?.location ?? logo?.file?.location ?? null,
+          categoryKey: categorySlug,
+          categoryLabel: this.formatCategoryLabel(categorySlug),
+          enrollmentCount: row._count?.course_enrollment ?? 0,
+          updatedAt: row.updated_at,
+        };
+      }),
+      categories: categories.map((item) => ({
+        value: item.slug,
+        label: this.formatCategoryLabel(item.slug),
+      })),
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+    };
+  }
+
   async getDashboard(userId: number, enterpriseId?: number) {
     const personUser = await this.prisma.person_user.findFirst({
       where: { user_id: userId },
@@ -83,6 +229,37 @@ export class TrainingStudentService {
     const weekStart = this.startOfWeek(now);
     const weekEnd = this.endOfDay(this.addDays(weekStart, 6));
 
+    const profile = await this.prisma.person.findUnique({
+      where: { id: personId },
+      select: {
+        id: true,
+        name: true,
+        avatar_id: true,
+        person_user: {
+          where: { user_id: userId },
+          take: 1,
+          select: {
+            user: {
+              select: {
+                id: true,
+                name: true,
+                photo_id: true,
+                user_identifier: {
+                  where: { type: 'email' },
+                  orderBy: [{ verified_at: 'desc' }, { created_at: 'asc' }],
+                  take: 1,
+                  select: { value: true },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const profileUser = profile?.person_user?.[0]?.user ?? null;
+    const profileEmail = profileUser?.user_identifier?.[0]?.value ?? null;
+
     // Fetch all active enrollments for this student
     const enrollments = await this.prisma.course_enrollment.findMany({
       where: { person_id: personId, status: { not: 'cancelled' } },
@@ -116,21 +293,29 @@ export class TrainingStudentService {
       .filter((id): id is number => id != null);
     const enrollmentIds = enrollments.map((e) => e.id);
 
-    const [kpis, myClasses, onDemandCourses, weeklySchedule, ranking, gamification] = await Promise.all([
+    const [kpis, myClasses, onDemandCourses, weeklySchedule, ranking, gamification, courseCards] = await Promise.all([
       this.getKpis(personId, enrollments, enrollmentIds),
       this.getMyClasses(classEnrollments, now),
       this.getOnDemandCourses(onDemandEnrollments),
       this.getWeeklySchedule(cgIds, weekStart, weekEnd),
       this.getRanking(personId, cgIds),
       this.getGamification(personId, enrollmentIds, weekStart, weekEnd),
+      this.getDashboardCourseCards(personId),
     ]);
 
     const myRanking = ranking.find((r) => r.isMe);
 
     return {
+      user: {
+        id: profileUser?.id ?? userId,
+        name: profile?.name ?? profileUser?.name ?? null,
+        email: profileEmail,
+        avatarId: profile?.avatar_id ?? profileUser?.photo_id ?? null,
+      },
       kpis,
       myClasses,
       onDemandCourses,
+      courseCards,
       weeklySchedule,
       ranking,
       gamification: {
@@ -447,7 +632,11 @@ export class TrainingStudentService {
 
     const courseIds = onDemandEnrollments.map((e) => e.course_id);
     const courses = await this.prisma.course.findMany({
-      where: { id: { in: courseIds } },
+      where: {
+        id: { in: courseIds },
+        status: 'published',
+        is_listed: true,
+      },
       select: {
         id: true,
         title: true,
@@ -465,6 +654,10 @@ export class TrainingStudentService {
 
     return onDemandEnrollments.map((enrollment) => {
       const course = courseById.get(enrollment.course_id);
+      if (!course) {
+        return null;
+      }
+
       return {
         enrollmentId: enrollment.id,
         courseId: enrollment.course_id,
@@ -473,7 +666,162 @@ export class TrainingStudentService {
         durationHours: (course as any)?.duration_hours ?? null,
         progress: enrollment.progress_percent ?? 0,
       };
+    }).filter((course): course is NonNullable<typeof course> => !!course);
+  }
+
+  private async getDashboardCourseCards(personId: number) {
+    const startedEnrollments = await this.prisma.course_enrollment.findMany({
+      where: {
+        person_id: personId,
+        status: { not: 'cancelled' },
+        progress_percent: { gt: 0 },
+        course: {
+          status: 'published',
+          is_listed: true,
+        },
+      },
+      orderBy: [{ updated_at: 'desc' }, { enrolled_at: 'desc' }, { id: 'desc' }],
+      take: this.courseCardsLimit,
+      select: {
+        id: true,
+        progress_percent: true,
+        course: {
+          select: {
+            id: true,
+            slug: true,
+            title: true,
+            description: true,
+            duration_hours: true,
+            course_module: {
+              select: {
+                _count: {
+                  select: {
+                    course_lesson: true,
+                  },
+                },
+              },
+            },
+            course_image: {
+              where: { image_type: { slug: { in: ['course-banner', 'course-logo'] } } },
+              orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+              select: {
+                image_type: { select: { slug: true } },
+                file: { select: { location: true } },
+              },
+            },
+          },
+        },
+      },
     });
+
+    if (startedEnrollments.length > 0) {
+      return startedEnrollments.map((enrollment) => {
+        const course = enrollment.course;
+        const lessons = (course.course_module ?? []).reduce(
+          (sum, module) => sum + (module._count?.course_lesson ?? 0),
+          0,
+        );
+        const banner = course.course_image.find((image) => image.image_type?.slug === 'course-banner');
+        const logo = course.course_image.find((image) => image.image_type?.slug === 'course-logo');
+
+        return {
+          id: course.id,
+          slug: course.slug,
+          title: course.title,
+          description: course.description ?? 'Continue de onde parou.',
+          image: banner?.file?.location ?? logo?.file?.location ?? null,
+          progress: enrollment.progress_percent ?? 0,
+          lessons,
+          durationHours: course.duration_hours ?? 0,
+          inProgress: true,
+          source: 'started' as const,
+        };
+      });
+    }
+
+    const fallbackCourses = await this.prisma.course.findMany({
+      where: {
+        status: 'published',
+        is_listed: true,
+        offering_type: 'on_demand',
+      },
+      orderBy: [{ updated_at: 'desc' }, { created_at: 'desc' }, { id: 'desc' }],
+      take: this.courseCardsLimit,
+      select: {
+        id: true,
+        slug: true,
+        title: true,
+        description: true,
+        duration_hours: true,
+        course_module: {
+          select: {
+            _count: {
+              select: {
+                course_lesson: true,
+              },
+            },
+          },
+        },
+        course_image: {
+          where: { image_type: { slug: { in: ['course-banner', 'course-logo'] } } },
+          orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+          select: {
+            image_type: { select: { slug: true } },
+            file: { select: { location: true } },
+          },
+        },
+      },
+    });
+
+    return fallbackCourses.map((course) => {
+      const lessons = (course.course_module ?? []).reduce(
+        (sum, module) => sum + (module._count?.course_lesson ?? 0),
+        0,
+      );
+      const banner = course.course_image.find((image) => image.image_type?.slug === 'course-banner');
+      const logo = course.course_image.find((image) => image.image_type?.slug === 'course-logo');
+
+      return {
+        id: course.id,
+        slug: course.slug,
+        title: course.title,
+        description: course.description ?? 'Curso disponível para começar agora.',
+        image: banner?.file?.location ?? logo?.file?.location ?? null,
+        progress: 0,
+        lessons,
+        durationHours: course.duration_hours ?? 0,
+        inProgress: false,
+        source: 'on_demand' as const,
+      };
+    });
+  }
+
+  private resolvePublishedCourseOrder(sort?: string) {
+    switch (sort) {
+      case 'duracao':
+        return [{ duration_hours: 'asc' as const }, { updated_at: 'desc' as const }];
+      case 'populares':
+        return [{ course_enrollment: { _count: 'desc' as const } }, { updated_at: 'desc' as const }];
+      case 'recentes':
+        return [{ updated_at: 'desc' as const }, { created_at: 'desc' as const }];
+      case 'relevantes':
+      default:
+        return [
+          { is_featured: 'desc' as const },
+          { course_enrollment: { _count: 'desc' as const } },
+          { updated_at: 'desc' as const },
+        ];
+    }
+  }
+
+  private formatCategoryLabel(slug?: string | null) {
+    if (!slug) return 'Sem categoria';
+
+    return slug
+      .split(/[-_\s]+/)
+      .filter(Boolean)
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+      .join(' ');
   }
 
   private async getWeeklySchedule(cgIds: number[], weekStart: Date, weekEnd: Date) {

package/src/instructor/instructor.service.ts

@@ -928,7 +928,10 @@ export class InstructorService {
       status?: string;
     } = {},
   ) {
-    const { page = 1, pageSize = 6, search, status } = options;
+    const page = Math.max(Number(options.page) || 1, 1);
+    const pageSize = Math.min(Math.max(Number(options.pageSize) || 6, 1), 100);
+    const skip = (page - 1) * pageSize;
+    const { search, status } = options;
 
     const where: Prisma.course_class_groupWhereInput = {
       instructor_id: instructorId,
@@ -971,7 +974,7 @@ export class InstructorService {
             },
           },
         },
-        skip: (page - 1) * pageSize,
+        skip,
         take: pageSize,
       }),
       this.prisma.course_class_group.count({ where }),
@@ -999,6 +1002,12 @@ export class InstructorService {
       };
     });
 
-    return { data, total, page, pageSize, lastPage: Math.ceil(total / pageSize) };
+    return {
+      data,
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+    };
   }
 }

package/src/lms.module.ts

@@ -21,6 +21,7 @@ import { ExamModule } from './exam/exam.module';
 import { InstructorModule } from './instructor/instructor.module';
 import { LmsRealtimeModule } from './realtime/lms-realtime.module';
 import { LmsReportsModule } from './reports/reports.module';
+import { PlataformaController } from './platforma/platforma.controller';
 import { TrainingModule } from './training/training.module';
 import { VideoResolutionProfileModule } from './video-resolution-profile/video-resolution-profile.module';
 
@@ -50,6 +51,7 @@ import { VideoResolutionProfileModule } from './video-resolution-profile/video-r
     forwardRef(() => TrainingModule),
     forwardRef(() => VideoResolutionProfileModule),
   ],
+  controllers: [PlataformaController],
   providers: [CourseAudioTranscriptionService],
   exports: [
     forwardRef(() => AchievementModule),

package/src/platforma/platforma.controller.ts

@@ -0,0 +1,92 @@
+import { NoRole, User } from '@hed-hog/api';
+import { NotificationService } from '@hed-hog/core';
+import { Body, Controller, Get, Param, ParseIntPipe, Patch, Post, Query } from '@nestjs/common';
+import { TrainingStudentService } from '../enterprise/training/training-student.service';
+
+@NoRole()
+@Controller('lms/platforma')
+export class PlataformaController {
+  constructor(
+    private readonly trainingStudentService: TrainingStudentService,
+    private readonly notificationService: NotificationService,
+  ) {}
+
+  @Get()
+  getHome(@User('id') userId: number) {
+    return this.trainingStudentService.getDashboard(userId);
+  }
+
+  @Get('dashboard')
+  getDashboard(@User('id') userId: number) {
+    return this.trainingStudentService.getDashboard(userId);
+  }
+
+  @Get('courses')
+  getCourses(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('category') category?: string,
+    @Query('sort') sort?: string,
+  ) {
+    return this.trainingStudentService.getPublishedCourses({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 12,
+      search,
+      category,
+      sort,
+    });
+  }
+
+  @Get('notifications')
+  listNotifications(
+    @User('id') userId: number,
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('sortField') sortField?: string,
+    @Query('sortOrder') sortOrder?: 'asc' | 'desc',
+  ) {
+    return this.notificationService.list(userId, {
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 10,
+      search,
+      sortField,
+      sortOrder,
+    });
+  }
+
+  @Get('notifications/unread-count')
+  unreadNotificationsCount(@User('id') userId: number) {
+    return this.notificationService.unreadCount(userId);
+  }
+
+  @Patch('notifications/read-all')
+  markAllNotificationsRead(@User('id') userId: number) {
+    return this.notificationService.markAllRead(userId);
+  }
+
+  @Patch('notifications/:id/read')
+  markNotificationRead(
+    @User('id') userId: number,
+    @Param('id', ParseIntPipe) id: number,
+  ) {
+    return this.notificationService.markRead(userId, id);
+  }
+
+  @Get('streak')
+  getStreak(
+    @User('id') userId: number,
+    @Query('days', new ParseIntPipe({ optional: true })) days?: number,
+  ) {
+    return this.trainingStudentService.getStreak(userId, days);
+  }
+
+  @Post('streak/activities')
+  registerStreakActivity(
+    @User('id') userId: number,
+    @Body() body?: { activityType?: string; source?: string; activityDateKey?: string },
+  ) {
+    return this.trainingStudentService.registerStreakActivity(userId, body);
+  }
+}