@hed-hog/lms 0.0.304 → 0.0.306

package/src/reports/reports.service.ts

@@ -0,0 +1,485 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+
+const MONTH_KEYS = [
+  'jan', 'feb', 'mar', 'apr', 'may', 'jun',
+  'jul', 'aug', 'sep', 'oct', 'nov', 'dec',
+];
+
+const WEEKDAY_KEYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+@Injectable()
+export class LmsReportsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async getReports(period: string) {
+    const now = new Date();
+    const start = this.periodToStart(period, now);
+    const periodMs = now.getTime() - start.getTime();
+    const prevStart = new Date(start.getTime() - periodMs);
+
+    const [
+      enrollmentsNow,
+      enrollmentsPrev,
+      totalStudentsAllTime,
+      totalStudentsCurrentPeriod,
+      totalStudentsPrevPeriod,
+      overallCompletion,
+      prevCompletion,
+      activeCount,
+      completedCount,
+      cancelledCount,
+      pendingCount,
+      allCourses,
+      allLearningPaths,
+      enrollmentsInPeriod,
+      allExamAttempts,
+      classSessions,
+      weeklyExamAttempts,
+    ] = await Promise.all([
+      // Enrollments in current period
+      this.prisma.course_enrollment.count({
+        where: { enrolled_at: { gte: start } },
+      }),
+      // Enrollments in previous period
+      this.prisma.course_enrollment.count({
+        where: { enrolled_at: { gte: prevStart, lt: start } },
+      }),
+      // All-time total students
+      this.prisma.course_enrollment.groupBy({
+        by: ['person_id'],
+      }),
+      // Unique students in current period
+      this.prisma.course_enrollment.groupBy({
+        by: ['person_id'],
+        where: { enrolled_at: { gte: start } },
+      }),
+      // Unique students in previous period
+      this.prisma.course_enrollment.groupBy({
+        by: ['person_id'],
+        where: { enrolled_at: { gte: prevStart, lt: start } },
+      }),
+      // Overall completion rate (all time)
+      this.prisma.course_enrollment.aggregate({
+        _avg: { progress_percent: true },
+        where: { status: { in: ['active', 'completed'] } },
+      }),
+      // Completion rate in previous period
+      this.prisma.course_enrollment.aggregate({
+        _avg: { progress_percent: true },
+        where: {
+          status: { in: ['active', 'completed'] },
+          enrolled_at: { gte: prevStart, lt: start },
+        },
+      }),
+      // Status distribution
+      this.prisma.course_enrollment.count({ where: { status: 'active' } }),
+      this.prisma.course_enrollment.count({ where: { status: 'completed' } }),
+      this.prisma.course_enrollment.count({
+        where: { status: { in: ['cancelled', 'paused'] } },
+      }),
+      this.prisma.course_enrollment.count({ where: { status: 'pending' } }),
+      // All courses with enrollment data for ranking
+      this.prisma.course.findMany({
+        include: {
+          _count: { select: { course_enrollment: true } },
+          course_enrollment: {
+            select: { progress_percent: true, final_score: true },
+          },
+        },
+        orderBy: [{ course_enrollment: { _count: 'desc' } }],
+      }),
+      // Learning paths with enrollment data for performance cards
+      this.prisma.learning_path.findMany({
+        where: {
+          learning_path_enrollment: { some: {} },
+        },
+        include: {
+          _count: { select: { learning_path_enrollment: true } },
+          learning_path_enrollment: { select: { progress_percent: true } },
+        },
+        orderBy: [{ learning_path_enrollment: { _count: 'desc' } }],
+      }),
+      // All enrollments in period for monthly chart + performance evolution
+      this.prisma.course_enrollment.findMany({
+        where: { enrolled_at: { gte: start } },
+        select: {
+          enrolled_at: true,
+          status: true,
+          progress_percent: true,
+          final_score: true,
+        },
+      }),
+      // Exam attempts for quality indicators
+      this.prisma.exam_attempt.findMany({
+        where: { status: 'completed', score: { not: null } },
+        select: {
+          score: true,
+          exam: { select: { min_score: true } },
+        },
+      }),
+      // Class sessions for weekly activity
+      this.prisma.course_class_session.findMany({
+        where: { session_date: { gte: start } },
+        select: { session_date: true },
+      }),
+      // Exam attempts in period for weekly exercises
+      this.prisma.exam_attempt.findMany({
+        where: {
+          status: 'completed',
+          finished_at: { gte: start },
+          score: { not: null },
+        },
+        select: { finished_at: true },
+      }),
+    ]);
+
+    // ── KPIs ──────────────────────────────────────────────────────────────────
+
+    const completionRateNow = Math.round(
+      overallCompletion._avg.progress_percent ?? 0,
+    );
+    const completionRatePrev = Math.round(
+      prevCompletion._avg.progress_percent ?? 0,
+    );
+    const enrollmentChange =
+      enrollmentsPrev > 0
+        ? this.round(
+            ((enrollmentsNow - enrollmentsPrev) / enrollmentsPrev) * 100,
+            1,
+          )
+        : 0;
+    const studentChange =
+      totalStudentsPrevPeriod.length > 0
+        ? this.round(
+            ((totalStudentsCurrentPeriod.length - totalStudentsPrevPeriod.length) /
+              totalStudentsPrevPeriod.length) *
+              100,
+            1,
+          )
+        : 0;
+
+    const kpis = {
+      totalStudents: {
+        value: totalStudentsAllTime.length,
+        change: studentChange,
+        positive: studentChange >= 0,
+      },
+      enrollments: {
+        value: enrollmentsNow,
+        change: enrollmentChange,
+        positive: enrollmentChange >= 0,
+      },
+      completionRate: {
+        value: completionRateNow,
+        change: this.round(completionRateNow - completionRatePrev, 1),
+        positive: completionRateNow >= completionRatePrev,
+      },
+      churnRate: {
+        value: cancelledCount,
+        change: 0,
+        positive: false,
+      },
+    };
+
+    // ── Monthly chart data ────────────────────────────────────────────────────
+
+    const monthlyData = this.buildMonthlyData(enrollmentsInPeriod, period, now);
+
+    // ── Course ranking ────────────────────────────────────────────────────────
+
+    const courseRanking = allCourses.map((c) => {
+      const progs = c.course_enrollment.map((e) => e.progress_percent ?? 0);
+      const finalScores = c.course_enrollment
+        .map((e) => e.final_score)
+        .filter((score): score is number => score !== null);
+      const avgProg =
+        progs.length > 0
+          ? progs.reduce((a, b) => a + b, 0) / progs.length
+          : 0;
+      const avgFinalScore =
+        finalScores.length > 0
+          ? finalScores.reduce((sum, score) => sum + score, 0) / finalScores.length
+          : null;
+
+      return {
+        id: c.id,
+        nome: c.title,
+        alunos: c._count.course_enrollment,
+        conclusao: Math.round(avgProg),
+        nota: this.resolveScore(avgFinalScore, avgProg),
+      };
+    });
+
+    // ── Learning path performance ─────────────────────────────────────────────
+
+    const categoryPerformance = allLearningPaths.map((path) => {
+      const progressValues = path.learning_path_enrollment.map(
+        (enrollment) => enrollment.progress_percent ?? 0,
+      );
+      const avgProgress =
+        progressValues.length > 0
+          ? progressValues.reduce((sum, value) => sum + value, 0) /
+            progressValues.length
+          : 0;
+
+      return {
+        area: path.title,
+        alunos: path._count.learning_path_enrollment,
+        conclusao: Math.round(avgProgress),
+        media: this.round(avgProgress / 10, 1),
+      };
+    });
+
+    // ── Student status distribution (pie) ─────────────────────────────────────
+
+    const studentStatus = [
+      { nome: 'active', valor: activeCount, cor: '#22c55e' },
+      { nome: 'completed', valor: completedCount, cor: '#3b82f6' },
+      { nome: 'inactive', valor: cancelledCount, cor: '#f97316' },
+      ...(pendingCount > 0
+        ? [{ nome: 'pending', valor: pendingCount, cor: '#a855f7' }]
+        : []),
+    ].filter((s) => s.valor > 0);
+
+    // ── Quality radar ─────────────────────────────────────────────────────────
+
+    const totalEnrollments =
+      activeCount + completedCount + cancelledCount + pendingCount;
+    const avgExamScore =
+      allExamAttempts.length > 0
+        ? allExamAttempts.reduce((s, a) => s + Number(a.score ?? 0), 0) /
+          allExamAttempts.length
+        : 0;
+
+    const engagementScore = Math.min(completionRateNow, 100);
+    const completionScore =
+      totalEnrollments > 0
+        ? Math.round((completedCount / totalEnrollments) * 100)
+        : 0;
+    const retentionScore =
+      totalEnrollments > 0
+        ? Math.round(
+            ((totalEnrollments - cancelledCount) / totalEnrollments) * 100,
+          )
+        : 100;
+    const performanceScore = Math.min(Math.round(avgExamScore), 100);
+    const satisfactionScore = Math.min(
+      Math.max(performanceScore, retentionScore - 5),
+      100,
+    );
+    const recommendationScore = Math.min(
+      Math.round((retentionScore + completionScore) / 2),
+      100,
+    );
+
+    const radarData = [
+      { subject: 'engagement', A: engagementScore, fullMark: 100 },
+      { subject: 'completion', A: completionScore, fullMark: 100 },
+      { subject: 'satisfaction', A: satisfactionScore, fullMark: 100 },
+      { subject: 'recommendation', A: recommendationScore, fullMark: 100 },
+      { subject: 'retention', A: retentionScore, fullMark: 100 },
+      { subject: 'performance', A: performanceScore, fullMark: 100 },
+    ];
+
+    // ── Weekly activity ───────────────────────────────────────────────────────
+
+    const weeklyActivity = this.buildWeeklyActivity(
+      enrollmentsInPeriod,
+      classSessions,
+      weeklyExamAttempts,
+    );
+
+    // ── Performance evolution (monthly) ──────────────────────────────────────
+
+    const performanceEvolution = this.buildPerformanceEvolution(
+      enrollmentsInPeriod,
+      period,
+      now,
+    );
+
+    return {
+      kpis,
+      monthlyData,
+      courseRanking,
+      categoryPerformance,
+      studentStatus,
+      radarData,
+      weeklyActivity,
+      performanceEvolution,
+    };
+  }
+
+  // ── Private helpers ─────────────────────────────────────────────────────────
+
+  private buildMonthlyData(
+    enrollments: Array<{
+      enrolled_at: Date;
+      status: string | null;
+      progress_percent: number | null;
+      final_score: number | null;
+    }>,
+    period: string,
+    now: Date,
+  ) {
+    const monthCount = this.periodToMonthCount(period);
+    const result: Array<{
+      mes: string;
+      matriculas: number;
+      cancelamentos: number;
+      receita: number;
+    }> = [];
+
+    for (let i = monthCount - 1; i >= 0; i--) {
+      const monthDate = this.addMonths(now, -i);
+      const monthStart = this.startOfMonth(monthDate);
+      const monthEnd = this.endOfMonth(monthDate);
+      const monthKey = MONTH_KEYS[monthDate.getMonth()];
+
+      const inMonth = enrollments.filter((e) => {
+        const d = new Date(e.enrolled_at);
+        return d >= monthStart && d <= monthEnd;
+      });
+
+      result.push({
+        mes: monthKey,
+        matriculas: inMonth.length,
+        cancelamentos: 0,
+        receita: 0,
+      });
+    }
+
+    return result;
+  }
+
+  private buildWeeklyActivity(
+    enrollments: Array<{ enrolled_at: Date }>,
+    classSessions: Array<{ session_date: Date }>,
+    examAttempts: Array<{ finished_at: Date | null }>,
+  ) {
+    const counts = Array.from({ length: 7 }, (_, i) => ({
+      dia: WEEKDAY_KEYS[i],
+      acessos: 0,
+      aulas: 0,
+      exercicios: 0,
+    }));
+
+    for (const e of enrollments) {
+      counts[new Date(e.enrolled_at).getDay()].acessos++;
+    }
+    for (const s of classSessions) {
+      counts[new Date(s.session_date).getDay()].aulas++;
+    }
+    for (const a of examAttempts) {
+      if (a.finished_at) {
+        counts[new Date(a.finished_at).getDay()].exercicios++;
+      }
+    }
+
+    // Mon → Sun order
+    return [1, 2, 3, 4, 5, 6, 0].map((d) => counts[d]);
+  }
+
+  private buildPerformanceEvolution(
+    enrollments: Array<{
+      enrolled_at: Date;
+      progress_percent: number | null;
+      final_score: number | null;
+    }>,
+    period: string,
+    now: Date,
+  ) {
+    const monthCount = this.periodToMonthCount(period);
+    const result: Array<{ mes: string; nota: number }> = [];
+
+    for (let i = monthCount - 1; i >= 0; i--) {
+      const monthDate = this.addMonths(now, -i);
+      const monthStart = this.startOfMonth(monthDate);
+      const monthEnd = this.endOfMonth(monthDate);
+      const monthKey = MONTH_KEYS[monthDate.getMonth()];
+
+      const inMonth = enrollments.filter((e) => {
+        const d = new Date(e.enrolled_at);
+        return d >= monthStart && d <= monthEnd;
+      });
+
+      const progressAvg =
+        inMonth.length > 0
+          ? inMonth.reduce((sum, enrollment) => {
+              return sum + (enrollment.progress_percent ?? 0);
+            }, 0) / inMonth.length
+          : 0;
+      const finalScores = inMonth
+        .map((enrollment) => enrollment.final_score)
+        .filter((score): score is number => score !== null);
+      const finalScoreAvg =
+        finalScores.length > 0
+          ? finalScores.reduce((sum, score) => sum + score, 0) / finalScores.length
+          : null;
+
+      result.push({
+        mes: monthKey,
+        nota: this.resolveScore(finalScoreAvg, progressAvg),
+      });
+    }
+
+    return result;
+  }
+
+  private resolveScore(
+    finalScoreAverage: number | null,
+    progressAverage: number,
+  ): number {
+    if (finalScoreAverage !== null) {
+      return this.round(finalScoreAverage / 10, 1);
+    }
+
+    return this.round(progressAverage / 10, 1);
+  }
+
+  private periodToStart(period: string, now: Date): Date {
+    if (period === '7d') return this.addDays(now, -7);
+    if (period === '30d') return this.addDays(now, -30);
+    if (period === '6m') return this.addMonths(now, -6);
+    return this.addMonths(now, -12);
+  }
+
+  private periodToMonthCount(period: string): number {
+    if (period === '7d' || period === '30d') return 1;
+    if (period === '6m') return 6;
+    return 12;
+  }
+
+  private addDays(date: Date, days: number): Date {
+    const d = new Date(date);
+    d.setDate(d.getDate() + days);
+    return d;
+  }
+
+  private addMonths(date: Date, months: number): Date {
+    const d = new Date(date);
+    d.setMonth(d.getMonth() + months);
+    return d;
+  }
+
+  private startOfMonth(date: Date): Date {
+    return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
+  }
+
+  private endOfMonth(date: Date): Date {
+    return new Date(
+      date.getFullYear(),
+      date.getMonth() + 1,
+      0,
+      23,
+      59,
+      59,
+      999,
+    );
+  }
+
+  private round(value: number, decimals: number): number {
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+  }
+}

package/src/training/dto/create-training.dto.ts

@@ -0,0 +1,81 @@
+import { Type } from 'class-transformer';
+import {
+    IsArray,
+    IsBoolean,
+    IsEnum,
+    IsIn,
+    IsInt,
+    IsNotEmpty,
+    IsOptional,
+    IsString,
+    MaxLength,
+    Min,
+    ValidateNested,
+} from 'class-validator';
+
+export class LearningPathItemDto {
+  @IsIn(['course', 'exam'])
+  type: 'course' | 'exam';
+
+  @IsInt()
+  @Min(1)
+  itemId: number;
+
+  @IsInt()
+  @Min(0)
+  @IsOptional()
+  order?: number;
+
+  @IsBoolean()
+  @IsOptional()
+  isRequired?: boolean;
+}
+
+export class CreateTrainingDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  title: string;
+
+  @IsString()
+  @IsOptional()
+  @MaxLength(255)
+  slug?: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsString()
+  @IsOptional()
+  shortDescription?: string;
+
+  @IsEnum(['beginner', 'intermediate', 'advanced'])
+  @IsOptional()
+  level?: 'beginner' | 'intermediate' | 'advanced';
+
+  @IsEnum(['draft', 'active', 'archived'])
+  @IsOptional()
+  status?: 'draft' | 'active' | 'archived';
+
+  @IsArray()
+  @IsInt({ each: true })
+  @IsOptional()
+  courseIds?: number[];
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => LearningPathItemDto)
+  @IsOptional()
+  items?: LearningPathItemDto[];
+
+  @IsString()
+  @IsOptional()
+  @MaxLength(32)
+  primaryColor?: string;
+
+  @IsString()
+  @IsOptional()
+  @MaxLength(32)
+  secondaryColor?: string;
+}

package/src/training/dto/update-training.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateTrainingDto } from './create-training.dto';
+
+export class UpdateTrainingDto extends PartialType(CreateTrainingDto) {}

package/src/training/training.controller.ts

@@ -0,0 +1,68 @@
+import { Role } from '@hed-hog/api';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+} from '@nestjs/common';
+import { CreateTrainingDto } from './dto/create-training.dto';
+import { UpdateTrainingDto } from './dto/update-training.dto';
+import { TrainingService } from './training.service';
+
+@Role()
+@Controller('lms/training')
+export class TrainingController {
+  constructor(private readonly trainingService: TrainingService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('level') level?: string,
+    @Query('area') area?: string,
+  ) {
+    return this.trainingService.list({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 12,
+      search,
+      status,
+      level,
+      area,
+    });
+  }
+
+  @Get('stats')
+  stats() {
+    return this.trainingService.stats();
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.trainingService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateTrainingDto) {
+    return this.trainingService.create(dto);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateTrainingDto,
+  ) {
+    return this.trainingService.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.trainingService.remove(id);
+  }
+}

package/src/training/training.module.ts

@@ -0,0 +1,12 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { TrainingController } from './training.controller';
+import { TrainingService } from './training.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [TrainingController],
+  providers: [TrainingService],
+  exports: [forwardRef(() => TrainingService)],
+})
+export class TrainingModule {}